ethagent 3.3.4 → 4.0.0

package/src/chat/ChatScreen.tsx

@@ -1,1685 +0,0 @@
-import React, { useCallback, useEffect, useMemo, useRef, useState } from 'react'
-import { Box, Text, useApp } from 'ink'
-import type { EthagentConfig } from '../storage/config.js'
-import type { Provider, Message } from '../providers/contracts.js'
-import { createProvider } from '../providers/registry.js'
-import { approximateTokens } from '../utils/messages.js'
-import {
-  dispatchSlash,
-  parseSlash,
-  getSlashSuggestions,
-  type SlashContext,
-} from './commands.js'
-import { theme } from '../ui/theme.js'
-import { BrandSplash } from '../ui/BrandSplash.js'
-import { SessionStatus, formatTokens } from './SessionStatus.js'
-import { formatModelDisplayName } from '../models/modelDisplay.js'
-import { providerDisplayName } from '../models/providerDisplay.js'
-import { toggleReasoningRow, type MessageRow } from './MessageList.js'
-import { ConversationStack } from './ConversationStack.js'
-import type { ModelPickerSelection } from '../models/ModelPicker.js'
-import type { ModelPickerContextFit } from '../models/modelPickerOptions.js'
-import type { CopyResult } from '../utils/clipboard.js'
-import { useKeybinding, useRegisterKeybindingContext } from '../app/keybindings/KeybindingProvider.js'
-import { TITLE_ANIMATION_FRAMES, TITLE_ANIMATION_INTERVAL_MS, TITLE_STATIC, setTerminalTitle } from '../ui/terminalTitle.js'
-import { useCancelRequest } from '../app/hooks/useCancelRequest.js'
-import { useExitOnCtrlC } from '../app/hooks/useExitOnCtrlC.js'
-import {
-  appendSessionMessage,
-  clearAllSessions,
-  ensureSessionMetadata,
-  loadSession,
-  loadSessionMetadata,
-  newSessionId,
-  updateSessionActivity,
-} from '../storage/sessions.js'
-import type { SessionMessage } from '../storage/sessions.js'
-import { loadPermissionRules, savePermissionRule } from '../storage/permissions.js'
-import { appendHistory, readHistory } from '../storage/history.js'
-import {
-  compactTranscript,
-  contextUsage,
-  contextUsageFromTokens,
-  summarizeTranscriptLocally,
-  shouldConfirmContextUsage,
-  type ContextUsage,
-} from '../runtime/compaction.js'
-import { fetchLlamaCppContextSize, onLlamaCppContextSizeChange, setCachedLlamaCppContextSize } from '../models/llamacpp.js'
-import { llamaCppServerHostFromBaseUrl } from '../models/llamacppPreflight.js'
-import { localProviderBaseUrlFor, saveConfig } from '../storage/config.js'
-import { getCwd as getRuntimeCwd, setCwd as setRuntimeCwd, syncCwdFromProcess } from '../runtime/cwd.js'
-import { executeToolWithPermissions } from '../runtime/toolExecution.js'
-import { nextSessionMode, sessionModeLabel, type PermissionMode, type SessionMode } from '../runtime/sessionMode.js'
-import type {
-  PermissionDecision,
-  PermissionRequest,
-  SessionPermissionRule,
-} from '../tools/contracts.js'
-import {
-  buildBaseMessages,
-  sessionMessagesToRows,
-  type TurnCheckpoint,
-} from './chatScreenUtils.js'
-import { ChatBottomPane, type ContextLimitState, type CopyPickerState, type IdentityOverlayState, type Overlay } from './ChatBottomPane.js'
-import { setTokenIdentity, getIdentityStatus } from '../storage/identity.js'
-import type { IdentityHubResult } from '../identity/hub/IdentityHub.js'
-import { continuityWorkingTreeStatus } from '../identity/continuity/storage.js'
-import { listPublishedContinuitySnapshots } from '../identity/continuity/snapshots.js'
-import { localChangeStatusView } from '../identity/hub/continuity/state.js'
-import {
-  buildResumedSessionState,
-  promptHistoryFromSessionMessages,
-  resolveModelSelection,
-  restoreConversationState,
-} from './chatSessionState.js'
-import { runStreamingTurn } from './chatTurnOrchestrator.js'
-import type { PlanApprovalAction } from './views/PlanApprovalView.js'
-import type { ContextLimitAction } from './views/ContextLimitView.js'
-import type { ContinuityEditReviewAction, ContinuityEditReviewState } from './views/ContinuityEditReviewView.js'
-import { openFileInEditor } from '../identity/continuity/editor.js'
-import { EMPTY_MCP_SNAPSHOT, McpManager, type McpSnapshot } from '../mcp/manager.js'
-import { compressHome, ensureLocalProviderReady } from './chatEnvironment.js'
-import {
-  buildPlanImplementationPrompt,
-  buildPlanTransferSeedMessages,
-  chatFooterShortcutText,
-  normalizeHandoffSummary,
-} from './planImplementation.js'
-import { privateContinuityEditReviewFromToolResult } from './continuityEditReview.js'
-
-export {
-  buildPlanImplementationPrompt,
-  buildPlanTransferSeedMessages,
-  chatFooterShortcutText,
-} from './planImplementation.js'
-export { privateContinuityEditReviewFromToolResult } from './continuityEditReview.js'
-
-type ChatScreenProps = {
-  config: EthagentConfig
-  onReplaceConfig?: (next: EthagentConfig) => void
-  updateNotice?: string | null
-}
-
-type PendingPlan = {
-  text: string
-  cwd: string
-  sessionId: string
-  provider: string
-  model: string
-  contextLabel: string
-  awaitingApproval: boolean
-}
-
-type CompactionKind = 'conversation' | 'plan'
-
-type CompactionUiState = {
-  kind: CompactionKind
-  progressRowId: string
-  sourceSessionId: string
-  startedAt: number
-  stage: string
-  controller: AbortController
-}
-
-let rowIdSeq = 0
-const nextRowId = (): string => `row-${++rowIdSeq}`
-const nowIso = (): string => new Date().toISOString()
-const STREAM_FLUSH_MS = 120
-const CONTEXT_CONFIRM_PERCENT = 90
-const MAX_PROMPT_HISTORY = 500
-
-export const ChatScreen: React.FC<ChatScreenProps> = ({ config: initialConfig, onReplaceConfig, updateNotice }) => {
-  useRegisterKeybindingContext('Chat')
-  const { exit } = useApp()
-  const [config, setConfig] = useState<EthagentConfig>(initialConfig)
-  const [rows, setRows] = useState<MessageRow[]>([])
-  const [history, setHistory] = useState<string[]>([])
-  const [streaming, setStreaming] = useState(false)
-  const [streamingStartedAt, setStreamingStartedAt] = useState<number | null>(null)
-  const [queuedInputs, setQueuedInputs] = useState<string[]>([])
-  const [turns, setTurns] = useState(0)
-  const [approxTokens, setApproxTokens] = useState(0)
-  const [overlay, setOverlay] = useState<Overlay>('none')
-  const [copyPickerState, setCopyPickerState] = useState<CopyPickerState>(null)
-  const [contextLimitState, setContextLimitState] = useState<ContextLimitState>(null)
-  const [continuityEditReview, setContinuityEditReview] = useState<ContinuityEditReviewState | null>(null)
-  const [modelPickerContextFit, setModelPickerContextFit] = useState<ModelPickerContextFit | null>(null)
-  const [identityOverlay, setIdentityOverlay] = useState<IdentityOverlayState | null>(null)
-  const [permissionRequest, setPermissionRequest] = useState<PermissionRequest | null>(null)
-  const [mode, setMode] = useState<SessionMode>('chat')
-  const [pendingPlan, setPendingPlan] = useState<PendingPlan | null>(null)
-  const [compactionUi, setCompactionUi] = useState<CompactionUiState | null>(null)
-  const [canScrollTranscript, setCanScrollTranscript] = useState(false)
-  const [sessionId, setSessionId] = useState<string>(() => newSessionId())
-  const [sessionKey, setSessionKey] = useState<number>(0)
-  const [cwd, setCwd] = useState<string>(() => syncCwdFromProcess())
-  const [statusStartedAt, setStatusStartedAt] = useState<number>(() => Date.now())
-  const [activeContextUsage, setActiveContextUsage] = useState<ContextUsage>(() =>
-    contextUsageFromTokens(0, initialConfig.provider, initialConfig.model),
-  )
-  const [mcpSnapshot, setMcpSnapshot] = useState<McpSnapshot>(EMPTY_MCP_SNAPSHOT)
-  const [pendingInputDraft, setPendingInputDraft] = useState<string | null>(null)
-
-  const rowsRef = useRef<MessageRow[]>([])
-  const visibleReasoningIdsRef = useRef<string[]>([])
-  const sessionMessagesRef = useRef<SessionMessage[]>([])
-  const sessionIdRef = useRef<string>(sessionId)
-  const globalHistoryRef = useRef<string[]>([])
-  const historyScopeRef = useRef<'global' | 'session'>('global')
-  const cwdRef = useRef<string>(getRuntimeCwd())
-  const overlayRef = useRef<Overlay>(overlay)
-  const modeRef = useRef<SessionMode>(mode)
-  const streamAbortRef = useRef<AbortController | null>(null)
-  const providerRef = useRef<Provider>(createProvider(initialConfig))
-  const configRef = useRef<EthagentConfig>(initialConfig)
-  const prevConfigRef = useRef<EthagentConfig>(initialConfig)
-  const compactingRef = useRef<boolean>(false)
-  const pendingAssistantTextRef = useRef<string | null>(null)
-  const pendingThinkingTextRef = useRef<string | null>(null)
-  const streamFlushTimerRef = useRef<ReturnType<typeof setTimeout> | null>(null)
-  const drainingQueueRef = useRef<boolean>(false)
-  const permissionResolveRef = useRef<((decision: PermissionDecision) => void) | null>(null)
-  const permissionRulesRef = useRef<SessionPermissionRule[]>([])
-  const activeCheckpointRef = useRef<TurnCheckpoint | undefined>(undefined)
-  const statsSegmentStartRef = useRef<number>(0)
-  const pendingPlanRef = useRef<PendingPlan | null>(null)
-  const compactionUiRef = useRef<CompactionUiState | null>(null)
-  const contextLimitStateRef = useRef<ContextLimitState>(null)
-  const pendingContinuityEditReviewRef = useRef<ContinuityEditReviewState | null>(null)
-  const contextModelSwitchPromptRef = useRef<string | null>(null)
-  const mcpManagerRef = useRef<McpManager | null>(null)
-  const savePromptShownRef = useRef<boolean>(false)
-
-  useEffect(() => { rowsRef.current = rows }, [rows])
-  useEffect(() => { overlayRef.current = overlay }, [overlay])
-  useEffect(() => { sessionIdRef.current = sessionId }, [sessionId])
-  useEffect(() => { cwdRef.current = cwd }, [cwd])
-  useEffect(() => { modeRef.current = mode }, [mode])
-  useEffect(() => { pendingPlanRef.current = pendingPlan }, [pendingPlan])
-  useEffect(() => { compactionUiRef.current = compactionUi }, [compactionUi])
-  useEffect(() => { contextLimitStateRef.current = contextLimitState }, [contextLimitState])
-
-  useEffect(() => {
-    if (prevConfigRef.current === config) return
-    prevConfigRef.current = config
-    configRef.current = config
-    providerRef.current = createProvider(config)
-  }, [config])
-
-  useEffect(() => {
-    void (async () => {
-      const loaded = await readHistory()
-      globalHistoryRef.current = loaded
-      if (historyScopeRef.current === 'global') setHistory(loaded)
-    })()
-  }, [])
-
-  useEffect(() => {
-    if (savePromptShownRef.current) return
-    savePromptShownRef.current = true
-    void (async () => {
-      try {
-        const identity = configRef.current.identity
-        if (!identity) return
-        const [latest] = await listPublishedContinuitySnapshots(identity, 1)
-        const status = await continuityWorkingTreeStatus(identity, latest)
-        if (!localChangeStatusView(status).hasLocalChanges) return
-        if (overlayRef.current !== 'none') return
-        setIdentityOverlay({
-          initialAction: 'save-prompt',
-          existing: { address: identity.address },
-        })
-        overlayRef.current = 'identity'
-        setOverlay('identity')
-      } catch {
-        // best-effort; skip prompt on any error
-      }
-    })()
-  }, [])
-
-  useEffect(() => {
-    void (async () => {
-      try {
-        permissionRulesRef.current = await loadPermissionRules(cwd)
-      } catch {
-        permissionRulesRef.current = []
-      }
-    })()
-  }, [cwd])
-
-  useEffect(() => {
-    void ensureSessionMetadata(sessionId, {
-      cwd,
-      provider: config.provider,
-      model: config.model,
-      mode,
-    })
-  }, [config.model, config.provider, cwd, mode, sessionId])
-
-  useEffect(() => {
-    void updateSessionActivity(
-      sessionId,
-      { cwd, provider: config.provider, model: config.model, mode },
-      { lastCwd: cwd, provider: config.provider, model: config.model, mode },
-    ).catch(() => {})
-  }, [config.model, config.provider, cwd, mode, sessionId])
-
-  useEffect(() => {
-    return () => {
-      streamAbortRef.current?.abort()
-      compactionUiRef.current?.controller.abort()
-      if (streamFlushTimerRef.current) clearTimeout(streamFlushTimerRef.current)
-      permissionResolveRef.current?.('deny')
-      void mcpManagerRef.current?.close()
-    }
-  }, [])
-
-  const updateRows = useCallback((updater: (prev: MessageRow[]) => MessageRow[]) => {
-    setRows(prev => updater(prev))
-  }, [])
-
-  const pushNote = useCallback(
-    (text: string, kind: 'info' | 'error' | 'dim' = 'info') => {
-      updateRows(prev => [...prev, { role: 'note', id: nextRowId(), kind, content: text }])
-    },
-    [updateRows],
-  )
-
-  useEffect(() => {
-    if (!mcpManagerRef.current) {
-      mcpManagerRef.current = new McpManager(cwd, setMcpSnapshot)
-    }
-    void mcpManagerRef.current.refresh(cwd).catch((err: unknown) => {
-      pushNote(`MCP refresh failed: ${(err as Error).message}`, 'error')
-    })
-  }, [cwd, pushNote])
-
-  const beginCompactionUi = useCallback((kind: CompactionKind, sourceSessionId: string): CompactionUiState => {
-    const progressRowId = nextRowId()
-    const state: CompactionUiState = {
-      kind,
-      progressRowId,
-      sourceSessionId,
-      startedAt: Date.now(),
-      stage: 'preparing transcript',
-      controller: new AbortController(),
-    }
-    compactionUiRef.current = state
-    setCompactionUi(state)
-    updateRows(prev => [
-      ...prev,
-      {
-        role: 'progress',
-        id: progressRowId,
-        title: kind === 'plan' ? 'summarizing plan context' : 'Compacting conversation',
-        progress: 0,
-        status: state.stage,
-        suffix: 'esc to cancel',
-        indeterminate: true,
-        startedAt: state.startedAt,
-      },
-    ])
-    return state
-  }, [updateRows])
-
-  const updateCompactionStage = useCallback((state: CompactionUiState, stage: string) => {
-    setCompactionUi(prev => prev?.progressRowId === state.progressRowId ? { ...prev, stage } : prev)
-    updateRows(prev => prev.map(row =>
-      row.id === state.progressRowId && row.role === 'progress'
-        ? { ...row, status: stage }
-        : row,
-    ))
-  }, [updateRows])
-
-  const removeCompactionProgress = useCallback((state: CompactionUiState) => {
-    updateRows(prev => prev.filter(row => row.id !== state.progressRowId))
-  }, [updateRows])
-
-  const toggleLatestReasoning = useCallback(() => {
-    const ids = visibleReasoningIdsRef.current
-    updateRows(rows => toggleReasoningRow(rows, ids[ids.length - 1]))
-  }, [updateRows])
-
-  const updateVisibleReasoningIds = useCallback((ids: string[]) => {
-    visibleReasoningIdsRef.current = ids
-  }, [])
-
-  const replaceConfig = useCallback(
-    (next: EthagentConfig) => {
-      configRef.current = next
-      providerRef.current = createProvider(next)
-      setConfig(next)
-      onReplaceConfig?.(next)
-    },
-    [onReplaceConfig],
-  )
-
-  const clearPendingPlan = useCallback(() => {
-    pendingPlanRef.current = null
-    setPendingPlan(null)
-    if (overlayRef.current === 'planApproval') {
-      overlayRef.current = 'none'
-      setOverlay('none')
-    }
-  }, [])
-
-  const clearContextLimit = useCallback(() => {
-    contextLimitStateRef.current = null
-    setContextLimitState(null)
-    if (overlayRef.current === 'contextLimit') {
-      overlayRef.current = 'none'
-      setOverlay('none')
-    }
-  }, [])
-
-  const openModelPicker = useCallback((contextFit?: ModelPickerContextFit | null, pendingPrompt?: string | null) => {
-    contextModelSwitchPromptRef.current = pendingPrompt ?? null
-    setModelPickerContextFit(contextFit ?? null)
-    overlayRef.current = 'modelPicker'
-    setOverlay('modelPicker')
-  }, [])
-
-  const handleModelPickerCancel = useCallback(() => {
-    const hadPendingPrompt = contextModelSwitchPromptRef.current !== null
-    contextModelSwitchPromptRef.current = null
-    setModelPickerContextFit(null)
-    overlayRef.current = 'none'
-    setOverlay('none')
-    if (hadPendingPrompt) pushNote('Pending message cancelled.', 'dim')
-  }, [pushNote])
-
-  const changeCwd = useCallback((next: string) => {
-    const updated = next === getRuntimeCwd() ? next : setRuntimeCwd(next, cwdRef.current)
-    cwdRef.current = updated
-    setCwd(updated)
-    clearPendingPlan()
-    setSessionKey(k => k + 1)
-  }, [clearPendingPlan])
-
-  const clearTranscript = useCallback(() => {
-    setRows([])
-    setTurns(0)
-    setApproxTokens(0)
-    setActiveContextUsage(contextUsageFromTokens(0, configRef.current.provider, configRef.current.model))
-    setQueuedInputs([])
-    clearPendingPlan()
-    clearContextLimit()
-    contextModelSwitchPromptRef.current = null
-    setModelPickerContextFit(null)
-    sessionMessagesRef.current = []
-    statsSegmentStartRef.current = 0
-    historyScopeRef.current = 'global'
-    setHistory(globalHistoryRef.current)
-    setStatusStartedAt(Date.now())
-    const nextId = newSessionId()
-    sessionIdRef.current = nextId
-    setSessionId(nextId)
-    setSessionKey(k => k + 1)
-  }, [clearContextLimit, clearPendingPlan])
-
-  const doExit = useCallback(() => {
-    streamAbortRef.current?.abort()
-    exit()
-  }, [exit])
-
-  const persistSessionMessage = useCallback(
-    async (msg: SessionMessage) => {
-      sessionMessagesRef.current = [...sessionMessagesRef.current, msg]
-      try {
-        await appendSessionMessage(sessionIdRef.current, msg, {
-          cwd: cwdRef.current,
-          provider: configRef.current.provider,
-          model: configRef.current.model,
-          mode: modeRef.current,
-        })
-      } catch {
-      }
-    },
-    [],
-  )
-
-  const refreshVisibleStats = useCallback(
-    (messages: SessionMessage[], providerSupportsTools: boolean, cwdForStats: string, configForStats: EthagentConfig, modeForStats: SessionMode): ContextUsage => {
-      const built = buildBaseMessages(messages, configForStats, providerSupportsTools, cwdForStats, modeForStats)
-      const tokens = approximateTokens(built)
-      const usage = contextUsageFromTokens(tokens, configForStats.provider, configForStats.model)
-      setTurns(messages.filter(message => message.role === 'user').length)
-      setApproxTokens(tokens)
-      setActiveContextUsage(usage)
-      return usage
-    },
-    [],
-  )
-
-  useEffect(() => {
-    if (config.provider !== 'llamacpp') return
-    const host = llamaCppServerHostFromBaseUrl(localProviderBaseUrlFor('llamacpp', config.baseUrl))
-    void fetchLlamaCppContextSize(host)
-    const unsubscribe = onLlamaCppContextSizeChange(() => {
-      refreshVisibleStats(
-        sessionMessagesRef.current,
-        providerRef.current.supportsTools,
-        cwdRef.current,
-        configRef.current,
-        modeRef.current,
-      )
-    })
-    return unsubscribe
-  }, [config.provider, config.baseUrl, refreshVisibleStats])
-
-  const warnIfContextPressure = useCallback(
-    (usage: ContextUsage, configForUsage: EthagentConfig) => {
-      if (!shouldConfirmContextUsage(usage, CONTEXT_CONFIRM_PERCENT)) return
-      const action = usage.percent >= 100
-        ? 'New requests will ask you to summarize into a new conversation, switch models, ignore and send, or cancel.'
-        : 'Run /compact before continuing, keep the next prompt short, switch models, or choose to send despite the warning.'
-      pushNote(
-        `current transcript is ${usage.percent}% of ${configForUsage.model}'s context (~${formatTokens(usage.usedTokens)} / ${formatTokens(usage.windowTokens)}). ${action}`,
-        usage.percent >= 100 ? 'error' : 'dim',
-      )
-    },
-    [pushNote],
-  )
-
-  const applyConfigChange = useCallback(
-    (next: EthagentConfig): ContextUsage => {
-      replaceConfig(next)
-      const usage = refreshVisibleStats(sessionMessagesRef.current, providerRef.current.supportsTools, cwdRef.current, next, modeRef.current)
-      warnIfContextPressure(usage, next)
-      return usage
-    },
-    [refreshVisibleStats, replaceConfig, warnIfContextPressure],
-  )
-
-  const attachActiveTurn = useCallback(<T extends SessionMessage>(message: T): T => {
-    const turnId = activeCheckpointRef.current?.turnId
-    if (!turnId) return message
-    return { ...message, turnId } as T
-  }, [])
-
-  const runCompaction = useCallback(
-    async (): Promise<boolean> => {
-      if (compactingRef.current) return false
-      const sourceSessionId = sessionIdRef.current
-      const sourceMessages = sessionMessagesRef.current
-      const priorMessages: Message[] = buildBaseMessages(
-        sourceMessages,
-        configRef.current,
-        providerRef.current.supportsTools,
-        cwdRef.current,
-        modeRef.current,
-      )
-      if (priorMessages.length <= 5) {
-        pushNote('Not enough turns to compact yet.', 'dim')
-        return false
-      }
-      compactingRef.current = true
-      const compaction = beginCompactionUi('conversation', sourceSessionId)
-      try {
-        const result = await compactTranscript(providerRef.current, priorMessages, {
-          signal: compaction.controller.signal,
-          onStage: stage => updateCompactionStage(compaction, stage),
-        })
-        if (!result.ok && result.cancelled) {
-          removeCompactionProgress(compaction)
-          pushNote('Compaction cancelled.', 'dim')
-          return false
-        }
-        const summary = result.ok
-          ? normalizeHandoffSummary(result.summary)
-          : normalizeHandoffSummary(summarizeTranscriptLocally(priorMessages, result.reason))
-        if (!result.ok) {
-          pushNote(`Provider summary failed; created a local summary instead: ${result.reason}`, 'dim')
-        }
-
-        updateCompactionStage(compaction, 'saving summarized conversation')
-        const nextSessionId = newSessionId()
-        const createdAt = nowIso()
-        const summaryMessage: SessionMessage = {
-          role: 'user',
-          synthetic: true,
-          content: [
-            `Conversation handoff from ${sourceSessionId.slice(0, 8)}:`,
-            '',
-            summary,
-          ].join('\n'),
-          createdAt,
-        }
-        const acknowledgement: SessionMessage = {
-          role: 'assistant',
-          content: 'Ready to continue from this summary.',
-          createdAt: nowIso(),
-          model: configRef.current.model,
-        }
-
-        const context = {
-          cwd: cwdRef.current,
-          provider: configRef.current.provider,
-          model: configRef.current.model,
-          mode: modeRef.current,
-        }
-        await ensureSessionMetadata(nextSessionId, context)
-        await updateSessionActivity(
-          nextSessionId,
-          context,
-          { compactedFromSessionId: sourceSessionId },
-        )
-        await appendSessionMessage(nextSessionId, summaryMessage, context)
-        await appendSessionMessage(nextSessionId, acknowledgement, context)
-
-        updateCompactionStage(compaction, 'opening summarized conversation')
-        const nextMessages = [summaryMessage, acknowledgement]
-        compactionUiRef.current = null
-        setCompactionUi(null)
-        sessionIdRef.current = nextSessionId
-        setSessionId(nextSessionId)
-        sessionMessagesRef.current = nextMessages
-        historyScopeRef.current = 'session'
-        setHistory(promptHistoryFromSessionMessages(nextMessages))
-        statsSegmentStartRef.current = 0
-        setRows([
-          {
-            role: 'note',
-            id: nextRowId(),
-            kind: 'dim',
-            content: `kept ${sourceSessionId.slice(0, 8)} saved; summarized into ${nextSessionId.slice(0, 8)}.`,
-          },
-          ...sessionMessagesToRows(nextMessages, nextRowId),
-        ])
-        setQueuedInputs([])
-        setStatusStartedAt(Date.now())
-        refreshVisibleStats(nextMessages, providerRef.current.supportsTools, cwdRef.current, configRef.current, modeRef.current)
-        setSessionKey(key => key + 1)
-        return true
-      } catch (err: unknown) {
-        removeCompactionProgress(compaction)
-        if (compaction.controller.signal.aborted) {
-          pushNote('Compaction cancelled.', 'dim')
-        } else {
-          pushNote(`Compact error: ${(err as Error).message}`, 'error')
-        }
-        return false
-      } finally {
-        compactingRef.current = false
-        compactionUiRef.current = null
-        setCompactionUi(null)
-      }
-    },
-    [beginCompactionUi, pushNote, refreshVisibleStats, removeCompactionProgress, updateCompactionStage],
-  )
-
-  const runCompactionFromTurn = useCallback(
-    async (turnId: string): Promise<boolean> => {
-      if (compactingRef.current) return false
-      const sourceSessionId = sessionIdRef.current
-      const all = sessionMessagesRef.current
-      const splitIndex = all.findIndex(m => m.turnId === turnId)
-      if (splitIndex < 0) {
-        pushNote('Could not find that prompt to summarize from.', 'error')
-        return false
-      }
-      const before = all.slice(0, splitIndex)
-      const from = all.slice(splitIndex)
-      const fromBase = buildBaseMessages(
-        from,
-        configRef.current,
-        providerRef.current.supportsTools,
-        cwdRef.current,
-        modeRef.current,
-      )
-      if (fromBase.length <= 2) {
-        pushNote('Not enough messages from that point to summarize.', 'dim')
-        return false
-      }
-      compactingRef.current = true
-      const compaction = beginCompactionUi('conversation', sourceSessionId)
-      try {
-        const result = await compactTranscript(providerRef.current, fromBase, {
-          signal: compaction.controller.signal,
-          onStage: stage => updateCompactionStage(compaction, stage),
-        })
-        if (!result.ok && result.cancelled) {
-          removeCompactionProgress(compaction)
-          pushNote('Compaction cancelled.', 'dim')
-          return false
-        }
-        const summary = result.ok
-          ? normalizeHandoffSummary(result.summary)
-          : normalizeHandoffSummary(summarizeTranscriptLocally(fromBase, result.reason))
-        if (!result.ok) {
-          pushNote(`Provider summary failed; created a local summary instead: ${result.reason}`, 'dim')
-        }
-        updateCompactionStage(compaction, 'saving summarized conversation')
-        const nextSessionId = newSessionId()
-        const summaryMessage: SessionMessage = {
-          role: 'user',
-          synthetic: true,
-          content: [
-            `Conversation handoff from ${sourceSessionId.slice(0, 8)} (summarized from a chosen prompt forward):`,
-            '',
-            summary,
-          ].join('\n'),
-          createdAt: nowIso(),
-        }
-        const acknowledgement: SessionMessage = {
-          role: 'assistant',
-          content: 'Ready to continue from this summary.',
-          createdAt: nowIso(),
-          model: configRef.current.model,
-        }
-        const context = {
-          cwd: cwdRef.current,
-          provider: configRef.current.provider,
-          model: configRef.current.model,
-          mode: modeRef.current,
-        }
-        await ensureSessionMetadata(nextSessionId, context)
-        await updateSessionActivity(nextSessionId, context, { compactedFromSessionId: sourceSessionId })
-        for (const msg of before) {
-          await appendSessionMessage(nextSessionId, msg, context)
-        }
-        await appendSessionMessage(nextSessionId, summaryMessage, context)
-        await appendSessionMessage(nextSessionId, acknowledgement, context)
-
-        updateCompactionStage(compaction, 'opening summarized conversation')
-        const nextMessages: SessionMessage[] = [...before, summaryMessage, acknowledgement]
-        compactionUiRef.current = null
-        setCompactionUi(null)
-        sessionIdRef.current = nextSessionId
-        setSessionId(nextSessionId)
-        sessionMessagesRef.current = nextMessages
-        historyScopeRef.current = 'session'
-        setHistory(promptHistoryFromSessionMessages(nextMessages))
-        statsSegmentStartRef.current = 0
-        setRows([
-          {
-            role: 'note',
-            id: nextRowId(),
-            kind: 'dim',
-            content: `kept ${sourceSessionId.slice(0, 8)} saved; summarized from a chosen prompt into ${nextSessionId.slice(0, 8)}.`,
-          },
-          ...sessionMessagesToRows(nextMessages, nextRowId),
-        ])
-        setQueuedInputs([])
-        setStatusStartedAt(Date.now())
-        refreshVisibleStats(nextMessages, providerRef.current.supportsTools, cwdRef.current, configRef.current, modeRef.current)
-        setSessionKey(key => key + 1)
-        return true
-      } catch (err: unknown) {
-        removeCompactionProgress(compaction)
-        if (compaction.controller.signal.aborted) {
-          pushNote('Compaction cancelled.', 'dim')
-        } else {
-          pushNote(`Compact error: ${(err as Error).message}`, 'error')
-        }
-        return false
-      } finally {
-        compactingRef.current = false
-        compactionUiRef.current = null
-        setCompactionUi(null)
-      }
-    },
-    [beginCompactionUi, pushNote, refreshVisibleStats, removeCompactionProgress, updateCompactionStage],
-  )
-
-  const assistantTurns = useCallback((): string[] => {
-    const out: string[] = []
-    for (const message of sessionMessagesRef.current) {
-      if (message.role === 'assistant' && message.content) out.push(message.content)
-    }
-    return out
-  }, [])
-
-  const buildSlashContext = useCallback(
-    (): SlashContext => ({
-      config: configRef.current,
-      turns,
-      approxTokens,
-      contextUsage: activeContextUsage,
-      startedAt: statusStartedAt,
-      sessionId: sessionIdRef.current,
-      cwd,
-      sessionMessages: () => sessionMessagesRef.current,
-      mode,
-      assistantTurns,
-      onReplaceConfig: applyConfigChange,
-      onChangeCwd: changeCwd,
-      onClear: clearTranscript,
-      onExit: doExit,
-      onResumeRequest: () => setOverlay('resume'),
-      onModelPickerRequest: () => openModelPicker(),
-      onRewindRequest: () => setOverlay('rewind'),
-      onPermissionsRequest: () => setOverlay('permissions'),
-      onCompactRequest: () => { void runCompaction() },
-      onIdentityRequest: action => {
-        void (async () => {
-          const status = await getIdentityStatus(configRef.current)
-          const initialAction = action === 'create' || action === 'load' ? action : undefined
-          setIdentityOverlay({
-            initialAction,
-            existing: status ? { address: status.address } : null,
-          })
-          setOverlay('identity')
-        })()
-      },
-      onCopyPickerRequest: (turnText, turnLabel) => {
-        setCopyPickerState({ turnText, turnLabel })
-        setOverlay('copyPicker')
-      },
-      mcp: mcpManagerRef.current ?? undefined,
-    }),
-    [
-      turns,
-      approxTokens,
-      statusStartedAt,
-      assistantTurns,
-      applyConfigChange,
-      changeCwd,
-      clearTranscript,
-      doExit,
-      openModelPicker,
-      runCompaction,
-      cwd,
-      mode,
-      activeContextUsage,
-    ],
-  )
-
-  const requestPermission = useCallback(
-    async (request: PermissionRequest): Promise<PermissionDecision> => {
-      setPermissionRequest(request)
-      setOverlay('permission')
-      return await new Promise<PermissionDecision>(resolve => {
-        permissionResolveRef.current = resolve
-      })
-    },
-    [],
-  )
-
-  const resolvePermission = useCallback((decision: PermissionDecision) => {
-    const resolve = permissionResolveRef.current
-    permissionResolveRef.current = null
-    setPermissionRequest(null)
-    setOverlay('none')
-    resolve?.(decision)
-  }, [])
-
-  const executeTool = useCallback(
-    async (
-      name: string,
-      input: Record<string, unknown>,
-      permissionMode: PermissionMode,
-    ): Promise<{ result: { ok: boolean; summary: string; content: string }; sessionRule?: SessionPermissionRule; persistRule?: boolean }> => {
-      const outcome = await executeToolWithPermissions({
-        name,
-        input,
-        permissionMode,
-        cwd: cwdRef.current,
-        config: configRef.current,
-        checkpoint: activeCheckpointRef.current,
-        abortSignal: streamAbortRef.current?.signal,
-        dynamicTools: mcpManagerRef.current?.getTools() ?? [],
-        mcp: mcpManagerRef.current ?? undefined,
-        getPermissionRules: () => permissionRulesRef.current,
-        requestPermission,
-        onDirectoryChange: next => {
-          cwdRef.current = next
-          setCwd(next)
-        },
-      })
-      const review = privateContinuityEditReviewFromToolResult(name, input, outcome.result)
-      if (review) pendingContinuityEditReviewRef.current = review
-      return outcome
-    },
-    [requestPermission],
-  )
-
-  const applySessionRule = useCallback(
-    async (sessionRule?: SessionPermissionRule, persistRule?: boolean) => {
-      if (!sessionRule) return
-      permissionRulesRef.current = [...permissionRulesRef.current, sessionRule]
-      if (!persistRule) return
-      try {
-        await savePermissionRule(cwdRef.current, sessionRule)
-      } catch (error: unknown) {
-        pushNote(`Failed to save permission rule: ${(error as Error).message}`, 'error')
-      }
-    },
-    [pushNote],
-  )
-
-  const runStream = useCallback(
-    async (userText: string, modeOverride?: SessionMode) => {
-      const activeMode = modeOverride ?? mode
-      const turnProvider = createProvider(configRef.current, {
-        mode: activeMode,
-        dynamicTools: mcpManagerRef.current?.getTools() ?? [],
-      })
-      const controller = new AbortController()
-      streamAbortRef.current = controller
-      let planCandidate: PendingPlan | null = null
-      const setStreamingWithStart = (value: boolean) => {
-        setStreaming(value)
-        setStreamingStartedAt(value ? Date.now() : null)
-      }
-      const result = await runStreamingTurn({
-        provider: turnProvider,
-        mode: activeMode,
-        sessionId: sessionIdRef.current,
-        userText,
-        streamFlushMs: STREAM_FLUSH_MS,
-        controller,
-        nextRowId,
-        nowIso,
-        getConfig: () => configRef.current,
-        getCwd: () => cwdRef.current,
-        getDisplayCwd: () => compressHome(cwdRef.current),
-        getSessionMessages: () => sessionMessagesRef.current,
-        setActiveCheckpoint: checkpoint => { activeCheckpointRef.current = checkpoint },
-        setStreaming: setStreamingWithStart,
-        updateRows,
-        pushNote,
-        persistTurnMessage: message => persistSessionMessage(attachActiveTurn(message)),
-        executeTool,
-        applySessionRule,
-        preflightProvider: () => ensureLocalProviderReady(configRef.current),
-        onPlanReady: plan => {
-          planCandidate = {
-            text: plan,
-            cwd: cwdRef.current,
-            sessionId: sessionIdRef.current,
-            provider: configRef.current.provider,
-            model: configRef.current.model,
-            contextLabel: formatContextLabel(
-              contextUsage(buildBaseMessages(sessionMessagesRef.current, configRef.current, turnProvider.supportsTools, cwdRef.current, activeMode), configRef.current.provider, configRef.current.model),
-            ),
-            awaitingApproval: true,
-          }
-          pendingPlanRef.current = planCandidate
-          setPendingPlan(planCandidate)
-        },
-        onContextExceeded: ({ contextLimit }) => {
-          setCachedLlamaCppContextSize(contextLimit)
-          pushNote('Context full. Compacting transcript. Re-send your message once compaction finishes.', 'dim')
-          void runCompaction()
-        },
-        pendingAssistantTextRef,
-        pendingThinkingTextRef,
-        streamFlushTimerRef,
-      })
-      refreshVisibleStats(sessionMessagesRef.current, turnProvider.supportsTools, cwdRef.current, configRef.current, activeMode)
-      streamAbortRef.current = null
-      if (
-        result.finishedNormally &&
-        activeMode === 'plan' &&
-        planCandidate &&
-        pendingPlanRef.current === planCandidate &&
-        overlayRef.current === 'none'
-      ) {
-        overlayRef.current = 'planApproval'
-        setOverlay('planApproval')
-      }
-    },
-    [applySessionRule, attachActiveTurn, executeTool, mode, persistSessionMessage, pushNote, refreshVisibleStats, updateRows],
-  )
-
-  const pullInFlight = false
-
-  useEffect(() => {
-    if (overlay !== 'none' || streaming || pullInFlight || compactionUi) return
-    const pending = pendingContinuityEditReviewRef.current
-    if (!pending) return
-    pendingContinuityEditReviewRef.current = null
-    setContinuityEditReview(pending)
-    overlayRef.current = 'continuityEditReview'
-    setOverlay('continuityEditReview')
-  }, [compactionUi, overlay, pullInFlight, streaming])
-
-  const projectedUsageForInput = useCallback((userText: string, modeOverride?: SessionMode): ContextUsage => {
-    const activeMode = modeOverride ?? modeRef.current
-    const turnProvider = createProvider(configRef.current, {
-      mode: activeMode,
-      dynamicTools: mcpManagerRef.current?.getTools() ?? [],
-    })
-    const projectedMessages: SessionMessage[] = [
-      ...sessionMessagesRef.current,
-      { role: 'user', content: userText, createdAt: nowIso() },
-    ]
-    return contextUsage(
-      buildBaseMessages(projectedMessages, configRef.current, turnProvider.supportsTools, cwdRef.current, activeMode),
-      configRef.current.provider,
-      configRef.current.model,
-    )
-  }, [])
-
-  const showContextLimitForPrompt = useCallback((prompt: string): ContextUsage => {
-    contextModelSwitchPromptRef.current = null
-    setModelPickerContextFit(null)
-    const projected = projectedUsageForInput(prompt)
-    contextLimitStateRef.current = { usage: projected, prompt }
-    setContextLimitState(contextLimitStateRef.current)
-    overlayRef.current = 'contextLimit'
-    setOverlay('contextLimit')
-    return projected
-  }, [projectedUsageForInput])
-
-  const continuePendingPromptAfterModelSwitch = useCallback(
-    async (prompt: string | null) => {
-      if (!prompt) {
-        setModelPickerContextFit(null)
-        return
-      }
-      contextModelSwitchPromptRef.current = null
-      setModelPickerContextFit(null)
-      const projected = projectedUsageForInput(prompt)
-      if (shouldConfirmContextUsage(projected, CONTEXT_CONFIRM_PERCENT)) {
-        contextLimitStateRef.current = { usage: projected, prompt }
-        setContextLimitState(contextLimitStateRef.current)
-        overlayRef.current = 'contextLimit'
-        setOverlay('contextLimit')
-        pushNote(
-          `selected model is still ${projected.percent}% of its context (~${formatTokens(projected.usedTokens)} / ${formatTokens(projected.windowTokens)}).`,
-          projected.percent >= 100 ? 'error' : 'dim',
-        )
-        return
-      }
-      await runStream(prompt)
-    },
-    [projectedUsageForInput, pushNote, runStream],
-  )
-
-  const handleSubmit = useCallback(
-    async (value: string) => {
-      const trimmed = value.trim()
-      if (!trimmed) return
-
-      setHistory(h => appendPromptHistoryEntry(h, value))
-      globalHistoryRef.current = appendPromptHistoryEntry(globalHistoryRef.current, value)
-      void appendHistory(value)
-
-      if (streaming || pullInFlight || compactionUiRef.current) {
-        setQueuedInputs(prev => [...prev, value])
-        return
-      }
-
-      if (parseSlash(value)) {
-        const ctx = buildSlashContext()
-        const result = await dispatchSlash(value, ctx)
-        if (result && result.kind === 'note') {
-          pushNote(result.text, result.variant ?? 'info')
-        }
-        if (result && result.kind === 'submit') {
-          const projected = projectedUsageForInput(result.text)
-          if (shouldConfirmContextUsage(projected, CONTEXT_CONFIRM_PERCENT)) {
-            showContextLimitForPrompt(result.text)
-            return
-          }
-          await runStream(result.text)
-        }
-        return
-      }
-
-      const projected = projectedUsageForInput(value)
-      if (shouldConfirmContextUsage(projected, CONTEXT_CONFIRM_PERCENT)) {
-        showContextLimitForPrompt(value)
-        return
-      }
-
-      await runStream(value)
-    },
-    [buildSlashContext, pullInFlight, projectedUsageForInput, pushNote, runStream, showContextLimitForPrompt, streaming],
-  )
-
-  const handleContextLimitCancel = useCallback(() => {
-    clearContextLimit()
-    pushNote('Pending message cancelled.', 'dim')
-  }, [clearContextLimit, pushNote])
-
-  const handleContextLimitAction = useCallback(
-    async (action: ContextLimitAction) => {
-      const state = contextLimitStateRef.current
-      if (!state) {
-        clearContextLimit()
-        return
-      }
-      const prompt = state.prompt
-      clearContextLimit()
-      if (action === 'cancel') {
-        pushNote('Pending message cancelled.', 'dim')
-        return
-      }
-      if (action === 'switchModel') {
-        openModelPicker(
-          { usedTokens: state.usage.usedTokens, thresholdPercent: CONTEXT_CONFIRM_PERCENT },
-          prompt,
-        )
-        return
-      }
-      if (action === 'compact') {
-        const compacted = await runCompaction()
-        if (!compacted) return
-        setHistory(h => appendPromptHistoryEntry(h, prompt))
-      }
-      if (action === 'send') {
-        pushNote(
-          'sending despite context warning; this may hit provider rate/context limits faster or degrade model/tool behavior.',
-          'dim',
-        )
-      }
-      await runStream(prompt)
-    },
-    [clearContextLimit, openModelPicker, pushNote, runCompaction, runStream],
-  )
-
-  const handleCancelActive = useCallback(() => {
-    if (streaming && streamAbortRef.current) {
-      streamAbortRef.current.abort()
-      return
-    }
-    compactionUiRef.current?.controller.abort()
-  }, [streaming])
-
-  useCancelRequest({
-    abortSignal: streaming ? streamAbortRef.current?.signal : compactionUi?.controller.signal,
-    onCancel: handleCancelActive,
-    isActive: overlay === 'none',
-  })
-
-  const exitState = useExitOnCtrlC({
-    isActive: overlay === 'none',
-    onInterrupt: () => {
-      if (streaming && streamAbortRef.current) {
-        streamAbortRef.current.abort()
-        return true
-      }
-      if (compactionUiRef.current) {
-        compactionUiRef.current.controller.abort()
-        return true
-      }
-      return false
-    },
-    onExit: doExit,
-  })
-
-  useKeybinding(
-    'chat:modelPicker',
-    () => { if (overlay === 'none') openModelPicker() },
-    { context: 'Chat', isActive: overlay === 'none' },
-  )
-
-  useKeybinding(
-    'chat:identityHub',
-    () => {
-      if (overlay !== 'none') return
-      setIdentityOverlay({
-        initialAction: undefined,
-        existing: configRef.current.identity ? { address: configRef.current.identity.address } : null,
-      })
-      setOverlay('identity')
-    },
-    { context: 'Chat', isActive: overlay === 'none' },
-  )
-
-  useKeybinding(
-    'chat:toggleReasoning',
-    () => { if (overlay === 'none') toggleLatestReasoning() },
-    { context: 'Chat', isActive: overlay === 'none' },
-  )
-
-  useKeybinding(
-    'chat:cycleMode',
-    () => {
-      if (overlay !== 'none') return
-      const nextMode = nextSessionMode(mode)
-      modeRef.current = nextMode
-      setMode(nextMode)
-      if (nextMode !== 'plan') clearPendingPlan()
-    },
-    { context: 'Chat', isActive: overlay === 'none' },
-  )
-
-  useKeybinding(
-    'app:redraw',
-    () => setSessionKey(k => k + 1),
-    { context: 'Global' },
-  )
-
-  const handleModelPick = useCallback(
-    async (sel: ModelPickerSelection) => {
-      const pendingPrompt = contextModelSwitchPromptRef.current
-      overlayRef.current = 'none'
-      setOverlay('none')
-      const resolution = resolveModelSelection(sel, configRef.current)
-      if (resolution.kind === 'noop') {
-        if (pendingPrompt) showContextLimitForPrompt(pendingPrompt)
-        return
-      }
-      try {
-        await saveConfig(resolution.config)
-        applyConfigChange(resolution.config)
-        pushNote(resolution.notice, resolution.tone)
-        await continuePendingPromptAfterModelSwitch(pendingPrompt)
-      } catch (err: unknown) {
-        pushNote(`Provider switch failed: ${(err as Error).message}`, 'error')
-        if (pendingPrompt) showContextLimitForPrompt(pendingPrompt)
-      }
-    },
-    [applyConfigChange, continuePendingPromptAfterModelSwitch, pushNote, showContextLimitForPrompt],
-  )
-
-  const handleResumePick = useCallback(
-    async (id: string) => {
-      setOverlay('none')
-      try {
-        const [loaded, metadata] = await Promise.all([loadSession(id), loadSessionMetadata(id)])
-        if (loaded.length === 0) {
-          pushNote('Session was empty.', 'error')
-          return
-        }
-        const resumed = buildResumedSessionState({
-          messages: loaded,
-          metadata,
-          fallbackCwd: cwd,
-          nextRowId,
-        })
-        const resumedCwd = resumed.cwd
-        if (resumedCwd) {
-          try {
-            const updated = setRuntimeCwd(resumedCwd)
-            cwdRef.current = updated
-            setCwd(updated)
-          } catch {
-            cwdRef.current = resumedCwd
-            setCwd(resumedCwd)
-          }
-        }
-        clearPendingPlan()
-        clearContextLimit()
-        modeRef.current = resumed.mode
-        setMode(resumed.mode)
-        sessionIdRef.current = id
-        setSessionId(id)
-        sessionMessagesRef.current = loaded
-        historyScopeRef.current = 'session'
-        setHistory(resumed.promptHistory)
-        statsSegmentStartRef.current = 0
-        setStatusStartedAt(resumed.statusStartedAt)
-        setRows(resumed.rows)
-        refreshVisibleStats(loaded, providerRef.current.supportsTools, resumedCwd, configRef.current, resumed.mode)
-        setSessionKey(k => k + 1)
-      } catch (err: unknown) {
-        pushNote(`Resume failed: ${(err as Error).message}`, 'error')
-      }
-    },
-    [clearContextLimit, clearPendingPlan, cwd, pushNote, refreshVisibleStats],
-  )
-
-  const handleResumeClearAll = useCallback(
-    async () => {
-      await clearAllSessions()
-      clearTranscript()
-      overlayRef.current = 'none'
-      setOverlay('none')
-      pushNote('Cleared saved sessions and resume context from this machine.', 'dim')
-    },
-    [clearTranscript, pushNote],
-  )
-
-  const handleIdentityResult = useCallback(
-    (result: IdentityHubResult) => {
-      setOverlay('none')
-      setIdentityOverlay(null)
-      if (result.kind === 'updated') {
-        applyConfigChange(result.config)
-        pushNote(result.message, 'info')
-        return
-      }
-      if (result.kind === 'token') {
-        void (async () => {
-          try {
-            const nextConfig = await setTokenIdentity(configRef.current, result.identity)
-            applyConfigChange(nextConfig)
-            pushNote(`Identity saved · ERC-8004 #${result.identity.agentId}`, 'info')
-          } catch (err: unknown) {
-            pushNote(`Identity save failed: ${(err as Error).message}`, 'error')
-          }
-        })()
-      }
-    },
-    [applyConfigChange, pushNote],
-  )
-
-  const handleContinuityEditReviewAction = useCallback(
-    async (action: ContinuityEditReviewAction) => {
-      const review = continuityEditReview
-      if (!review) return
-      if (action === 'open') {
-        const result = await openFileInEditor(review.filePath)
-        pushNote(
-          result.ok
-            ? `opened ${review.file} with ${result.method}.`
-            : `open failed: ${result.error}`,
-          result.ok ? 'dim' : 'error',
-        )
-        if (result.ok) setContinuityEditReview(prev => prev ? { ...prev, editorOpened: true } : null)
-        return
-      }
-      setContinuityEditReview(null)
-      if (action === 'save-publish') {
-        const status = await getIdentityStatus(configRef.current)
-        setIdentityOverlay({
-          initialAction: 'save-snapshot',
-          existing: status ? { address: status.address } : null,
-        })
-        overlayRef.current = 'identity'
-        setOverlay('identity')
-        pushNote('Opening snapshot signature.', 'dim')
-        return
-      }
-      overlayRef.current = 'none'
-      setOverlay('none')
-      pushNote('Snapshot not saved yet.', 'dim')
-    },
-    [continuityEditReview, pushNote],
-  )
-
-  const handleContinuityEditReviewCancel = useCallback(() => {
-    setContinuityEditReview(null)
-    overlayRef.current = 'none'
-    setOverlay('none')
-    pushNote('Snapshot not saved yet.', 'dim')
-  }, [pushNote])
-
-  const handleCopyDone = useCallback(
-    (result: CopyResult, label: string) => {
-      setOverlay('none')
-      setCopyPickerState(null)
-      if (result.ok) {
-        pushNote(`${label} copied to clipboard · ${result.chars} chars`, 'dim')
-      } else {
-        pushNote(`Copy failed: ${result.error}`, 'error')
-      }
-    },
-    [pushNote],
-  )
-
-  const handleCopyCancel = useCallback(() => {
-    setOverlay('none')
-    setCopyPickerState(null)
-    pushNote('Copy cancelled.', 'dim')
-  }, [pushNote])
-
-  const handleRestoreConversation = useCallback((turnId: string, promptText?: string) => {
-    const restored = restoreConversationState(sessionMessagesRef.current, turnId, nextRowId)
-    sessionMessagesRef.current = restored.messages
-    setRows(restored.rows)
-    historyScopeRef.current = 'session'
-    setHistory(restored.promptHistory)
-    if (promptText != null && promptText.length > 0) {
-      setPendingInputDraft(promptText)
-    }
-    if (restored.truncated) {
-      setQueuedInputs([])
-      statsSegmentStartRef.current = Math.min(statsSegmentStartRef.current, restored.messages.length)
-      refreshVisibleStats(restored.messages, providerRef.current.supportsTools, cwdRef.current, configRef.current, mode)
-      setSessionKey(key => key + 1)
-      return
-    }
-    refreshVisibleStats(restored.messages, providerRef.current.supportsTools, cwdRef.current, configRef.current, mode)
-  }, [mode, refreshVisibleStats])
-
-  const startFreshImplementationContext = useCallback(() => {
-    const nextSessionId = newSessionId()
-    sessionMessagesRef.current = []
-    statsSegmentStartRef.current = 0
-    sessionIdRef.current = nextSessionId
-    historyScopeRef.current = 'global'
-    setHistory(globalHistoryRef.current)
-    setSessionId(nextSessionId)
-    setRows([])
-    setTurns(0)
-    setApproxTokens(0)
-    setQueuedInputs([])
-    setStatusStartedAt(Date.now())
-    setSessionKey(key => key + 1)
-  }, [])
-
-  const startSummarizedPlanImplementationContext = useCallback(
-    async (plan: string): Promise<boolean> => {
-      if (compactingRef.current) return false
-
-      const sourceSessionId = sessionIdRef.current
-      const priorMessages = buildBaseMessages(
-        sessionMessagesRef.current,
-        configRef.current,
-        providerRef.current.supportsTools,
-        cwdRef.current,
-        modeRef.current,
-      )
-
-      if (priorMessages.length <= 5) {
-        startFreshImplementationContext()
-        pushNote('Not enough planning context to summarize; starting a plan-only implementation conversation.', 'dim')
-        return true
-      }
-
-      compactingRef.current = true
-      const compaction = beginCompactionUi('plan', sourceSessionId)
-      try {
-        const result = await compactTranscript(providerRef.current, priorMessages, {
-          signal: compaction.controller.signal,
-          onStage: stage => updateCompactionStage(compaction, stage),
-        })
-        if (!result.ok && result.cancelled) {
-          removeCompactionProgress(compaction)
-          pushNote('Plan context summary cancelled.', 'dim')
-          return false
-        }
-        const summary = result.ok
-          ? normalizeHandoffSummary(result.summary)
-          : normalizeHandoffSummary(summarizeTranscriptLocally(priorMessages, result.reason))
-        if (!result.ok) {
-          pushNote(`Provider summary failed; created a local summary instead: ${result.reason}`, 'dim')
-        }
-
-        updateCompactionStage(compaction, 'saving summarized conversation')
-        const nextSessionId = newSessionId()
-        const createdAt = nowIso()
-        const nextMessages = buildPlanTransferSeedMessages({
-          sourceSessionId,
-          summary,
-          plan,
-          createdAt,
-        })
-        const context = {
-          cwd: cwdRef.current,
-          provider: configRef.current.provider,
-          model: configRef.current.model,
-          mode: modeRef.current,
-        }
-
-        await ensureSessionMetadata(nextSessionId, context)
-        await updateSessionActivity(nextSessionId, context, { compactedFromSessionId: sourceSessionId })
-        for (const message of nextMessages) {
-          await appendSessionMessage(nextSessionId, message, context)
-        }
-
-        updateCompactionStage(compaction, 'opening summarized conversation')
-        compactionUiRef.current = null
-        setCompactionUi(null)
-        sessionIdRef.current = nextSessionId
-        setSessionId(nextSessionId)
-        sessionMessagesRef.current = nextMessages
-        historyScopeRef.current = 'session'
-        setHistory(promptHistoryFromSessionMessages(nextMessages))
-        statsSegmentStartRef.current = 0
-        setRows([
-          {
-            role: 'note',
-            id: nextRowId(),
-            kind: 'dim',
-            content: `kept ${sourceSessionId.slice(0, 8)} saved; transferred plan into ${nextSessionId.slice(0, 8)}.`,
-          },
-          ...sessionMessagesToRows(nextMessages, nextRowId),
-        ])
-        setQueuedInputs([])
-        setStatusStartedAt(Date.now())
-        refreshVisibleStats(nextMessages, providerRef.current.supportsTools, cwdRef.current, configRef.current, modeRef.current)
-        setSessionKey(key => key + 1)
-        return true
-      } catch (err: unknown) {
-        removeCompactionProgress(compaction)
-        if (compaction.controller.signal.aborted) {
-          pushNote('Plan context summary cancelled.', 'dim')
-        } else {
-          pushNote(`Context summary error: ${(err as Error).message}`, 'error')
-        }
-        return false
-      } finally {
-        compactingRef.current = false
-        compactionUiRef.current = null
-        setCompactionUi(null)
-      }
-    },
-    [beginCompactionUi, pushNote, refreshVisibleStats, removeCompactionProgress, startFreshImplementationContext, updateCompactionStage],
-  )
-
-  const handlePlanApprovalCancel = useCallback(() => {
-    const plan = pendingPlanRef.current
-    if (plan) {
-      const next = { ...plan, awaitingApproval: false }
-      pendingPlanRef.current = next
-      setPendingPlan(next)
-    }
-    if (overlayRef.current === 'planApproval') {
-      overlayRef.current = 'none'
-      setOverlay('none')
-    }
-  }, [])
-
-  const handlePlanApproval = useCallback(
-    async (action: PlanApprovalAction) => {
-      const plan = pendingPlanRef.current
-      if (!plan) {
-        handlePlanApprovalCancel()
-        return
-      }
-      if (plan.cwd !== cwdRef.current || plan.sessionId !== sessionIdRef.current) {
-        clearPendingPlan()
-        pushNote('Dismissed stale plan approval because the workspace changed.', 'dim')
-        return
-      }
-      if (action === 'continue') {
-        handlePlanApprovalCancel()
-        return
-      }
-
-      const nextMode: SessionMode = 'accept-edits'
-      if (action === 'apply-summary') {
-        const transferred = await startSummarizedPlanImplementationContext(plan.text)
-        if (!transferred) return
-      }
-      clearPendingPlan()
-      modeRef.current = nextMode
-      setMode(nextMode)
-      await runStream(buildPlanImplementationPrompt(plan.text), nextMode)
-    },
-    [
-      clearPendingPlan,
-      handlePlanApprovalCancel,
-      pushNote,
-      runStream,
-      startSummarizedPlanImplementationContext,
-    ],
-  )
-
-  const busy = streaming || pullInFlight || Boolean(compactionUi)
-
-  useEffect(() => {
-    if (!busy) {
-      setTerminalTitle(TITLE_STATIC)
-      return
-    }
-    let i = 0
-    setTerminalTitle(TITLE_ANIMATION_FRAMES[0])
-    const id = setInterval(() => {
-      i = (i + 1) % TITLE_ANIMATION_FRAMES.length
-      setTerminalTitle(TITLE_ANIMATION_FRAMES[i] ?? TITLE_STATIC)
-    }, TITLE_ANIMATION_INTERVAL_MS)
-    return () => clearInterval(id)
-  }, [busy])
-
-  const slashSuggestions = useMemo(
-    () => getSlashSuggestions(mcpManagerRef.current?.getPromptSuggestions() ?? []),
-    [mcpSnapshot],
-  )
-
-  useEffect(() => {
-    const plan = pendingPlanRef.current
-    if (!plan?.awaitingApproval) return
-    if (mode !== 'plan' || overlay !== 'none' || streaming || pullInFlight || compactionUi) return
-    if (plan.cwd !== cwdRef.current || plan.sessionId !== sessionIdRef.current) {
-      clearPendingPlan()
-      return
-    }
-    overlayRef.current = 'planApproval'
-    setOverlay('planApproval')
-  }, [clearPendingPlan, compactionUi, mode, overlay, pullInFlight, streaming])
-
-  useEffect(() => {
-    if (overlay !== 'none') return
-    if (streaming || pullInFlight || compactionUi || queuedInputs.length === 0 || drainingQueueRef.current) return
-    drainingQueueRef.current = true
-    const next = queuedInputs[0]
-    setQueuedInputs(prev => prev.slice(1))
-    void (async () => {
-      if (!next) return
-      if (parseSlash(next)) {
-        const ctx = buildSlashContext()
-        const result = await dispatchSlash(next, ctx)
-        if (result && result.kind === 'note') {
-          pushNote(result.text, result.variant ?? 'info')
-        }
-        if (result && result.kind === 'submit') {
-          const projected = projectedUsageForInput(result.text)
-          if (shouldConfirmContextUsage(projected, CONTEXT_CONFIRM_PERCENT)) {
-            showContextLimitForPrompt(result.text)
-            return
-          }
-          await runStream(result.text)
-        }
-        return
-      }
-      const projected = projectedUsageForInput(next)
-      if (shouldConfirmContextUsage(projected, CONTEXT_CONFIRM_PERCENT)) {
-        showContextLimitForPrompt(next)
-        return
-      }
-      await runStream(next)
-    })().finally(() => {
-      drainingQueueRef.current = false
-    })
-  }, [compactionUi, overlay, projectedUsageForInput, pullInFlight, pushNote, queuedInputs, runStream, showContextLimitForPrompt, streaming])
-
-  const contextLine = `${providerDisplayName(config.provider)} · ${formatModelDisplayName(config.provider, config.model, { maxLength: 24 })} · ${compressHome(cwd)}`
-  const tipLine = 'Tip: type /help to get started · shift+enter for newline'
-
-  const placeholderHints = useMemo(() => {
-    if (compactionUi) return ['compaction in progress · esc to cancel']
-    return []
-  }, [compactionUi])
-
-  const exitHint = exitState.pending ? 'ctrl+c again to quit' : null
-  const runtimeModeLabel = sessionModeLabel(mode)
-  const runtimeModeColor =
-    mode === 'plan'
-      ? theme.modePlan
-      : mode === 'accept-edits'
-        ? theme.modeAcceptEdits
-        : theme.text
-  const footerRight = (
-    <Box flexDirection="row">
-      {exitHint ? (
-        <>
-          <Text color={theme.accentPeriwinkle}>{exitHint}</Text>
-          <Text color={theme.dim}> · </Text>
-        </>
-      ) : null}
-      {runtimeModeLabel ? (
-        <>
-          <Text color={runtimeModeColor} bold>{runtimeModeLabel}</Text>
-          <Text color={theme.dim}> (</Text>
-          <Text color={theme.accentPeriwinkle}>shift+tab to cycle</Text>
-          <Text color={theme.dim}>) · </Text>
-        </>
-      ) : (
-        <>
-          <Text color={theme.accentPeriwinkle}>shift+tab to cycle</Text>
-          <Text color={theme.dim}> · </Text>
-        </>
-      )}
-      <Text color={theme.dim}>{chatFooterShortcutText(canScrollTranscript)}</Text>
-    </Box>
-  )
-  const header = <BrandSplash contextLine={contextLine} tipLine={tipLine} updateNotice={updateNotice ?? null} />
-  return (
-    <ConversationStack
-      header={header}
-      rows={rows}
-      transcriptActive={overlay === 'none'}
-      bottomVariant={overlay === 'none' ? 'prompt' : 'overlay'}
-      bottom={(
-        <ChatBottomPane
-          overlay={overlay}
-          config={config}
-          sessionId={sessionId}
-          cwd={cwd}
-          currentSessionId={sessionId}
-          copyPickerState={copyPickerState}
-          contextLimitState={contextLimitState}
-          continuityEditReview={continuityEditReview}
-          modelPickerContextFit={modelPickerContextFit}
-          permissionRequest={permissionRequest}
-          history={history}
-          streaming={streaming}
-          streamingStartedAt={streamingStartedAt}
-          activity={null}
-          placeholderHints={placeholderHints}
-          queuedInputs={queuedInputs}
-          slashSuggestions={slashSuggestions}
-          planApprovalContextLabel={pendingPlan?.contextLabel ?? formatContextLabel(activeContextUsage)}
-          footerRight={footerRight}
-          handleModelPick={handleModelPick}
-          handleModelPickerCancel={handleModelPickerCancel}
-          handleResumePick={handleResumePick}
-          handleResumeClearAll={handleResumeClearAll}
-          identityOverlay={identityOverlay}
-          handleIdentityResult={handleIdentityResult}
-          handleRestoreConversation={handleRestoreConversation}
-          pendingInputDraft={pendingInputDraft}
-          onInputDraftConsumed={() => setPendingInputDraft(null)}
-          handleSummarizeFromTurn={runCompactionFromTurn}
-          handleCopyDone={handleCopyDone}
-          handleCopyCancel={handleCopyCancel}
-          resolvePermission={resolvePermission}
-          handlePlanApproval={handlePlanApproval}
-          handlePlanApprovalCancel={handlePlanApprovalCancel}
-          handleContextLimitAction={handleContextLimitAction}
-          handleContextLimitCancel={handleContextLimitCancel}
-          handleContinuityEditReviewAction={handleContinuityEditReviewAction}
-          handleContinuityEditReviewCancel={handleContinuityEditReviewCancel}
-          onPermissionRulesChanged={rules => { permissionRulesRef.current = rules }}
-          onConfigChange={replaceConfig}
-          handleSubmit={handleSubmit}
-          setOverlay={setOverlay}
-          pushNote={pushNote}
-        />
-      )}
-      status={(
-        <SessionStatus
-          provider={config.provider}
-          model={config.model}
-          turns={turns}
-          approxTokens={approxTokens}
-          startedAt={statusStartedAt}
-          contextUsage={activeContextUsage}
-        />
-      )}
-      sessionKey={sessionKey}
-      onVisibleReasoningIdsChange={updateVisibleReasoningIds}
-      onTranscriptScrollabilityChange={setCanScrollTranscript}
-    />
-  )
-}
-
-function formatContextLabel(usage: ContextUsage): string {
-  if (!Number.isFinite(usage.usedTokens) || usage.usedTokens <= 0) return 'Estimated context: empty'
-  return `Estimated context: ${usage.percent}% used`
-}
-
-function appendPromptHistoryEntry(history: string[], value: string): string[] {
-  const prompt = value.trim()
-  if (!prompt) return history
-  const next = history[history.length - 1] === prompt ? history : [...history, prompt]
-  return next.length > MAX_PROMPT_HISTORY ? next.slice(-MAX_PROMPT_HISTORY) : next
-}