// Early boot initialization that must run before any other code.
// These run during script evaluation to handle server-stopped state
// and cross-tab shutdown broadcasts as early as possible.
(function(){
  // Clear stale stop-server flag on successful page load (server is reachable)
  try{localStorage.removeItem('hermes-webui-server-stopped');}catch(_){}
  // Listen for shutdown broadcast from other tabs
  try {
    var _stopChan = new BroadcastChannel('hermes-webui-shutdown');
    _stopChan.onmessage = function() { _showServerStopped(); };
  } catch(_) {}
})();

// cancelStream: stop the active chat stream.
// See docs/rfcs/webui-run-state-consistency-contract.md (Invariants #2, #4)
// for the owner-aware + terminal-settle rationale.
async function cancelStream(reason){
  const sid = S.session && S.session.session_id;
  const streamId = S.activeStreamId;
  if(!streamId) return false;
  // Interrupt provenance: log WHY the active run is being cancelled so operators
  // can tell an explicit Stop / interrupt from any other trigger when they see a
  // SIGINT/exit-code-130 in the backend logs. Only explicit user paths reach
  // this function (Stop button, /stop, /interrupt, busy-interrupt); passive
  // lifecycle events — session switch, tab hide, page unload — tear down the
  // LOCAL SSE transport via closeLiveStream() and never call /api/chat/cancel,
  // so they never interrupt the backend agent/tool run. (#5345)
  const _reason = reason || 'explicit-cancel';
  if(typeof console !== 'undefined' && console.info){
    console.info('[stream] cancel requested', {reason:_reason, streamId, sessionId:sid});
  }
  let respBody=null;
  let respOk=false;
  try{
    const r=await fetch(new URL(`api/chat/cancel?stream_id=${encodeURIComponent(streamId)}`,document.baseURI||location.href).href,{credentials:'include'});
    respOk=!!(r&&r.ok);
    try{respBody=await r.json();}catch(_){}
  }catch(e){
    if(typeof console !== 'undefined' && console.warn){
      console.warn('cancelStream: /api/chat/cancel request failed', e);
    }
  }
  // Active-session cancel should not tear down the current SSE transport before
  // the backend emits its terminal event; do that only for stale owner paths
  // where the user moved on to a different stream before this request
  // completed.
  if(sid && S.activeStreamId !== streamId && typeof closeLiveStream==='function'){
    closeLiveStream(sid, streamId);
  }
  // Owner guard: if the backend accepted the active-session cancel, leave
  // the current SSE transport and owner state intact so the terminal
  // `cancel` event can clear INFLIGHT, render "Task cancelled", and refresh
  // the sidebar. Only clear locally when the backend says there is no active
  // stream left to settle.
  if(respOk && respBody && respBody.cancelled===false && S.activeStreamId===streamId){
    S.activeStreamId=null;
    setBusy(false);
    if(typeof setComposerStatus==='function') setComposerStatus('');
    else setStatus('');
    // /api/chat/cancel only exposes `cancelled:bool`, so we cannot
    // distinguish reasons — keep the toast generic and short.
    if(typeof _clearPendingPromptsForSession==='function') _clearPendingPromptsForSession(sid);
    if(typeof showToast==='function') showToast('Stream is no longer active',2000);
  }
  return respOk;
}

async function cancelSessionStream(session){
  const streamId = session&&session.active_stream_id;
  const sid = session&&session.session_id;
  if(!streamId||!sid) return false;
  // Explicit sidebar "Stop response" — log provenance for the same reason as
  // cancelStream(). (#5345)
  if(typeof console !== 'undefined' && console.info){
    console.info('[stream] cancel requested', {reason:'sidebar-stop', streamId, sessionId:sid});
  }
  let respOk=false;
  try{
    const r=await fetch(new URL(`api/chat/cancel?stream_id=${encodeURIComponent(streamId)}`,document.baseURI||location.href).href,{credentials:'include'});
    respOk=!!(r&&r.ok);
  }catch(e){/* close local stream; keep UI state honest below */}
  if(!respOk) return false;
  if(typeof closeLiveStream==='function') closeLiveStream(sid, streamId);
  session.active_stream_id=null;
  delete INFLIGHT[sid];
  clearInflightState(sid);
  if(S.session&&S.session.session_id===sid){
    S.activeStreamId=null;
    if(S.session) S.session.active_stream_id=null;
    clearInflight();
    setBusy(false);
    if(typeof setComposerStatus==='function') setComposerStatus('');
    else setStatus('');
  }
  if(typeof _clearPendingPromptsForSession==='function') _clearPendingPromptsForSession(sid);
  if(typeof stopApprovalPollingForSession==='function') stopApprovalPollingForSession(sid);
  if(typeof stopClarifyPollingForSession==='function') stopClarifyPollingForSession(sid);
  if(typeof _approvalSessionId!=='undefined' && _approvalSessionId===sid){
    stopApprovalPolling();
    hideApprovalCard(true);
  }
  if(typeof _clarifySessionId!=='undefined' && _clarifySessionId===sid){
    stopClarifyPolling();
    hideClarifyCard(true, 'cancelled');
  }
  if(typeof renderSessionList==='function') renderSessionList();
  return true;
}

async function _savedSessionShouldStaySidebarOnly(sid){
  const state = await _savedSessionSidebarOnlyState(sid);
  return !!(state&&state.sidebarOnly);
}

async function _savedSessionSidebarOnlyState(sid){
  if(!sid) return false;
  try{
    const data = await api(`/api/session?session_id=${encodeURIComponent(sid)}&messages=0&resolve_model=0`);
    const session = data&&data.session;
    const archived = !!(session&&session.archived);
    const running = !!(session&&(session.active_stream_id||session.pending_user_message));
    return {sidebarOnly:archived||running, archived};
  }catch(e){
    return null;
  }
}

// ── Mobile navigation ──────────────────────────────────────────────────────
// URL prefill boot helpers.
function _prefillHasDraftText(prefillIntent){
  return !!(prefillIntent&&prefillIntent.hasText);
}
function _rootPrefillNeedsFreshComposer(urlSession, savedLocal, prefillIntent){
  return !urlSession&&!!savedLocal&&_prefillHasDraftText(prefillIntent);
}
function _profileQueryBlocksSavedLocalRestore(profileIntent, urlSession){
  return !!(profileIntent&&profileIntent.hasParam&&profileIntent.valid&&!urlSession);
}
function _shouldStartFreshPwaChat(action,urlSession){
  return action==='new-chat'&&!urlSession;
}
async function _applyComposerPrefillOnBoot(prefillIntent){
  if(!prefillIntent||!prefillIntent.hasText) return;
  const msg=(typeof $==='function')?$('msg'):document.getElementById('msg');
  if(!msg) return;
  const text=String(prefillIntent.text||'');
  msg.value=text;
  if(typeof autoResize==='function') autoResize();
  else if(typeof updateSendBtn==='function') updateSendBtn();
  if(typeof msg.focus==='function') msg.focus();
}
async function _finalizeComposerPrefillOnBoot(prefillIntent){
  if(prefillIntent&&prefillIntent.hasParams&&typeof _consumeComposerPrefillParamsFromLocation==='function'){
    _consumeComposerPrefillParamsFromLocation();
  }
  await _applyComposerPrefillOnBoot(prefillIntent);
}

// Mobile navigation.
let _workspacePanelMode='closed'; // 'closed' | 'browse' | 'preview'

function _isCompactWorkspaceViewport(){
  return window.matchMedia('(max-width: 900px)').matches;
}

function _isPhoneWidthViewport(){
  return window.matchMedia('(max-width: 640px)').matches;
}

function _isTouchKeyboardViewport(){
  try{return matchMedia('(hover:none) and (pointer:coarse)').matches&&!_hasFinePointerCoexisting();}catch(_){return false;}
}

function _syncKeyboardBottomInset(){
  const root=document.documentElement;
  if(!root) return;
  if(!window.visualViewport||!_isTouchKeyboardViewport()){
    root.style.removeProperty('--keyboard-bottom-inset');
    return;
  }
  const vv=window.visualViewport;
  // A pinch-zoomed viewport (vv.scale != 1) makes innerHeight - vv.height
  // reflect the zoom, not the keyboard — on Chromium touch devices with
  // accessibility "force enable zoom" that yields a large spurious inset that
  // jitters on pan. Treat only the unzoomed state as keyboard occlusion.
  if(Math.abs((vv.scale||1)-1)>0.05){
    root.style.removeProperty('--keyboard-bottom-inset');
    return;
  }
  const inset=Math.max(0,Math.ceil(window.innerHeight-(vv.height+vv.offsetTop)));
  if(inset>0){
    root.style.setProperty('--keyboard-bottom-inset',`${inset}px`);
  }else{
    root.style.removeProperty('--keyboard-bottom-inset');
  }
}

// Mobile PWA viewport reflow guard. When the on-screen keyboard / browser
// chrome shows or hides, visualViewport (or a plain resize on browsers without
// it) changes height without a layout invalidation, leaving the phone layout
// painted against stale geometry. Toggling a one-frame `viewport-reflow` class
// (which applies a cheap GPU-promotion transform under the @media(max-width:640px)
// rule) forces a repaint, then we resync the workspace panel + sidebar aria.
function _forceMobileViewportReflow(){
  _syncKeyboardBottomInset();
  if(!_isPhoneWidthViewport()) return;
  const layout=document.querySelector('.layout');
  if(!layout) return;
  document.documentElement.classList.add('viewport-reflow');
  void layout.offsetWidth;
  requestAnimationFrame(()=>{
    document.documentElement.classList.remove('viewport-reflow');
    try{ syncWorkspacePanelState(); }catch(_){ }
    try{ if(typeof _syncSidebarAria==='function') _syncSidebarAria(); }catch(_){ }
  });
}

function _syncWorkspacePanelInlineWidth(){
  const {panel}= _workspacePanelEls();
  if(!panel) return;

  const isCompact = _isCompactWorkspaceViewport();
  if(isCompact){
    if(panel.style.width) panel.style.removeProperty('width');
    return;
  }

  const saved = localStorage.getItem('hermes-panel-w');
  if(!saved) return;
  const parsed = parseInt(saved, 10);
  if(Number.isNaN(parsed) || parsed <= 0) return;
  panel.style.width = `${parsed}px`;
}

function _workspacePanelEls(){
  return {
    layout: document.querySelector('.layout'),
    panel: document.querySelector('.rightpanel'),
    toggleBtn: $('btnWorkspacePanelToggle'),
    edgeToggleBtn: $('btnWorkspacePanelEdgeToggle'),
    collapseBtn: $('btnCollapseWorkspacePanel'),
  };
}

function _hasWorkspacePreviewVisible(){
  const preview=$('previewArea');
  return !!(preview&&preview.classList.contains('visible'));
}

function _setWorkspacePanelMode(mode){
  const {layout,panel}= _workspacePanelEls();
  if(!layout||!panel)return;
  _workspacePanelMode=(mode==='browse'||mode==='preview')?mode:'closed';
  const open=_workspacePanelMode!=='closed';
  document.documentElement.dataset.workspacePanel=open?'open':'closed';
  // Persist open/closed across refreshes (browse/preview → open; closed → closed)
  // Do NOT overwrite the user's "keep open" preference — only track runtime state
  // so that toggleWorkspacePanel(false) from the toolbar doesn't clear the setting.
  try{localStorage.setItem('hermes-webui-workspace-panel', open ? 'open' : 'closed');}catch(_){}
  layout.classList.toggle('workspace-panel-collapsed',!open);
  if(_isCompactWorkspaceViewport()){
    panel.classList.toggle('mobile-open',open);
  }else{
    panel.classList.remove('mobile-open');
  }
  syncWorkspacePanelUI();
}

function syncWorkspacePanelState(){
  const hasPreview=_hasWorkspacePreviewVisible();
  if(hasPreview){
    if(_workspacePanelMode==='closed') _setWorkspacePanelMode('preview');
    else syncWorkspacePanelUI();
    return;
  }
  if(!S.session){
    // No active session — if the panel was explicitly opened (browse mode), keep it
    // open so the workspace pane doesn't vanish on a fresh-page or empty-session boot.
    // The file tree will show the "no workspace" placeholder naturally via renderFileTree().
    // Only force-close if the mode is 'preview' (file preview without a session is invalid).
    if(_workspacePanelMode==='preview') _setWorkspacePanelMode('closed');
    else syncWorkspacePanelUI();
    return;
  }
  _setWorkspacePanelMode(_workspacePanelMode==='preview'?'closed':_workspacePanelMode);
}

function openWorkspacePanel(mode='browse'){
  if(mode==='browse'&&!S.session&&!_hasWorkspacePreviewVisible()&&!S._profileDefaultWorkspace)return;
  if(mode==='preview'&&_workspacePanelMode==='browse'){
    syncWorkspacePanelUI();
    return;
  }
  _setWorkspacePanelMode(mode);
}

function closeWorkspacePanel(){
  _setWorkspacePanelMode('closed');
}

function ensureWorkspacePreviewVisible(){
  if(_workspacePanelMode==='closed') _setWorkspacePanelMode('preview');
  else syncWorkspacePanelUI();
}

function handleWorkspaceClose(){
  if(_hasWorkspacePreviewVisible()){
    clearPreview();
    return;
  }
  closeWorkspacePanel();
}

async function _maybeBindFreshDefaultWorkspaceSession(prefillIntent=null){
  if(_prefillHasDraftText(prefillIntent)) return false;
  if(S.session) return false;
  if(_workspacePanelMode!=='browse') return false;
  if(!S._profileDefaultWorkspace) return false;
  try{
    // worktree:false is explicit and load-bearing — this auto-bind runs on
    // page load, and a config-level worktree default must never leak a fresh
    // worktree + branch from simply opening the UI (#6022).
    await newSession(false, {awaitWorkspaceLoad: true, worktree: false});
    return true;
  }catch(e){
    console.warn('[hermes] failed to bind fresh default workspace session', e);
    return false;
  }
}

/**
 * Set a tooltip on a button, preferring the custom CSS tooltip (`data-tooltip`)
 * when the element opts in via the `has-tooltip` class. Falls back to the
 * native `title` attribute for elements that haven't opted in.
 *
 * Critical: when the element DOES have data-tooltip, this MUST also clear any
 * existing native `title` attribute, otherwise the slow ~1.5s native browser
 * tooltip co-fires alongside the fast custom CSS tooltip — exactly the bug
 * #1775 reports. Always pair `data-tooltip` with `removeAttribute('title')`.
 */
function _setButtonTooltip(btn, text){
  if(!btn) return;
  if(btn.hasAttribute('data-tooltip')){
    btn.setAttribute('data-tooltip', text);
    if(btn.hasAttribute('title')) btn.removeAttribute('title');
  } else {
    btn.title = text;
  }
}

function _uiText(key, fallback){
  if(typeof t==='function'){
    const val=t(key);
    if(val&&val!==key) return val;
  }
  return fallback;
}

function syncWorkspacePanelUI(){
  const {layout,panel,toggleBtn,edgeToggleBtn,collapseBtn}= _workspacePanelEls();
  if(!layout||!panel)return;
  const desktopOpen=_workspacePanelMode!=='closed';
  const mobileOpen=panel.classList.contains('mobile-open');
  const isCompact=_isCompactWorkspaceViewport();
  const isOpen=isCompact?mobileOpen:desktopOpen;
  const canBrowse=!!S.session||_hasWorkspacePreviewVisible()||!!(S._profileDefaultWorkspace);
  const hasPreview=_hasWorkspacePreviewVisible();
  if(toggleBtn){
    toggleBtn.classList.toggle('active',isOpen);
    toggleBtn.setAttribute('aria-pressed',isOpen?'true':'false');
    const label=_uiText(isOpen?'workspace_panel_hide':'workspace_panel_show', isOpen?'Hide workspace panel':'Show workspace panel');
    _setButtonTooltip(toggleBtn, label);
    toggleBtn.setAttribute('aria-label', label);
    toggleBtn.disabled=!canBrowse;
  }
  if(edgeToggleBtn){
    edgeToggleBtn.classList.toggle('active',isOpen);
    edgeToggleBtn.setAttribute('aria-expanded',isOpen?'true':'false');
    const label=_uiText(isOpen?'workspace_panel_hide':'workspace_panel_show', isOpen?'Hide workspace panel':'Show workspace panel');
    _setButtonTooltip(edgeToggleBtn, label);
    edgeToggleBtn.setAttribute('aria-label', label);
    edgeToggleBtn.disabled=!canBrowse;
  }
  if(collapseBtn){
    _setButtonTooltip(collapseBtn, isCompact?_uiText('workspace_panel_close','Close workspace panel'):_uiText('workspace_panel_hide','Hide workspace panel'));
  }
  const hasSession=!!S.session;
  ['btnUpDir','btnNewFile','btnNewFolder','btnRefreshPanel'].forEach(id=>{
    const el=$(id);
    if(el)el.disabled=!hasSession;
  });
  const clearBtn=$('btnClearPreview');
  if(clearBtn){
    clearBtn.disabled=!isOpen;
    const label=hasPreview?_uiText('workspace_close_preview','Close preview'):_uiText('terminal_close','Close');
    _setButtonTooltip(clearBtn, label);
    clearBtn.setAttribute('aria-label', label);
    if(!isCompact) clearBtn.style.display='';
  }
}

function toggleMobileSidebar(){
  const sidebar=document.querySelector('.sidebar');
  if(!sidebar)return;
  const isOpen=sidebar.classList.contains('mobile-open');
  if(isOpen){closeMobileSidebar();}
  else{
    try{if(typeof _syncMobileSidebarPanelFromMainView==='function')_syncMobileSidebarPanelFromMainView();}catch(_){}
    sidebar.classList.remove('mobile-session-page');sidebar.classList.add('mobile-panel-drawer','mobile-open');
  }
}
function closeMobileSidebar(){
  const sidebar=document.querySelector('.sidebar');
  const overlay=$('mobileOverlay');
  if(sidebar)sidebar.classList.remove('mobile-open','mobile-session-page','mobile-panel-drawer');
  if(overlay)overlay.classList.remove('visible');
}

const _PWA_SIDEBAR_SWIPE_EDGE=80;
const _PWA_SIDEBAR_SWIPE_CLAIM=10;
const _PWA_SIDEBAR_SWIPE_TRIGGER=64;
const _PWA_SIDEBAR_SWIPE_MAX_VERTICAL=56;
let _pwaSidebarSwipe=null;

function _isPwaStandalone(){
  try{
    return document.documentElement.classList.contains('pwa-standalone')
      || window.matchMedia('(display-mode: standalone)').matches
      || window.navigator.standalone===true;
  }catch(_){return false;}
}

function _isInteractiveSwipeTarget(target){
  try{return !!(target&&target.closest&&target.closest('input,textarea,select,button,a,[contenteditable="true"],.topbar-chips,.composer-left,.sidebar,.rightpanel'));}
  catch(_){return false;}
}

function _pwaSidebarSwipePoint(e){
  const touch=e&&e.touches&&e.touches[0]||e&&e.changedTouches&&e.changedTouches[0];
  const src=touch||e;
  if(!src)return null;
  return {clientX:Number(src.clientX)||0,clientY:Number(src.clientY)||0};
}

function _isTouchPointerEvent(e){
  return !!(e&&e.pointerType==='touch');
}

function _openMobileSidebarFromGesture(){
  if(_isDesktopWidth())return;
  const sidebar=document.querySelector('.sidebar');
  if(!sidebar)return;
  try{if(typeof _syncMobileSidebarPanelFromMainView==='function')_syncMobileSidebarPanelFromMainView();}catch(_){}
  const layout=document.querySelector('.layout');
  if(layout)layout.classList.remove('sidebar-collapsed');
  sidebar.classList.remove('sidebar-collapsed');
  try{document.documentElement.removeAttribute('data-sidebar-collapsed');}catch(_){}
  sidebar.classList.remove('mobile-session-page');
  sidebar.classList.add('mobile-panel-drawer');
  sidebar.classList.add('mobile-open');
}

function _onPwaSidebarSwipeStart(e){
  if(_isDesktopWidth())return;
  if(_isTouchPointerEvent(e))return;
  if(e.pointerType==='mouse'||(e.pointerType&&e.pointerType!=='touch'&&e.pointerType!=='pen'))return;
  if(document.querySelector('.sidebar')?.classList.contains('mobile-open'))return;
  const point=_pwaSidebarSwipePoint(e);
  if(!point)return;
  if(point.clientX>_PWA_SIDEBAR_SWIPE_EDGE)return;
  if(_isInteractiveSwipeTarget(e.target))return;
  _pwaSidebarSwipe={startX:point.clientX,startY:point.clientY,active:true,opened:false};
}

function _onPwaSidebarSwipeMove(e){
  if(_isTouchPointerEvent(e))return;
  const swipe=_pwaSidebarSwipe;
  if(!swipe||!swipe.active||swipe.opened)return;
  const point=_pwaSidebarSwipePoint(e);
  if(!point)return;
  const dx=point.clientX-swipe.startX;
  const dy=point.clientY-swipe.startY;
  if(dx<0||Math.abs(dy)>_PWA_SIDEBAR_SWIPE_MAX_VERTICAL*1.5){_pwaSidebarSwipe=null;return;}
  if(dx>=_PWA_SIDEBAR_SWIPE_CLAIM&&dx>Math.abs(dy)*1.2){
    if(e.cancelable)e.preventDefault();
  }
  if(dx>=_PWA_SIDEBAR_SWIPE_TRIGGER&&Math.abs(dy)<=_PWA_SIDEBAR_SWIPE_MAX_VERTICAL&&dx>Math.abs(dy)*1.5){
    if(e.cancelable)e.preventDefault();
    swipe.opened=true;
    _openMobileSidebarFromGesture();
  }
}

function _onPwaSidebarSwipeEnd(e){if(_isTouchPointerEvent(e))return;_pwaSidebarSwipe=null;}
function _onPwaSidebarSwipeCancel(e){if(_isTouchPointerEvent(e))return;_pwaSidebarSwipe=null;}

function _installPwaSidebarSwipeGesture(){
  // #4660 review (Codex CORE): the #pwaSidebarEdgeGuard element is now
  // pointer-events:none (CSS), so it can no longer intercept hit-testing for
  // taps / vertical scrolls that merely start in the left edge strip — those
  // pass through to the underlying .messages scroller. The edge-swipe-to-open
  // gesture is handled entirely by the window-level CAPTURE touch/pointer
  // listeners below (which see the event regardless of the guard), so no
  // dedicated guard-element listener is needed.
  window.addEventListener('touchstart', _onPwaSidebarSwipeStart, {capture:true,passive:true});
  window.addEventListener('touchmove', _onPwaSidebarSwipeMove, {capture:true,passive:false});
  window.addEventListener('touchend', _onPwaSidebarSwipeEnd, {capture:true,passive:true});
  window.addEventListener('touchcancel', _onPwaSidebarSwipeCancel, {capture:true,passive:true});
  window.addEventListener('pointerdown', _onPwaSidebarSwipeStart, {passive:true});
  window.addEventListener('pointermove', _onPwaSidebarSwipeMove, {passive:false});
  window.addEventListener('pointerup', _onPwaSidebarSwipeEnd, {passive:true});
  window.addEventListener('pointercancel', _onPwaSidebarSwipeCancel, {passive:true});
}
_installPwaSidebarSwipeGesture();

// ── Desktop sidebar collapse toggle ────────────────────────────────────────
// Two discoverability paths into the same state:
//   (1) Click the already-active rail icon → collapse / expand the sidebar.
//   (2) Cmd/Ctrl+B keyboard shortcut (VS Code convention).
// Mobile is unaffected: the sidebar is an overlay there, and every collapse
// code path is gated on `_isDesktopWidth()` (min-width:641px).
// State is persisted via localStorage and survives reloads + bfcache.
const _SIDEBAR_COLLAPSED_KEY='hermes-webui-sidebar-collapsed';

function _isDesktopWidth(){
  try{return window.matchMedia('(min-width:641px)').matches;}catch(_){return true;}
}

function _isSidebarCollapsed(){
  return document.querySelector('.layout')?.classList.contains('sidebar-collapsed')||false;
}

function _syncSidebarAria(){
  // Mirror the open/collapsed state on the active rail button via aria-expanded
  // so screen readers announce the toggle. Open=true, collapsed=false.
  // Clear the others first: only one panel owns the sidebar, but this used to set
  // aria-expanded on the newly-active button without unsetting the previous one,
  // so chat -> kanban -> skills left three buttons claiming aria-expanded=true
  // and a screen reader announced three open disclosures.
  document.querySelectorAll('.rail .rail-btn.nav-tab[data-panel][aria-expanded]')
    .forEach(function(btn){ btn.setAttribute('aria-expanded','false'); });
  const active=document.querySelector('.rail .rail-btn.nav-tab.active[data-panel]');
  if(active)active.setAttribute('aria-expanded',!_isSidebarCollapsed());
}

function toggleSidebar(forceState){
  if(!_isDesktopWidth())return; // mobile uses an overlay; never collapse there
  const layout=document.querySelector('.layout');
  if(!layout)return;
  const next=typeof forceState==='boolean'?forceState:!_isSidebarCollapsed();
  layout.classList.toggle('sidebar-collapsed',next);
  // Clear the flash-prevention root-level marker once JS owns the state.
  try{document.documentElement.removeAttribute('data-sidebar-collapsed');}catch(_){}
  try{localStorage.setItem(_SIDEBAR_COLLAPSED_KEY,next?'1':'0');}catch(_){}
  _syncSidebarAria();
}

function expandSidebar(){
  if(_isSidebarCollapsed())toggleSidebar(false);
}

// Boot-time restore. The inline flash-prevention script in index.html already
// set data-sidebar-collapsed='1' on <html> before the stylesheet so the page
// renders collapsed without paint flash. This IIFE promotes that pre-paint
// state into the .layout class system where both JS and CSS can read it.
(function _restoreSidebarState(){
  try{document.documentElement.removeAttribute('data-sidebar-collapsed');}catch(_){}
  if(!_isDesktopWidth())return;
  try{
    if(localStorage.getItem(_SIDEBAR_COLLAPSED_KEY)==='1'){
      const layout=document.querySelector('.layout');
      if(layout)layout.classList.add('sidebar-collapsed');
    }
  }catch(_){}
  _syncSidebarAria();
})();
// ── Boot-time tab visibility ────────────────────────────────────────────────
// Apply hidden tabs from localStorage. The primary flash-prevention is an
// inline <script> in index.html (after sidebar-nav) that runs synchronously
// before first paint. This IIFE is a secondary fallback: it ensures consistency
// after panels.js is loaded and handles the active-tab switch. No-op if
// panels.js hasn't loaded yet (typeof guard).
(function _restoreTabVisibility(){
  try{
    if(typeof _applyTabOrder==='function'&&typeof _getTabOrder==='function'){
      _applyTabOrder(_getTabOrder());
    }
    if(typeof _applyTabVisibility==='function'&&typeof _getHiddenTabs==='function'){
      _applyTabVisibility(_getHiddenTabs());
    }
    var active=document.querySelector('.rail .rail-btn.nav-tab.active[data-panel]')
               ||document.querySelector('.sidebar-nav .nav-tab.active[data-panel]');
    if(active&&active.classList.contains('nav-tab-hidden')){
      var chatBtn=document.querySelector('.rail .rail-btn.nav-tab[data-panel="chat"]');
      if(chatBtn)chatBtn.classList.add('active');
      if(active)active.classList.remove('active');
    }
  }catch(_){}
})();
function toggleMobileFiles(){
  toggleWorkspacePanel();
}
function closeMobileWorkspacePanelFromChat(e){
  if(!_isCompactWorkspaceViewport()||_workspacePanelMode==='closed') return;
  const panel=document.querySelector('.rightpanel');
  if(panel&&panel.contains(e.target)) return;
  closeWorkspacePanel();
}
function toggleWorkspacePanel(force){
  const {panel}= _workspacePanelEls();
  if(!panel)return;
  const currentlyOpen=_workspacePanelMode!=='closed';
  const nextOpen=typeof force==='boolean'?force:!currentlyOpen;
  if(!nextOpen){
    closeWorkspacePanel();
    return;
  }
  const nextMode=_hasWorkspacePreviewVisible()?'preview':'browse';
  openWorkspacePanel(nextMode);
}
function mobileSwitchPanel(name){
  switchPanel(name);
  if(name==='chat'){
    closeMobileSidebar();
  } else {
    const sidebar=document.querySelector('.sidebar');
    if(sidebar){
      sidebar.classList.remove('mobile-session-page');
      sidebar.classList.add('mobile-panel-drawer','mobile-open');
    }
  }
}

$('btnSend').onclick=()=>{
  if(typeof handleComposerPrimaryAction==='function') return handleComposerPrimaryAction();
  if(window._micActive){
    window._micPendingSend=true;
    _stopMic();
    return;
  }
  // Turn-based voice mode: let the voice mode system handle the send flow
  if(typeof window._voiceModeActive==='function'&&window._voiceModeActive()){
    // Immediately send whatever is in the textarea
    if(typeof window._voiceModeImmediateSend==='function') window._voiceModeImmediateSend();
    return;
  }
  send();
};
$('mainChat')?.addEventListener('pointerdown', closeMobileWorkspacePanelFromChat);
$('btnAttach').onclick=e=>{if(e&&e.preventDefault)e.preventDefault();$('fileInput').value='';$('fileInput').click();};

// ── Voice input (Web Speech API + MediaRecorder fallback) ───────────────────
function _micIsLocalhostOrLoopback(hostname){
  const host=String(hostname||'').toLowerCase().replace(/^\[|\]$/g,'');
  return host==='localhost'
    || host.endsWith('.localhost')
    || host==='::1'
    || host==='0:0:0:0:0:0:0:1'
    || /^127\./.test(host);
}

function _micOriginNeedsSecureContext(){
  if(window.isSecureContext===true) return false;
  const loc=window.location||{};
  const protocol=loc.protocol||'';
  return protocol==='http:'&&!_micIsLocalhostOrLoopback(loc.hostname);
}

function _micToastKeyForRecognitionError(error){
  if((error==='not-allowed'||error==='service-not-allowed'||error==='audio-capture')
      && _micOriginNeedsSecureContext()){
    return 'mic_insecure_origin';
  }
  const msgs={
    'not-allowed':'mic_denied',
    'service-not-allowed':'mic_denied',
    'no-speech':'mic_no_speech',
    'network':'mic_network',
  };
  return msgs[error]||null;
}

(function(){
  const SpeechRecognition=window.SpeechRecognition||window.webkitSpeechRecognition;
  const _canRecordAudio=!!(navigator.mediaDevices&&navigator.mediaDevices.getUserMedia&&window.MediaRecorder);
  if(!SpeechRecognition&&!_canRecordAudio) return; // Browser unsupported — mic button stays hidden

  // Persist SR failure across reloads (e.g. Tailscale/network error)
  const _micForceMediaRecorderKey='mic_force_mediarecorder';
  const _micForceMediaRecorderStored=localStorage.getItem(_micForceMediaRecorderKey);
  // Prefer Hermes server-side STT (MediaRecorder -> /api/transcribe) only
  // after the server confirms an STT provider is available. No stored key must
  // keep browser SpeechRecognition as the first-click default until then; that
  // avoids dropping the first dictation on installs without server STT.
  let _serverSttAvailable=false;
  let _forceMediaRecorder=!SpeechRecognition||(_micForceMediaRecorderStored===null?(_serverSttAvailable&&_canRecordAudio):_micForceMediaRecorderStored==='1');

  // Raw audio mode preference: send audio file instead of transcribing
  let _rawAudioMode = localStorage.getItem('hermes-raw-audio-mode') === 'true';
  // Append-on-commit preference: when ON (default), dictated text is appended
  // to any text already in the composer. When OFF, dictated text replaces the
  // composer content (the pre-existing behavior).
  let _dictationAppend = localStorage.getItem('hermes-dictation-append') !== 'false';
  // Capture backend pinned at recording start ('speech' | 'media' | null) so
  // _stopMic / onstop act on the backend that actually started, even if the
  // raw-audio toggle changes mid-recording (#3169 Codex review).
  let _activeCaptureMode = null;

  const btn=$('btnMic');
  const status=$('micStatus');
  const ta=$('msg');
  const statusText=status?status.querySelector('.status-text'):null;
  btn.style.display=''; // Show button — browser supports speech recognition or recording fallback

  let recognition=null;
  let mediaRecorder=null;
  let mediaStream=null;
  let audioChunks=[];
  let _finalText='';
  let _prefix='';
  let _isRecording=false;
  // #5294 salvage — mobile composer-mic dictation continuity.
  // _speechStopRequested distinguishes an intentional stop (send/toggle) from a
  // natural pause so onend only auto-restarts on real pauses. _micWakeLock keeps
  // the screen awake while dictating; _micWakeLockOp serializes acquire/release
  // so rapid start/stop/visibility churn can't leak a lock. _micRestartCount is
  // bounded by _micMaxRestarts to stop a tight loop if the audio session is stolen.
  let _speechStopRequested=false;
  let _micWakeLock=null;
  let _micWakeLockOp=null;
  let _micRestartCount=0;
  const _micMaxRestarts=20;
  let _micHoldTimer=null;
  let _micHoldActive=false;
  let _micPointerDown=false;
  let _micStartSeq=0;
  const _micHoldThresholdMs=300;

  function _setButtonTooltipAndKey(btn, key){
    const text = t(key);
    btn.setAttribute('data-i18n-title', key);
    if(btn.hasAttribute('data-tooltip')){
      btn.setAttribute('data-tooltip', text);
      if(btn.hasAttribute('title')) btn.removeAttribute('title');
    } else {
      btn.title = text;
    }
  }

  function _setRecording(on){
    window._micActive=on;
    btn.classList.toggle('recording',on);
    // Active-state title flips so the tooltip is honest about what
    // pressing the button will do (#1488).
    _setButtonTooltipAndKey(btn, on ? (_rawAudioMode ? 'voice_recording_active' : 'voice_dictate_active') : (_rawAudioMode ? 'voice_send_raw' : 'voice_dictate'));
    status.style.display=on?'':'none';
    if(statusText) statusText.textContent=on?'Listening':'Listening';
    if(!on){ _finalText=''; _prefix=''; }
  }

  function _updateMicTooltip(){
    if(!window._micActive){
      _setButtonTooltipAndKey(btn, _rawAudioMode ? 'voice_send_raw' : 'voice_dictate');
    }
  }

  function _applyRawAudioModePreference(enabled){
    _rawAudioMode=!!enabled;
    try{localStorage.setItem('hermes-raw-audio-mode',_rawAudioMode?'true':'false');}catch(_){}
    const rawAudioCheckbox=document.getElementById('settingsRawAudio');
    if(rawAudioCheckbox) rawAudioCheckbox.checked=_rawAudioMode;
    _updateMicTooltip();
  }
  window._applyRawAudioModePreference=_applyRawAudioModePreference;

  function _applyDictationAppendPreference(enabled){
    _dictationAppend=!!enabled;
    try{localStorage.setItem('hermes-dictation-append',_dictationAppend?'true':'false');}catch(_){}
    const cb=document.getElementById('settingsDictationAppend');
    if(cb) cb.checked=_dictationAppend;
  }
  window._applyDictationAppendPreference=_applyDictationAppendPreference;

  async function _sendRawAudio(blob){
    const ext=(blob.type&&blob.type.includes('ogg'))?'ogg':'webm';
    const file=new File([blob],`voice-input-${Date.now()}.${ext}`,{type:blob.type||`audio/${ext}`});
    S.pendingFiles.push(file);
    renderTray();
    // An explicit Send-button click while recording sets _micPendingSend — that
    // is an unambiguous send intent, so honor it even when the composer already
    // has text (mirrors the transcribe path). Otherwise (manual mic-stop): send
    // immediately only if the composer is empty, else just attach + toast so the
    // user can keep composing.
    if(window._micPendingSend){
      window._micPendingSend=false;
      send();
    }else if(!ta.value.trim()){
      send();
    }else{
      showToast(t('voice_raw_attached'));
    }
  }

  function _commitTranscript(text, prefixOverride){
    // `prefixOverride` is the composer content captured at recording start,
    // passed only by the async server-STT path (recorder.onstop → _transcribeBlob).
    // The sync browser-SR path doesn't call this function — it commits inline
    // in sr.onend using _prefix directly.
    //
    // Three concerns this function has to balance (Greptile reviews):
    //   1. Race condition: user types during async transcription → preserve those
    //      keystrokes. Read live ta.value, not the stale snapshot.
    //   2. Clear-during-transcription: user clears textarea during async wait →
    //      respect that intent. Live ta.value (even empty) wins over snapshot.
    //   3. Browser-SR fallback: if a future caller passes no prefixOverride
    //      and live ta.value is empty, fall back to _prefix as a safety net.
    //
    // Resolution: when prefixOverride IS provided (server-STT path), trust live
    // ta.value unconditionally — even when empty. Otherwise fall back to _prefix.
    const clean=(text||'').trim();
    let committed;
    if(!clean){
      committed = ta.value;
    }else if(_dictationAppend){
      const base = prefixOverride !== undefined ? ta.value : (ta.value || _prefix);
      if(!base){
        committed = clean;
      }else{
        committed = (!base.endsWith(' ') && !base.endsWith('\n'))
          ? base+' '+clean.trimStart()
          : base+clean;
      }
    }else{
      // Replace mode (explicit): dictated text overwrites the composer.
      committed = clean;
    }
    ta.value=committed;
    autoResize();
    if(window._micPendingSend){
      window._micPendingSend=false;
      send();
    }
  }

  function _isServerSttUnavailable(err){
    const status=err&&err.status;
    if(status===404||status===503||status>=500) return true;
    if(!status) return true;
    const msg=String((err&&err.message)||'').toLowerCase();
    return msg.includes('unavailable')||msg.includes('not configured');
  }

  function _allowBrowserSttFallback(){
    return !!(SpeechRecognition&&localStorage.getItem(_micForceMediaRecorderKey)!=='1');
  }

  async function _transcribeBlob(blob, prefixSnapshot){
    const ext=(blob.type&&blob.type.includes('ogg'))?'ogg':'webm';
    const form=new FormData();
    form.append('file',new File([blob],`voice-input.${ext}`,{type:blob.type||`audio/${ext}`}));
    // Snapshot is passed in from the recorder.onstop handler — taken there
    // BEFORE _setRecording(false) clears _prefix (async server STT path).
    setComposerStatus('Transcribing…');
    try{
      const res=await fetch('api/transcribe',{method:'POST',body:form});
      const data=await res.json().catch(()=>({}));
      if(!res.ok){
        const err=new Error(data.error||'Transcription failed');
        err.status=res.status;
        throw err;
      }
      _commitTranscript(data.transcript||'', prefixSnapshot);
    }catch(err){
      if(_isServerSttUnavailable(err)&&_allowBrowserSttFallback()){
        window._micPendingSend=false;
        localStorage.setItem(_micForceMediaRecorderKey,'0');
        _forceMediaRecorder=false;
        recognition=_ensureSpeechRecognition();
        showToast(err.message||t('mic_network'));
        return;
      }
      window._micPendingSend=false;
      showToast(err.message||t('mic_network'));
    }finally{
      setComposerStatus('');
    }
  }

  function _stopTracks(stream=mediaStream){
    if(stream){
      stream.getTracks().forEach(track=>track.stop());
      if(mediaStream===stream) mediaStream=null;
    }
  }

  // Gate continuous dictation to MOBILE so desktop stays one-shot (single
  // utterance). An explicit hermes-mic-continuous flag wins in both directions,
  // mirroring the hermes-voice-continuous pattern: 'true' opts a desktop in,
  // 'false' opts a mobile out. Absent a flag, coarse-pointer (touch) devices get
  // continuity and everything else stays single-utterance.
  function _micDictationContinuous(){
    try{
      const flag=localStorage.getItem('hermes-mic-continuous');
      if(flag==='true') return true;
      if(flag==='false') return false;
    }catch(_){}
    try{ return window.matchMedia('(pointer:coarse)').matches; }catch(_){ return false; }
  }

  // Only auto-restart the composer-mic session on a natural pause: continuity
  // must be enabled (mobile/opt-in), the session must still be active speech,
  // the stop must not have been requested, and we must be under the restart cap.
  function _micShouldRestartDictation(){
    return _micDictationContinuous()
      && !_speechStopRequested
      && !!window._micActive
      && _activeCaptureMode==='speech'
      && _micRestartCount<_micMaxRestarts;
  }

  // Screen Wake Lock while dictating. All acquire/release ops are chained onto a
  // single in-flight promise (_micWakeLockOp) so rapid start/stop/visibility
  // churn runs strictly in order and can't interleave to leak a lock or null
  // _micWakeLock mid-request.
  function _acquireMicWakeLock(){
    if(!navigator.wakeLock) return Promise.resolve();
    _micWakeLockOp=Promise.resolve(_micWakeLockOp).then(async()=>{
      if(_micWakeLock) return;
      if(!window._micActive||_activeCaptureMode!=='speech') return;
      try{
        const lock=await navigator.wakeLock.request('screen');
        // If the session ended while awaiting, don't hold a stale lock.
        if(!window._micActive||_activeCaptureMode!=='speech'){
          try{ await lock.release(); }catch(_){}
          return;
        }
        _micWakeLock=lock;
        _micWakeLock.addEventListener?.('release',()=>{ _micWakeLock=null; },{once:true});
      }catch(_){
        _micWakeLock=null;
      }
    });
    return _micWakeLockOp;
  }

  function _releaseMicWakeLock(){
    _micWakeLockOp=Promise.resolve(_micWakeLockOp).then(async()=>{
      const lock=_micWakeLock;
      _micWakeLock=null;
      if(!lock) return;
      try{ await lock.release(); }catch(_){}
    });
    return _micWakeLockOp;
  }

  // The OS drops a screen wake lock when the tab is hidden; reacquire on return
  // if we're still dictating (release on hide is a no-op if none is held).
  document.addEventListener('visibilitychange',()=>{
    if(document.visibilityState==='hidden'){
      void _releaseMicWakeLock();
      return;
    }
    if(window._micActive&&_activeCaptureMode==='speech'){
      void _acquireMicWakeLock();
    }
  });

  function _stopMic(){
    _micStartSeq+=1;
    _isRecording=false;
    if(!window._micActive) return;
    // Stop the backend that was ACTIVE WHEN RECORDING STARTED — not whatever
    // _rawAudioMode says now. The user can toggle Settings → Sound mid-recording,
    // which would otherwise make us stop the wrong backend and orphan the other
    // (#3169 Codex review). _activeCaptureMode is pinned at start.
    if(recognition && _activeCaptureMode==='speech'){
      _speechStopRequested=true;
      recognition.stop();
      return;
    }
    if(mediaRecorder&&mediaRecorder.state!=='inactive'){
      mediaRecorder.stop();
      return;
    }
    _setRecording(false);
    _stopTracks();
  }
  window._stopMic=_stopMic; // expose for send-guard above

  function _ensureSpeechRecognition(){
    if(!SpeechRecognition) return null;
    const sr=recognition||new SpeechRecognition();
    // Desktop dictation stays one-shot (single utterance); mobile / opt-in
    // devices run continuous so a natural pause doesn't end the session (#5294).
    sr.continuous=_micDictationContinuous();
    sr.interimResults=true;
    sr.lang=(typeof _locale!=='undefined'&&_locale._speech)||'en-US';

    sr.onstart=()=>{ _finalText=''; };

    sr.onresult=(event)=>{
      // #5294: a real result means the continuity restarts are PRODUCTIVE, not a
      // stolen-audio-session tight loop — reset the restart budget so a long
      // dictation with many natural pauses isn't silently capped at
      // _micMaxRestarts. The cap still guards the failure case: consecutive
      // restarts that yield no speech (onend without an intervening onresult)
      // keep incrementing and trip the bound.
      _micRestartCount=0;
      let interim='';
      let final=_finalText;
      for(let i=event.resultIndex;i<event.results.length;i++){
        const t=event.results[i][0].transcript;
        if(event.results[i].isFinal){ final+=t; _finalText=final; }
        else{ interim+=t; }
      }
      ta.value=_prefix+(final||interim);
      autoResize();
    };

    sr.onend=()=>{
      const committed=_finalText
        ? (_prefix&&!_prefix.endsWith(' ')&&!_prefix.endsWith('\n')
            ? _prefix+' '+_finalText.trimStart()
            : _prefix+_finalText)
        : ta.value;
      ta.value=committed;
      autoResize();
      // Mobile / opt-in continuity: a natural pause ends this recognition run but
      // the user is still dictating, so restart to keep the session alive. Desktop
      // (one-shot) and intentional stops (_speechStopRequested) skip this and
      // finalize. Bounded by _micMaxRestarts so a stolen audio session can't loop.
      if(_micShouldRestartDictation()){
        _prefix=committed&&!committed.endsWith(' ')&&!committed.endsWith('\n')
          ? committed+' '
          : committed;
        _finalText='';
        _micRestartCount++;
        try{
          sr.start();
          return;
        }catch(err){
          // Restart failed (e.g. the audio session was taken by another app).
          // Surface it instead of silently dropping to idle (Greptile P2).
          showToast(t('mic_error')+String((err&&err.message)||'restart'));
        }
      }
      _speechStopRequested=false;
      _isRecording=false;
      _micRestartCount=0;
      void _releaseMicWakeLock();
      _setRecording(false);
      if(window._micPendingSend){
        window._micPendingSend=false;
        send();
      }
      _applyDeferredServerSttFlip();
    };

    sr.onerror=(event)=>{
      // While dictating with continuity on, a no-speech/aborted error is a normal
      // pause or transient audio-session hiccup — swallow it and let onend restart
      // (bounded by _micMaxRestarts). Desktop one-shot still surfaces the toast.
      if((event.error==='no-speech'||event.error==='aborted')
          && _micDictationContinuous()
          && window._micActive
          && _activeCaptureMode==='speech'
          && !_speechStopRequested
          && _micRestartCount<_micMaxRestarts){
        return;
      }
      _speechStopRequested=false;
      _setRecording(false);
      window._micPendingSend=false;
      _isRecording=false;
      _micRestartCount=0;
      void _releaseMicWakeLock();
      if(event.error==='network'||event.error==='not-allowed'
          ||event.error==='service-not-allowed'||event.error==='audio-capture'){
        // Persist SR failure: next reload will skip SpeechRecognition
        localStorage.setItem(_micForceMediaRecorderKey,'1');
        _forceMediaRecorder=true;
        recognition=null;
      }
      const messageKey=_micToastKeyForRecognitionError(event.error);
      showToast(messageKey?t(messageKey):t('mic_error')+event.error);
    };

    return sr;
  }

  if(!_forceMediaRecorder){
    recognition=_ensureSpeechRecognition();
  }

  async function _probeServerSttCapability(){
    if(!_canRecordAudio||_micForceMediaRecorderStored!==null) return;
    try{
      const res=await fetch('api/transcribe/capability',{cache:'no-store'});
      const data=await res.json().catch(()=>({}));
      if(res.ok&&data&&data.available){
        _serverSttAvailable=true;
        if(!window._micActive){
          _forceMediaRecorder=true;
          recognition=null;
        }
      }
    }catch(_err){
      // Keep browser SpeechRecognition as the safe first-click default when the
      // passive capability probe fails.
    }
  }

  // If the capability probe resolved WHILE a session was active, the flip to
  // server STT was deferred to protect that in-flight session. Apply it once the
  // session ends so subsequent clicks use the configured server STT as intended.
  // Reads LIVE localStorage (not the init-time const) so a fallback that just
  // persisted '0' is respected and not re-flipped.
  function _applyDeferredServerSttFlip(){
    if(_serverSttAvailable&&!_forceMediaRecorder&&!window._micActive
        &&localStorage.getItem(_micForceMediaRecorderKey)===null){
      _forceMediaRecorder=true;
      recognition=null;
    }
  }

  _probeServerSttCapability();

  function _clearMicHoldTimer(){
    if(_micHoldTimer){
      clearTimeout(_micHoldTimer);
      _micHoldTimer=null;
    }
  }

  function _resetMicHoldState(){
    _clearMicHoldTimer();
    _micHoldActive=false;
    _micPointerDown=false;
  }

  function _micButtonAvailable(){
    if(!btn||btn.disabled) return false;
    if(btn.style.display==='none') return false;
    if(btn.classList.contains('composer-control-hidden')) return false;
    if(btn.getAttribute('aria-hidden')==='true') return false;
    if(window.getComputedStyle&&window.getComputedStyle(btn).display==='none') return false;
    return true;
  }

  async function _startMicCapture(holdRequired=false){
    if(!_micButtonAvailable()) return;
    const startSeq=++_micStartSeq;
    // Race-condition guard: ignore rapid double-clicks
    if(_isRecording){
      _stopMic();
      _isRecording=false;
      return;
    }
    if(window._micActive){
      _stopMic();
      return;
    }
    _isRecording=true;
    _finalText='';
    _prefix=ta.value;
    if(_micOriginNeedsSecureContext()){
      _isRecording=false;
      window._micPendingSend=false;
      showToast(t('mic_insecure_origin'));
      return;
    }
    if(recognition && !_forceMediaRecorder && !_rawAudioMode){
      _activeCaptureMode='speech';
      _speechStopRequested=false;
      _micRestartCount=0;
      // Refresh continuity gate at start so a settings/orientation change takes
      // effect for this session (desktop stays one-shot, mobile stays continuous).
      recognition.continuous=_micDictationContinuous();
      recognition.lang=(typeof _locale!=='undefined'&&_locale._speech)||'en-US';
      recognition.start();
      void _acquireMicWakeLock();
      _setRecording(true);
      return;
    }
    if(!_canRecordAudio){
      _isRecording=false;
      showToast(t('mic_network'));
      return;
    }
    try{
      const captureStream=await navigator.mediaDevices.getUserMedia({audio:true});
      if(startSeq!==_micStartSeq||!_micButtonAvailable()||(holdRequired&&!_micHoldActive)){
        _isRecording=false;
        _stopTracks(captureStream);
        return;
      }
      mediaStream=captureStream;
      const preferredTypes=['audio/webm;codecs=opus','audio/webm','audio/ogg;codecs=opus','audio/ogg'];
      const mimeType=preferredTypes.find(type=>window.MediaRecorder.isTypeSupported?.(type))||'';
      const captureMode=_rawAudioMode?'media-raw':'media-transcribe';
      const recorder=new MediaRecorder(captureStream,mimeType?{mimeType}:undefined);
      audioChunks=[];
      const captureChunks=audioChunks;
      recorder.ondataavailable=e=>{if(e.data&&e.data.size)captureChunks.push(e.data);};
      recorder.onerror=()=>{
        const isCurrentCapture=mediaRecorder===recorder||mediaStream===captureStream;
        _isRecording=false;
        if(mediaRecorder===recorder) mediaRecorder=null;
        if(isCurrentCapture) _setRecording(false);
        window._micPendingSend=false;
        _stopTracks(captureStream);
        showToast(t('mic_network'));
      };
      recorder.onstop=async()=>{
        const isCurrentCapture=mediaRecorder===recorder||mediaStream===captureStream;
        if(mediaRecorder===recorder) mediaRecorder=null;
        _isRecording=false;
        // Capture the composer prefix BEFORE _setRecording(false) clears _prefix.
        // The await on _transcribeBlob runs after this sync block, so by the
        // time _transcribeBlob is called, _prefix is already ''. Passing the
        // snapshot through keeps append-mode working on the async server-STT
        // path. See _commitTranscript() for how the snapshot is consumed.
        const prefixSnapshot = _prefix;
        const blob=new Blob(captureChunks,{type:recorder.mimeType||mimeType||'audio/webm'});
        if(isCurrentCapture) _setRecording(false);
        _stopTracks(captureStream);
        if(blob.size){
          if(captureMode==='media-raw'){
            await _sendRawAudio(blob);
          }else{
            await _transcribeBlob(blob, prefixSnapshot);
          }
        }
        else if(window._micPendingSend){
          window._micPendingSend=false;
        }
        _applyDeferredServerSttFlip();
      };
      _activeCaptureMode=captureMode;
      mediaRecorder=recorder;
      recorder.start();
      _setRecording(true);
    }catch(err){
      if(startSeq!==_micStartSeq) return;
      _isRecording=false;
      window._micPendingSend=false;
      _stopTracks();
      showToast(t(_micToastKeyForRecognitionError('not-allowed')||'mic_denied'));
    }
  }

  async function _toggleMicCapture(){
    if(!_micButtonAvailable()) return;
    if(window._micActive){
      _stopMic();
      return;
    }
    await _startMicCapture();
  }
  window._toggleMicCapture=_toggleMicCapture;

  btn.addEventListener('pointerdown',e=>{
    if(e.button!==0) return;
    if(!_micButtonAvailable()) return;
    _resetMicHoldState();
    _micPointerDown=true;
    _micHoldTimer=setTimeout(async()=>{
      _micHoldTimer=null;
      if(!_micPointerDown||window._micActive) return;
      _micHoldActive=true;
      await _startMicCapture(true);
    },_micHoldThresholdMs);
  });

  btn.addEventListener('pointerup',async e=>{
    if(e.button!==0||!_micPointerDown) return;
    _clearMicHoldTimer();
    if(_micHoldActive){
      _micHoldActive=false;
      _micPointerDown=false;
      _stopMic();
      return;
    }
    _micPointerDown=false;
    await _toggleMicCapture();
  });

  btn.addEventListener('pointerleave',()=>{
    _clearMicHoldTimer();
    if(_micHoldActive){
      _micHoldActive=false;
      _micPointerDown=false;
      _stopMic();
      return;
    }
    _micPointerDown=false;
  });

  btn.addEventListener('pointercancel',()=>{
    _clearMicHoldTimer();
    if(_micHoldActive){
      _micHoldActive=false;
      _micPointerDown=false;
      _stopMic();
      return;
    }
    _micPointerDown=false;
  });

  btn.addEventListener('click',async e=>{
    if(e.detail!==0) return;
    await _toggleMicCapture();
  });

  // Wire up the settings checkbox
  const rawAudioCheckbox = document.getElementById('settingsRawAudio');
  if(rawAudioCheckbox){
    rawAudioCheckbox.checked = _rawAudioMode;
    rawAudioCheckbox.addEventListener('change', function(){
      _applyRawAudioModePreference(this.checked);
    });
  }
  const appendCheckbox = document.getElementById('settingsDictationAppend');
  if(appendCheckbox){
    appendCheckbox.checked = _dictationAppend;
    appendCheckbox.addEventListener('change', function(){
      _applyDictationAppendPreference(this.checked);
    });
  }
  _updateMicTooltip();
})();
window._micActive=window._micActive||false;
window._micPendingSend=window._micPendingSend||false;

// ── Default message mode eager default (#5167 / #5145) ──────────────────────
// The Default message mode preference (queue/interrupt/steer) is read on the
// send path via `window._defaultMessageMode||'steer'`. The authoritative value
// only arrives once the async boot IIFE below resolves the `/api/settings`
// fetch. Without an eager value, every send during that boot window silently
// falls back, ignoring a saved 'queue'/'interrupt' preference (worse on
// slow/contended environments like WSL2, see #5132). Mirror the resolved value
// into localStorage — the same synchronous-source pattern used by hermes-lang /
// hermes-theme — so the very first send after a reload honors the saved choice.
const _DEFAULT_MESSAGE_MODES=['queue','interrupt','steer'];
// Legacy localStorage key (pre-#5145 rename); read it as a fallback so an
// existing user's persisted busy-input-mode preference survives the rename.
const _LEGACY_DEFAULT_MESSAGE_MODE_KEY='hermes-busy-input-mode';
const _DEFAULT_MESSAGE_MODE_KEY='hermes-default-message-mode';
// ── Auto-follow eager mirror (#6819) ────────────────────────────────────────
// PERSISTENCE CONTRACT (client-side mirror of the Auto-follow new content
// setting, `auto_scroll_follow`):
//
// * Why: the boot settings-fetch-failure path used to hardcode
//   `window._autoScrollFollow=true`, silently clobbering an explicit OFF for
//   the whole session (post-turn scroll yanks until the next refresh).
// * Storage: ONE global localStorage value (`'1'`/`'0'`) under
//   `_AUTO_SCROLL_FOLLOW_KEY` — NOT profile-keyed. The backend authority is
//   global: `SETTINGS_FILE = STATE_DIR / "settings.json"` (api/config.py)
//   and `/api/settings` calls `load_settings()` with no profile-specific
//   file, so the mirror must match that single global contract. A
//   profile-keyed map would leave a freshly-opened profile with no entry and
//   wrongly fall back to ON despite the global OFF (maintainer review on
//   #6856).
// * Write semantics: written ONLY when a settings response (or the boot
//   settings path) actually resolves the setting; the fallback path never
//   writes.
// * Read semantics: `_readPersistedAutoScrollFollow()` returns the stored
//   value if present, else `true` (the config.py default). The boot-failure
//   path reads it directly (no profile resolution needed — the mirror is
//   global, so it can be read synchronously in the fallback). Fresh users
//   (no mirror) get ON.
// * Upgrade: there is no legacy key; the mirror is created on first settings
//   resolve, so older sessions simply default to ON until the next settings
//   round-trip writes it.
const _AUTO_SCROLL_FOLLOW_KEY='hermes-auto-scroll-follow';
function _persistAutoScrollFollow(enabled){
  try{localStorage.setItem(_AUTO_SCROLL_FOLLOW_KEY,enabled?'1':'0');}catch(_){}
  return enabled;
}
function _readPersistedAutoScrollFollow(){
  try{
    const raw=localStorage.getItem(_AUTO_SCROLL_FOLLOW_KEY);
    if(raw==='1') return true;
    if(raw==='0') return false;
  }catch(_){}
  return true;  // default: follow ON (matches config.py default)
}
window._persistAutoScrollFollow=_persistAutoScrollFollow;
window._readPersistedAutoScrollFollow=_readPersistedAutoScrollFollow;
function _normalizeDefaultMessageMode(mode){
  return _DEFAULT_MESSAGE_MODES.includes(mode)?mode:'steer';
}
function _persistDefaultMessageMode(mode){
  const m=_normalizeDefaultMessageMode(mode);
  try{localStorage.setItem(_DEFAULT_MESSAGE_MODE_KEY,m);}catch(_){}
  return m;
}
function _readPersistedDefaultMessageMode(){
  let stored=null;
  try{
    // Prefer the new key; fall back to the legacy key so a pre-rename
    // preference is honored until the next explicit save rewrites the new key.
    stored=localStorage.getItem(_DEFAULT_MESSAGE_MODE_KEY);
    if(stored===null||stored===undefined) stored=localStorage.getItem(_LEGACY_DEFAULT_MESSAGE_MODE_KEY);
  }catch(_){}
  return _normalizeDefaultMessageMode(stored);
}
window._persistDefaultMessageMode=_persistDefaultMessageMode;
window._readPersistedDefaultMessageMode=_readPersistedDefaultMessageMode;
// Eager default set BEFORE the async settings fetch resolves so first sends in
// the boot window honor the persisted preference instead of the raw default.
window._defaultMessageMode=_readPersistedDefaultMessageMode();

// ── Extension TTS-engine registry (registerHermesTtsEngine) ──────────────────
// Defined at MODULE scope (not inside the voice-mode IIFE below) so the public
// API exists even on browsers without SpeechRecognition / speechSynthesis — an
// extension can register a TTS engine regardless of STT/browser-TTS support.
// Lets a trusted local extension contribute a TTS engine that appears in the
// Settings -> TTS Engine dropdown and is used by BOTH playback paths (voice-mode
// auto-read and the per-message Listen button). The extension provides an async
// synthesize(text, opts) that returns audio bytes (ArrayBuffer or Blob); core
// handles selection, the dropdown option, and playback. Mirrors registerHermesSkin.
//
//   window.registerHermesTtsEngine({
//     id: 'voicevox',            // [a-z0-9_-], not a built-in (browser/edge/elevenlabs/openai)
//     label: 'VOICEVOX (local)',
//     synthesize(text, opts) { return Promise<ArrayBuffer|Blob>; }
//   }) -> true on success, false if rejected
var _HERMES_TTS_ENGINES = Object.create(null);
var _HERMES_TTS_RESERVED = { browser:1, edge:1, elevenlabs:1, openai:1 };
function _hermesTtsValidId(id){ return typeof id==='string' && /^[a-z0-9][a-z0-9_-]{0,31}$/.test(id); }
function _hermesAddTtsOption(id, label){
  var sel=document.getElementById('settingsTtsEngine');
  if(!sel) return;
  if(sel.querySelector('option[value="'+id+'"]')) return;
  var opt=document.createElement('option');
  opt.value=id;
  opt.textContent=label;   // textContent — never innerHTML (no injection)
  sel.appendChild(opt);
}
window.registerHermesTtsEngine=function(desc){
  try{
    if(!desc||typeof desc!=='object') return false;
    var id=String(desc.id||'').toLowerCase();
    if(!_hermesTtsValidId(id)) return false;
    if(_HERMES_TTS_RESERVED[id]) return false;          // can't shadow a built-in
    if(typeof desc.synthesize!=='function') return false;
    var label=(typeof desc.label==='string' && desc.label.trim()) ? desc.label.trim().slice(0,48) : id;
    _HERMES_TTS_ENGINES[id]={ id:id, label:label, synthesize:desc.synthesize };
    _hermesAddTtsOption(id, label);
    return true;
  }catch(_){ return false; }
};
window._hermesTtsIsRegistered=function(id){ return !!_HERMES_TTS_ENGINES[id]; };
// List registered engines (for the settings panel to re-add options on render).
window._hermesTtsEngineOptions=function(){
  return Object.keys(_HERMES_TTS_ENGINES).map(function(k){
    return { id:_HERMES_TTS_ENGINES[k].id, label:_HERMES_TTS_ENGINES[k].label };
  });
};
// Returns a Promise<ArrayBuffer> or null if the engine isn't registered.
window._hermesTtsSynth=function(id, text, opts){
  var eng=_HERMES_TTS_ENGINES[id];
  if(!eng) return null;
  return Promise.resolve()
    .then(function(){ return eng.synthesize(text, opts||{}); })
    .then(function(out){
      if(!out) throw new Error('empty TTS result');
      if(out instanceof ArrayBuffer) return out;
      if(typeof Blob!=='undefined' && out instanceof Blob) return out.arrayBuffer();
      if(out.buffer instanceof ArrayBuffer) return out.buffer;   // typed array
      throw new Error('TTS engine returned an unsupported type');
    });
};

// ── Session-open hook (for extensions) ────────────────────────────────────
var _HERMES_SESSION_OPEN_HANDLERS=[];
window.registerHermesSessionOpenHandler=function(fn){
  if(typeof fn!=='function') return false;
  if(_HERMES_SESSION_OPEN_HANDLERS.indexOf(fn)>=0) return false;
  _HERMES_SESSION_OPEN_HANDLERS.push(fn);
  return true;
};
window._hermesNotifySessionOpen=function(sid, data, opts){
  opts=opts||{};
  for(var i=0;i<_HERMES_SESSION_OPEN_HANDLERS.length;i++){
    try{
      var result=_HERMES_SESSION_OPEN_HANDLERS[i](sid, data, opts);
      if(opts.preload===true && result&&result.cancel===true) return {cancel:true};
    }catch(_){}
  }
  return {};
};

// ── Transcript renderer (for extensions) ───────────────────────────────────
window.renderTranscript=function(container, messages, opts){
  if(!container||!Array.isArray(messages)) return container;
  opts=opts||{};
  container.innerHTML='';
  var md=window.renderMd||null;
  for(var i=0;i<messages.length;i++){
    var msg=messages[i];
    if(!msg||!msg.role||msg.role==='tool') continue;
    var content;
    if(typeof msg.content==='string'){
      content=msg.content;
    }else if(msg.content==null){
      content='';
    }else if(Array.isArray(msg.content)){
      // Multi-part content (OpenAI/Anthropic API style) — concatenate text parts.
      content=msg.content.map(function(p){return (p&&typeof p.text==='string')?p.text:''}).join('');
    }else{
      content=String(msg.content);
    }
    if(!content&&opts.skipEmpty) continue;
    var row=document.createElement('div');
    row.className='msg-row';
    row.setAttribute('data-role',msg.role);
    var body=document.createElement('div');
    body.className='msg-body';
    try{
      if(md){
        var html=md(content);
        if(html!=null){body.innerHTML=html}else{body.textContent=content}
      }else{
        body.textContent=content;
      }
    }catch(_){body.textContent=content}
    row.appendChild(body);
    container.appendChild(row);
  }
  if(typeof _rehydrateTransparentStreamDom==='function'){
    try{_rehydrateTransparentStreamDom(container);}catch(_){}
  }
  return container;
};

// ── Turn-based voice mode (#1333) ────────────────────────────────────────
// Chained flow: listen → send → (agent processes) → TTS response → listen again
(function(){
  const SpeechRecognition=window.SpeechRecognition||window.webkitSpeechRecognition;
  const hasSTT=!(!SpeechRecognition);
  const hasTTS=!!('speechSynthesis' in window);

  // Need both STT and TTS for turn-based voice mode
  if(!hasSTT||!hasTTS) return;

  const modeBtn=$('btnVoiceMode');
  const bar=$('voiceModeBar');
  const indicator=$('voiceModeIndicator');
  const label=$('voiceModeLabel');
  const micBtn=$('btnMic');
  const ta=$('msg');

  if(!modeBtn||!bar||!indicator||!label) return;

  // Voice-mode button is gated behind a Preferences toggle (#1488).
  // Default off — keeps the composer footer uncluttered for users who
  // only need plain dictation. The hands-free conversation feature is
  // a power-user surface; explicit opt-in avoids the visual confusion
  // of two near-identical mic icons.
  function _voiceModePrefEnabled(){
    try{ return localStorage.getItem('hermes-voice-mode-button')==='true'; }
    catch(_){ return false; }
  }
  let _voiceModeActive=false;

  function _applyVoiceModePref(){
    const enabled = _voiceModePrefEnabled();
    modeBtn.style.display = enabled ? '' : 'none';
    if(!enabled && _voiceModeActive) _deactivate();
  }
  _applyVoiceModePref();
  // Expose so the settings pane can re-apply immediately on toggle.
  window._applyVoiceModePref = _applyVoiceModePref;

  let _voiceModeState='idle'; // idle | listening | thinking | speaking
  let _recognition=null;
  let _silenceTimer=null;
  // Capture the session id at thinking-time so the TTS callback won't read
  // a different session's last assistant reply if the user navigated away
  // between send and stream completion. (Opus pre-release advisor.)
  let _voiceModeThinkingSid=null;
  let _browserTtsKeepAlive=null;
  let _browserTtsWatchdog=null;
  let _browserTtsSuppressNextErrorRearm=false;
  // Configurable via localStorage keys (set from dev console or a future settings panel).
  //   hermes-voice-silence-ms, pause duration before auto-send (ms, default 1800)
  //   hermes-voice-continuous, keep mic open across natural pauses ("true"/"false", default false)
  function _voiceSilenceMs(){
    const _silenceMsRaw=parseInt(localStorage.getItem('hermes-voice-silence-ms'),10);
    return (Number.isFinite(_silenceMsRaw)&&_silenceMsRaw>0)?Math.max(200,_silenceMsRaw):1800;
  }

  function _clearBrowserTtsRecovery(){
    if(_browserTtsKeepAlive){
      clearInterval(_browserTtsKeepAlive);
      _browserTtsKeepAlive=null;
    }
    if(_browserTtsWatchdog){
      clearTimeout(_browserTtsWatchdog);
      _browserTtsWatchdog=null;
    }
  }

  function _armBrowserTtsRecovery(clean, rate){
    _clearBrowserTtsRecovery();
    _browserTtsSuppressNextErrorRearm=false;
    const safeRate=(Number.isFinite(rate)&&rate>0)?rate:1;
    // Chromium can drop utter.onend on later turns, so force a recovery path.
    const watchdogMs=Math.max(4000,Math.round((String(clean||'').length/(12*safeRate))*1000)+10000);
    _browserTtsWatchdog=setTimeout(()=>{
      if(!_voiceModeActive||_voiceModeState!=='speaking') return;
      _browserTtsSuppressNextErrorRearm=true;
      try{ speechSynthesis.cancel(); }catch(_){}
      _clearBrowserTtsRecovery();
      _startListening();
    },watchdogMs);
    _browserTtsKeepAlive=setInterval(()=>{
      if(!_voiceModeActive||_voiceModeState!=='speaking'){
        _clearBrowserTtsRecovery();
        return;
      }
      if(!speechSynthesis.speaking) return;
      try{
        speechSynthesis.pause();
        speechSynthesis.resume();
      }catch(_){}
    },10000);
  }

  function _setState(state){
    _voiceModeState=state;
    indicator.className='voice-mode-indicator '+state;
    label.textContent=state==='listening'?t('voice_listening')
      :state==='speaking'?t('voice_speaking')
      :state==='thinking'?t('voice_thinking')
      :'';
    bar.style.display=_voiceModeActive?(state==='idle'?'none':''):'none';
  }

  function _startListening(){
    if(!_voiceModeActive) return;
    if(_micOriginNeedsSecureContext()){
      _deactivate();
      showToast(t('mic_insecure_origin'));
      return;
    }
    _clearBrowserTtsRecovery();
    _setState('listening');

    _recognition=new SpeechRecognition();
    _recognition.continuous=localStorage.getItem('hermes-voice-continuous')==='true';
    _recognition.interimResults=true;
    _recognition.lang=(typeof _locale!=='undefined'&&_locale._speech)||'en-US';

    let _finalText='';

    _recognition.onstart=()=>{ _finalText=''; };

    _recognition.onresult=(event)=>{
      // Reset silence timer on any result
      clearTimeout(_silenceTimer);
      let interim='';
      let final=_finalText;
      for(let i=event.resultIndex;i<event.results.length;i++){
        const txt=event.results[i][0].transcript;
        if(event.results[i].isFinal){ final+=txt; _finalText=final; }
        else{ interim+=txt; }
      }
      ta.value=final||interim;
      autoResize();

      // Auto-send on silence after final result
      if(_finalText){
        _silenceTimer=setTimeout(()=>{
          _voiceModeSend();
        },_voiceSilenceMs());
      }
    };

    _recognition.onend=()=>{
      clearTimeout(_silenceTimer);
      // If we have text and haven't sent yet, send it
      if(_finalText&&_voiceModeActive&&_voiceModeState==='listening'){
        _voiceModeSend();
      } else if(_voiceModeActive&&_voiceModeState==='listening'){
        // No speech detected — restart listening
        setTimeout(()=>{ if(_voiceModeActive) _startListening(); },500);
      }
    };

    _recognition.onerror=(event)=>{
      clearTimeout(_silenceTimer);
      if(event.error==='no-speech'||event.error==='aborted'){
        // Restart if still active
        if(_voiceModeActive){
          setTimeout(()=>{ if(_voiceModeActive) _startListening(); },800);
        }
        return;
      }
      if(event.error==='not-allowed'||event.error==='service-not-allowed'||event.error==='audio-capture'){
        _deactivate();
        const messageKey=_micToastKeyForRecognitionError(event.error);
        showToast(messageKey?t(messageKey):t('mic_error')+event.error);
        return;
      }
      // Other errors — try to restart
      if(_voiceModeActive){
        setTimeout(()=>{ if(_voiceModeActive) _startListening(); },1500);
      }
    };

    try{ _recognition.start(); }catch(e){
      // Already started or other error — retry shortly
      setTimeout(()=>{ if(_voiceModeActive) _startListening(); },1000);
    }
  }

  function _voiceModeSend(){
    if(!_voiceModeActive) return;
    const text=(ta.value||'').trim();
    if(!text){
      ta.value='';
      setTimeout(()=>{ if(_voiceModeActive) _startListening(); },300);
      return;
    }
    _setState('thinking');
    // Pin the active session id so the TTS callback won't speak a different
    // session's reply if the user navigates away mid-stream.
    _voiceModeThinkingSid=(typeof S!=='undefined'&&S.session)?S.session.session_id:null;
    try{ if(_recognition) _recognition.abort(); }catch(_){}
    _recognition=null;
    // send() is global from boot.js
    if(typeof send==='function') send();
  }

  function _speakResponse(){
    if(!_voiceModeActive) return;
    // Bail out if the user navigated to a different session between send and
    // stream completion. The patched autoReadLastAssistant fires globally;
    // without this guard it would TTS-read the wrong session's last assistant
    // message. Drop back to listening on the new session instead.
    const currentSid=(typeof S!=='undefined'&&S.session)?S.session.session_id:null;
    if(_voiceModeThinkingSid && currentSid && currentSid!==_voiceModeThinkingSid){
      _voiceModeThinkingSid=null;
      _startListening();
      return;
    }
    _voiceModeThinkingSid=null;
    _setState('speaking');

    // Find last assistant message
    const rows=document.querySelectorAll('.msg-row[data-role="assistant"], .assistant-segment[data-raw-text]');
    if(!rows.length){ _startListening(); return; }
    const last=rows[rows.length-1];
    const rawText=last.dataset.rawText||'';
    if(!rawText.trim()){ _startListening(); return; }

    // Strip for TTS (reuse existing helper if available)
    let clean=rawText;
    if(typeof _stripForTTS==='function') clean=_stripForTTS(rawText);
    else{
      // Basic strip: remove code blocks, images, links
      clean=clean.replace(/```[\s\S]*?```/g,' code block ')
        .replace(/`([^`]*)`/g,'$1')
        .replace(/!\[([^\]]*)\]\([^)]*\)/g,'$1')
        .replace(/\[([^\]]*)\]\([^)]*\)/g,'$1')
        .replace(/#{1,6}\s/g,'')
        .replace(/[*_~]+/g,'')
        .replace(/\n{2,}/g,'. ')
        .replace(/\n/g,' ')
        .trim();
    }
    if(!clean){ _startListening(); return; }
    const engine=localStorage.getItem("hermes-tts-engine")||"browser";
    // Extension-registered TTS engine (window.registerHermesTtsEngine): synth
    // via the extension, then play through the same Audio lifecycle as edge.
    if(typeof window._hermesTtsIsRegistered==='function' && window._hermesTtsIsRegistered(engine)){
      _ttsSpeaking=true;
      const _opts={
        voice: localStorage.getItem("hermes-tts-voice")||'',
        rate: parseFloat(localStorage.getItem("hermes-tts-rate")),
        pitch: parseFloat(localStorage.getItem("hermes-tts-pitch")),
      };
      Promise.resolve(window._hermesTtsSynth(engine, clean, _opts))
        .then(function(buf){
          const blob=new Blob([buf]);
          const url=URL.createObjectURL(blob);
          const audio=new Audio(url);
          _playingEdgeAudio=audio;
          audio.onended=function(){
            _ttsSpeaking=false;
            if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
            URL.revokeObjectURL(url);
            if(_voiceModeActive) setTimeout(function(){_startListening();},500);
          };
          audio.onerror=function(){
            _ttsSpeaking=false;
            if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
            URL.revokeObjectURL(url);
            if(_voiceModeActive) setTimeout(function(){_startListening();},1000);
          };
          audio.play().catch(function(){
            _ttsSpeaking=false;
            if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
            URL.revokeObjectURL(url);
            if(_voiceModeActive) setTimeout(function(){_startListening();},1000);
          });
        })
        .catch(function(){
          _ttsSpeaking=false;
          if(_voiceModeActive) setTimeout(function(){_startListening();},1000);
        });
      return;
    }
    if(engine==="elevenlabs"){
      _ttsSpeaking=true;
      fetch(new URL('api/tts', document.baseURI || location.href).href, {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({text: clean, engine: 'elevenlabs'})
      })
      .then(r => {
        if(!r.ok) throw new Error('TTS request failed: ' + r.status);
        return r.blob();
      })
      .then(blob => {
        const url = URL.createObjectURL(blob);
        const audio = new Audio(url);
        _playingEdgeAudio=audio;
        audio.onended = () => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          URL.revokeObjectURL(url);
          if(_voiceModeActive) setTimeout(()=>_startListening(),500);
        };
        audio.onerror = () => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          URL.revokeObjectURL(url);
          if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
        };
        audio.play().catch(e => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          URL.revokeObjectURL(url);
          if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
        });
      })
      .catch(() => {
        _ttsSpeaking=false;
        if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
      });
      return;
    }
    if(engine==="openai"){
      _ttsSpeaking=true;
      fetch(new URL('api/tts', document.baseURI || location.href).href, {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({text: clean, engine: 'openai'})
      })
      .then(r => {
        if(!r.ok) throw new Error('TTS request failed: ' + r.status);
        return r.blob();
      })
      .then(blob => {
        const url = URL.createObjectURL(blob);
        const audio = new Audio(url);
        _playingEdgeAudio=audio;
        audio.onended = () => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          URL.revokeObjectURL(url);
          if(_voiceModeActive) setTimeout(()=>_startListening(),500);
        };
        audio.onerror = () => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          URL.revokeObjectURL(url);
          if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
        };
        audio.play().catch(() => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          URL.revokeObjectURL(url);
          if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
        });
      })
      .catch(() => {
        _ttsSpeaking=false;
        if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
      });
      return;
    }
    if(engine==="edge"){
      const voice=localStorage.getItem("hermes-tts-voice")||"zh-CN-XiaoxiaoNeural";
      const savedRate=parseFloat(localStorage.getItem("hermes-tts-rate"));
      const savedPitch=parseFloat(localStorage.getItem("hermes-tts-pitch"));
      let rate='', pitch='';
      if(!isNaN(savedRate)){const pct=Math.round((savedRate-1)*100);const sign=pct>=0?'+':'';rate=sign+pct+'%';}
      if(!isNaN(savedPitch)){const hz=Math.round((savedPitch-1)*50);const sign=hz>=0?'+':'';pitch=sign+hz+'Hz';}
      _ttsSpeaking=true;
      fetch(new URL('api/tts', document.baseURI || location.href).href, {
        method: 'POST',
        headers: {'Content-Type': 'application/json'},
        body: JSON.stringify({text: clean, voice, rate, pitch, engine: 'edge'})
      })
      .then(r => {
        if(!r.ok) throw new Error('TTS request failed: ' + r.status);
        return r.blob();
      })
      .then(blob => {
        const url = URL.createObjectURL(blob);
        const audio = new Audio(url);
        // Register with the shared handle (declared in ui.js, same global scope;
        // both scripts are fully evaluated before any voice interaction) so
        // stopTTS() — called from _deactivate() — can actually pause hands-free
        // Edge playback. Without this the audio is local here and unstoppable.
        _playingEdgeAudio=audio;
        audio.onended = () => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          URL.revokeObjectURL(url);
          if(_voiceModeActive) setTimeout(()=>_startListening(),500);
        };
        audio.onerror = () => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          URL.revokeObjectURL(url);
          if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
        };
        audio.play().catch(e => {
          _ttsSpeaking=false;
          if(_playingEdgeAudio===audio) _playingEdgeAudio=null;
          if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
        });
      })
      .catch(() => {
        _ttsSpeaking=false;
        if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
      });
      return;
    }
    const utter=new SpeechSynthesisUtterance(clean);

    // Apply saved voice preferences
    const savedVoice=localStorage.getItem('hermes-tts-voice');
    const voices=speechSynthesis.getVoices();
    if(savedVoice&&voices.length){
      const match=voices.find(v=>v.name===savedVoice);
      if(match) utter.voice=match;
    }
    const savedRate=parseFloat(localStorage.getItem('hermes-tts-rate'));
    if(!isNaN(savedRate)) utter.rate=Math.min(2,Math.max(0.5,savedRate));
    const savedPitch=parseFloat(localStorage.getItem('hermes-tts-pitch'));
    if(!isNaN(savedPitch)) utter.pitch=Math.min(2,Math.max(0,savedPitch));

    utter.onend=()=>{
      _browserTtsSuppressNextErrorRearm=false;
      _clearBrowserTtsRecovery();
      // After speaking, go back to listening
      if(_voiceModeActive&&_voiceModeState==='speaking') setTimeout(()=>_startListening(),500);
    };
    utter.onerror=()=>{
      _clearBrowserTtsRecovery();
      if(_browserTtsSuppressNextErrorRearm){
        _browserTtsSuppressNextErrorRearm=false;
        return;
      }
      if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
    };

    _armBrowserTtsRecovery(clean, utter.rate);
    try{
      speechSynthesis.speak(utter);
    }catch(_){
      _clearBrowserTtsRecovery();
      if(_voiceModeActive) setTimeout(()=>_startListening(),1000);
    }
  }

  // Hook into response completion — observe when the agent finishes
  // We patch setComposerStatus to detect when a response completes
  const _origSetComposerStatus=(typeof setComposerStatus==='function')?setComposerStatus.bind(window):null;

  window._voiceModeOnResponseComplete=function(){
    if(_voiceModeActive&&_voiceModeState==='thinking'){
      // Small delay to let DOM render the final message
      setTimeout(()=>{
        if(_voiceModeActive&&_voiceModeState==='thinking'){
          _speakResponse();
        }
      },400);
    }
  };

  // Observe S.busy changes to detect response completion
  // The existing code calls setBusy(false) when response completes
  const _origSetBusy=(typeof setBusy==='function')?setBusy.bind(window):null;
  if(_origSetBusy){
    // We use a MutationObserver-style approach via polling S.busy
    // Actually, we'll use a simpler approach: hook into the message stream completion
  }

  // Most reliable hook: use the existing autoReadLastAssistant call site.
  // We override autoReadLastAssistant so that if voice mode is active, we use our
  // own speak-and-resume flow instead of the default auto-read.
  const _origAutoRead=(typeof autoReadLastAssistant==='function')?autoReadLastAssistant:null;
  window.autoReadLastAssistant=function(){
    if(_voiceModeActive&&_voiceModeState==='thinking'){
      _speakResponse();
      return;
    }
    if(_origAutoRead) _origAutoRead.apply(this,arguments);
  };

  function _activate(){
    if(_micOriginNeedsSecureContext()){
      showToast(t('mic_insecure_origin'));
      return;
    }
    _voiceModeActive=true;
    modeBtn.classList.add('active');
    _setButtonTooltip(modeBtn, t('voice_mode_toggle_active'));
    showToast(t('voice_mode_active'),1500);
    // If the agent is busy, wait — state will be 'thinking' and we'll detect completion
    if(typeof S!=='undefined'&&S.busy){
      _setState('thinking');
      return;
    }
    // Cancel any existing TTS
    if(typeof stopTTS==='function') stopTTS();
    _startListening();
  }

  function _deactivate(){
    _voiceModeActive=false;
    _voiceModeState='idle';
    _voiceModeThinkingSid=null;
    _browserTtsSuppressNextErrorRearm=false;
    modeBtn.classList.remove('active');
    _setButtonTooltip(modeBtn, t('voice_mode_toggle'));
    bar.style.display='none';
    clearTimeout(_silenceTimer);
    _clearBrowserTtsRecovery();
    try{ if(_recognition) _recognition.abort(); }catch(_){}
    _recognition=null;
    if(typeof stopTTS==='function') stopTTS();
    // Restore original autoReadLastAssistant
    if(_origAutoRead) window.autoReadLastAssistant=_origAutoRead;
    // Clear textarea if it was only voice input
    ta.value='';
    autoResize();
  }

  modeBtn.onclick=()=>{
    if(_voiceModeActive){
      _deactivate();
      showToast(t('voice_mode_off'),1500);
    }else{
      _activate();
    }
  };

  // Expose for external use
  window._voiceModeActive=()=>_voiceModeActive;
  window._voiceModeDeactivate=_deactivate;
  window._voiceModeImmediateSend=_voiceModeSend;
})();
function _currentSessionIsReusableEmptyChat(){
  if(!S.session) return false;
  const hasVisibleMessages=Array.isArray(S.messages)
    && S.messages.some(m=>m&&m.role&&m.role!=='tool');
  return (S.session.message_count||0)===0
    && !hasVisibleMessages
    && !S.busy
    && !S.session.active_stream_id
    && !S.session.pending_user_message;
}

$('fileInput').onchange=e=>{addFiles(Array.from(e.target.files));e.target.value='';};
$('btnNewChat').onclick=async()=>{
  // If the current session has no messages AND nothing is in flight, just focus
  // the composer rather than creating another empty session that will clutter the
  // sidebar list (#1171).
  //
  // The "nothing in flight" half is critical (#1432): if the user clicks + while
  // their first message is still streaming (or queued), `message_count` is still 0
  // server-side because the user turn hasn't been merged yet. The old guard treated
  // that as "empty" and made + a no-op for the entire stream duration, so users
  // couldn't actually start a parallel chat. Use the same in-flight signal as
  // `_restoreSettledSession()` in messages.js: an active stream id or a queued
  // pending user message means the session is real, not empty.
  if(_currentSessionIsReusableEmptyChat()){
    $('msg').focus();closeMobileSidebar();return;
  }
  if(typeof _restoreRememberedNewChatDraftSession==='function'
     && await _restoreRememberedNewChatDraftSession()){
    await renderSessionList();closeMobileSidebar();$('msg').focus();return;
  }
  await newSession();await renderSessionList();closeMobileSidebar();$('msg').focus();
};
$('btnDownload').onclick=()=>{
  if(!S.session)return;
  const blob=new Blob([transcript()],{type:'text/markdown'});
  const a=document.createElement('a');a.href=URL.createObjectURL(blob);
  a.download=`hermes-${S.session.session_id}.md`;a.click();URL.revokeObjectURL(a.href);
};
function _buildSessionExportUrl(sessionId,params){
  const url=new URL('api/session/export',document.baseURI||location.href);
  url.searchParams.set('session_id',String(sessionId||''));
  Object.entries(params||{}).forEach(([key,value])=>{
    if(value!==undefined&&value!==null)url.searchParams.set(key,String(value));
  });
  return url.href;
}
$('btnExportJSON').onclick=()=>{
  if(!S.session)return;
  const url=_buildSessionExportUrl(S.session.session_id);
  const a=document.createElement('a');a.href=url;
  a.download=`hermes-${S.session.session_id}.json`;a.click();
};
$('btnShareSession').onclick=async()=>{
  if(!S.session) return;
  try{
    const existing=(S.session&&S.session.share_token)?new URL(`/share/${encodeURIComponent(S.session.share_token)}`,location.origin).href:null;
    if(existing){
      const reuse=await showConfirmDialog({
        title:t('share_session'),
        message:t('share_session_existing_confirm'),
        confirmLabel:t('share_session_copy_existing'),
        cancelLabel:t('share_session_refresh_snapshot'),
      });
      if(reuse){
        await _copyText(existing);
        showToast(t('share_session_link_copied'));
        window.open(existing,'_blank','noopener');
        return;
      }
    }
    const res=await api('/api/share/create',{method:'POST',body:JSON.stringify({session_id:S.session.session_id})});
    if(res&&res.session) S.session=res.session;
    const href=new URL(String(res&&res.share&&res.share.url||''),location.origin).href;
    await _copyText(href);
    showToast(t('share_session_created'));
    if(typeof _syncHermesPanelSessionActions==='function') _syncHermesPanelSessionActions();
    window.open(href,'_blank','noopener');
  }catch(err){
    showToast(t('share_session_failed')+(err&&err.message?err.message:String(err||'')),4000,'error');
  }
};
$('btnStopSharingSession').onclick=async()=>{
  if(!S.session||!S.session.share_token) return;
  const ok=await showConfirmDialog({
    title:t('stop_sharing_session'),
    message:t('stop_sharing_session_confirm'),
    confirmLabel:t('stop_sharing_session'),
    danger:true,
  });
  if(!ok) return;
  try{
    const res=await api('/api/share/revoke',{method:'POST',body:JSON.stringify({session_id:S.session.session_id})});
    if(res&&res.session) S.session=res.session;
    showToast(t('share_session_revoked'));
    if(typeof _syncHermesPanelSessionActions==='function') _syncHermesPanelSessionActions();
  }catch(err){
    showToast(t('share_session_revoke_failed')+(err&&err.message?err.message:String(err||'')),4000,'error');
  }
};
function exportSessionHTML(session){
  const target=session||S.session;
  if(!target||!target.session_id)return;
  const sid=target.session_id;
  const theme=document.documentElement.classList.contains('dark')?'dark':'light';
  // Capture the live WebUI palette so the export matches the user's active
  // theme + skin exactly, not just the built-in dark/light fallback. Map each
  // export-template variable to its WebUI source; getComputedStyle resolves to
  // the currently rendered colour regardless of which skin is selected.
  const cs=getComputedStyle(document.documentElement);
  const read=(...names)=>{for(const n of names){const v=cs.getPropertyValue(n).trim();if(v)return v;}return '';};
  const palette={
    'bg':read('--bg'),
    'panel':read('--surface','--bg'),
    'panel2':read('--code-bg','--surface'),
    'border':read('--border'),
    'text':read('--text'),
    'muted':read('--muted','--text'),
    'accent':read('--accent'),
    'code-bg':read('--code-bg'),
    'code-border':read('--border2','--border'),
    'code-text':read('--text'),
  };
  // Drop empties so the inlined fallback keeps working for anything we couldn't read.
  const clean={};for(const k in palette){if(palette[k])clean[k]=palette[k];}
  const paletteB64=btoa(unescape(encodeURIComponent(JSON.stringify(clean))));
  const url=_buildSessionExportUrl(sid,{format:'html',theme,palette:paletteB64});
  const a=document.createElement('a');a.href=url;
  a.download=`hermes-${sid}.html`;a.click();
}
$('btnExportHTML').onclick=()=>exportSessionHTML();
$('btnImportJSON').onclick=()=>$('importFileInput').click();
$('importFileInput').onchange=async(e)=>{
  const file=e.target.files[0];
  if(!file)return;
  e.target.value='';
  try{
    const text=await file.text();
    const data=JSON.parse(text);
    const res=await api('/api/session/import',{method:'POST',body:JSON.stringify(data)});
    if(res.ok&&res.session){
      await loadSession(res.session.session_id);
      await renderSessionList();
      if(_currentPanel==='settings') switchPanel('chat');
      showToast(t('session_imported'));
    }
  }catch(err){
    showToast(t('import_failed')+(err.message||t('import_invalid_json')));
  }
};
// btnRefreshFiles is now panel-icon-btn in header (see HTML)
function clearPreview(opts={}){
  const keepPanelOpen=!!(opts&&opts.keepPanelOpen);
  // Restore directory breadcrumb after closing file preview
  if(typeof renderBreadcrumb==='function') renderBreadcrumb();
  const closePanelAfter=_workspacePanelMode==='preview'&&!keepPanelOpen;
  const pa=$('previewArea');if(pa)pa.classList.remove('visible');
  const pi=$('previewImg');if(pi){pi.onerror=null;pi.src='';}
  const pdf=$('previewPdfFrame');if(pdf)pdf.src='';
  const html=$('previewHtmlIframe');if(html)html.src='';
  const pm=$('previewMd');if(pm)pm.innerHTML='';
  const pc=$('previewCode');if(pc)pc.textContent='';
  const pp=$('previewPathText');if(pp)pp.textContent='';
  const ft=$('fileTree');if(ft)ft.style.display='';
  _previewCurrentPath='';_previewCurrentMode='';_previewDirty=false;
  if(closePanelAfter)closeWorkspacePanel();
  else if(keepPanelOpen&&_workspacePanelMode==='preview')openWorkspacePanel('browse');
  else syncWorkspacePanelUI();
}
$('btnClearPreview').onclick=handleWorkspaceClose;
// workspacePath click handler removed -- use topbar workspace chip dropdown instead
function _applySessionContextMetadataUpdate(data){
  if(!S.session||!data||!data.session)return;
  S.session.context_length=data.session.context_length||0;
  S.session.threshold_tokens=data.session.threshold_tokens||0;
  S.session.last_prompt_tokens=data.session.last_prompt_tokens||0;
  S.session.post_compression_context_tokens_estimate=data.session.post_compression_context_tokens_estimate||null;
  if(typeof _syncCtxIndicator==='function'){
    const u=S.lastUsage||{};
    const _pick=(latest,stored,dflt=0)=>latest!=null?latest:(stored!=null?stored:dflt);
    _syncCtxIndicator({
      input_tokens:_pick(u.input_tokens,S.session.input_tokens),
      output_tokens:_pick(u.output_tokens,S.session.output_tokens),
      estimated_cost:_pick(u.estimated_cost,S.session.estimated_cost),
      context_length:S.session.context_length||0,
      last_prompt_tokens:_pick(u.last_prompt_tokens,S.session.last_prompt_tokens),
      post_compression_context_tokens_estimate:S.session.post_compression_context_tokens_estimate,
      threshold_tokens:S.session.threshold_tokens||0,
    });
  }
}

$('modelSelect').onchange=async()=>{
  const selectedModel=$('modelSelect').value;
  const modelState=(typeof _modelStateForSelect==='function')
    ? _modelStateForSelect($('modelSelect'),selectedModel)
    : {model:selectedModel,model_provider:null};
  if(typeof clearProfileTransitionReasoningContext==='function') clearProfileTransitionReasoningContext();
  if(typeof closeModelDropdown==='function') closeModelDropdown();
  if(typeof _writePersistedModelState==='function') _writePersistedModelState(modelState.model,modelState.model_provider);
  else try{localStorage.setItem('hermes-webui-model',modelState.model)}catch{}
  if(!S.session){
    if(typeof _rememberEmptyComposerModelOverride==='function') _rememberEmptyComposerModelOverride(modelState.model,modelState.model_provider);
    if(typeof syncModelChip==='function') syncModelChip();
    if(typeof syncReasoningChip==='function') syncReasoningChip();
    return;
  }
  if(typeof _rememberPendingSessionModel==='function') _rememberPendingSessionModel(S.session.session_id,modelState.model,modelState.model_provider);
  S.session.model=modelState.model;
  S.session.model_provider=modelState.model_provider||null;
  if(typeof syncModelChip==='function') syncModelChip();
  if(typeof syncReasoningChip==='function') syncReasoningChip();
  syncTopbar();
  // Clarify scope: composer model changes are session-local, not the global default.
  if(typeof showToast==='function'){
    showToast(t('model_scope_toast')||'Applies to this conversation from your next message.', 3000);
  }
  const data=await api('/api/session/update',{method:'POST',body:JSON.stringify({
    session_id:S.session.session_id,
    workspace:S.session.workspace,
    model:modelState.model,
    model_provider:modelState.model_provider||null,
  })});
  // NOTE: do NOT clear the pending explicit-pick marker here. It must survive until
  // the NEXT send() consumes it, otherwise the normal "pick → session-update → send"
  // flow loses the explicit-pick signal before /api/chat/start runs and the server
  // re-reverts a cross-family pick (the #3737 bug, Codex catch). send() clears it
  // after reading a matching pending pick. (#3739/#3737)
  _applySessionContextMetadataUpdate(data);
  // Warn if selected model belongs to a different provider than what Hermes is configured for
  if(typeof _checkProviderMismatch==='function'){
    const warn=_checkProviderMismatch(selectedModel);
    if(warn&&typeof showToast==='function') showToast(warn,4000);
  }
};
$('msg').addEventListener('input',()=>{
  updateSendBtn();
  scheduleComposerAutoResize();
  // Persist composer draft to server (debounced in _saveComposerDraft).
  const sid = S && S.session && S.session.session_id;
  if (sid && typeof _saveComposerDraft === 'function') {
    _saveComposerDraft(sid, $('msg').value, S.pendingFiles ? [...S.pendingFiles] : []);
  }
  const text=$('msg').value;
  const _slashIdx=typeof _activeSlashCommandOffset==='function'?_activeSlashCommandOffset(text):-1;
  if(_slashIdx>=0&&text.indexOf('\n')===-1){
    if(typeof getSlashAutocompleteMatches==='function'){
      getSlashAutocompleteMatches(text).then(matches=>{
        if(($('msg').value||'')!==text) return;
        if(matches.length)showCmdDropdown(matches); else hideCmdDropdown();
      });
    }else{
      const prefix=text.slice(_slashIdx+1);
      const matches=getMatchingCommands(prefix);
      if(matches.length)showCmdDropdown(matches); else hideCmdDropdown();
    }
    if(typeof ensureSkillCommandsLoadedForAutocomplete==='function') ensureSkillCommandsLoadedForAutocomplete();
  } else if(typeof getComposerPathAutocompleteMatches==='function'){
    const cursor=$('msg').selectionStart;
    getComposerPathAutocompleteMatches(text,cursor).then(matches=>{
      const ta=$('msg');
      if(!ta||ta.value!==text||ta.selectionStart!==cursor) return;
      if(matches.length)showCmdDropdown(matches); else hideCmdDropdown();
    }).catch(()=>hideCmdDropdown());
  } else {
    hideCmdDropdown();
  }
});
// #5514/#5515: re-pin the transcript on ANY composer height change, not only the
// ones that route through the input->autoResize path. A multi-line paste
// (WisprFlow), a draft restore, an attachment tray / selection-chip appearing, a
// programmatic value set, or a font/reflow can all grow the composer and shrink
// the flex:1 transcript viewport, stranding a pinned reader above the bottom
// (reads as a "random" upward jump — #5515). Observe the whole #composerWrap
// (not just #msg) so tray/chip growth is covered too, at one seam. The re-pin is
// guarded (only fires when genuinely pinned), so it never fights a reader who
// scrolled away. First callback fires on observe (initial size) — the guard
// makes that a cheap no-op.
(()=>{
  const _cw=$('composerWrap')||$('msg');
  if(!_cw || typeof ResizeObserver!=='function' || typeof _repinMessagesAfterComposerResize!=='function') return;
  let _lastComposerH=_cw.offsetHeight;
  const _ro=new ResizeObserver(()=>{
    const h=_cw.offsetHeight;
    if(h<=_lastComposerH){_lastComposerH=h;return;}   // shrink/no-op: enlarges the viewport, can't strand
    _lastComposerH=h;
    _repinMessagesAfterComposerResize();               // grow: re-pin the pinned reader
  });
  try{ _ro.observe(_cw); }catch(_){ }
})();
// Track IME composition for East Asian input. Safari fires the committing
// keydown AFTER compositionend with isComposing=false, so we also keep a
// manual flag and reset it on the next tick to swallow that trailing Enter.
// Also reset on blur so the flag can never get stuck in a true state if
// compositionend never fires (focus loss with some IME implementations).
//
// The `_imeComposing` flag is bound to the chat composer (`#msg`); other
// inputs (session/project rename, app dialog, message edit, workspace rename)
// rely on the state-free `e.isComposing || e.keyCode === 229` part of
// `_isImeEnter`, which is sufficient for the Safari race because keyCode 229
// is the canonical "still composing" signal regardless of which field is
// focused. Promote `_isImeEnter` to `window` so other modules can reuse it
// without duplicating the full IIFE per input (issue #1443).
let _imeComposing=false;
(()=>{const _c=$('msg');if(!_c)return;
  _c.addEventListener('compositionstart',()=>{_imeComposing=true;});
  _c.addEventListener('compositionend',()=>{setTimeout(()=>{_imeComposing=false;},0);});
  _c.addEventListener('blur',()=>{_imeComposing=false;});
})();
function _isImeEnter(e){return e.isComposing||e.keyCode===229||_imeComposing;}
window._isImeEnter=_isImeEnter;
// #3076: a touch-primary device (`pointer:coarse`) can still have a
// physical keyboard attached (Android tablet + Bluetooth keyboard,
// detachable Surface in tablet mode, iPad + Magic Keyboard). When that
// happens we should NOT force the mobile newline-on-Enter override
// because Shift+Enter / Ctrl+Enter come from real keys and the user
// expects desktop semantics. `matchMedia('(any-pointer:fine)')` is true
// whenever ANY available pointing device is fine-grained — which is the
// strongest signal browsers expose for "there is a real keyboard /
// trackpad in the picture too". Skip the mobile default in that case.
function _hasFinePointerCoexisting(){
  try{ return matchMedia('(any-pointer:fine)').matches; }catch(_){ return false; }
}
// Detect phone software keyboards without undoing #3076's hardware-input
// guard for tablets. Some iOS Safari versions report (any-pointer:fine) on a
// plain iPhone, so phone UAs bypass that unreliable signal. Tablets and
// touch-capable desktop UAs still require a coarse pointer with no fine pointer.
function _isTouchOnlyDevice(){
  const ua=navigator.userAgent||'';
  if(/iPhone|iPod/i.test(ua)) return true;
  if(/Android.*Mobile/i.test(ua)) return true;
  try{
    return matchMedia('(pointer:coarse)').matches&&!_hasFinePointerCoexisting();
  }catch(_){}
  return false;
}
function _isNumpadEnter(e){
  return e.key==='Enter'&&(e.code==='NumpadEnter'||e.location===KeyboardEvent.DOM_KEY_LOCATION_NUMPAD);
}
// Initialise _sendKey synchronously from the localStorage cache so the keydown
// handler below has the correct value before the async /api/settings call
// (line ~3231) resolves. Without this, on slow mobile networks the race window
// leaves _sendKey=undefined, _mobileDefault evaluates false, and plain Enter
// falls through to the `else { send() }` branch — sending the message instead
// of inserting a newline (issue: mobile Enter sends on fresh page load).
try{ window._sendKey=localStorage.getItem('hermes-pref-send_key')||'enter'; }catch(_){ window._sendKey='enter'; }
$('msg').addEventListener('keydown',e=>{
  // Autocomplete navigation when dropdown is open
  const dd=$('cmdDropdown');
  const dropdownOpen=dd&&dd.classList.contains('open');
  if(dropdownOpen){
    if(e.key==='ArrowUp'){e.preventDefault();navigateCmdDropdown(-1);return;}
    if(e.key==='ArrowDown'){e.preventDefault();navigateCmdDropdown(1);return;}
    if(e.key==='Tab'){e.preventDefault();selectCmdDropdownItem();return;}
    if(e.key==='Escape'){e.preventDefault();e.stopPropagation();hideCmdDropdown();return;}
    if(e.key==='Enter'&&!e.shiftKey){
      if(_isImeEnter(e)){return;}
      if(window._sendKey==='shift+enter'){
        return;
      }
      e.preventDefault();
      selectCmdDropdownItem();
      return;
    }
  }
  // Send key: respect user preference.
  // On touch-primary devices (coarse pointer, no fine pointer co-existing),
  // default to Enter = newline regardless of whether the visual viewport has
  // shrunk. The viewport-shrink heuristic (_isVirtualKeyboardLikelyOpen) was
  // unreliable on iOS Safari and some Android browsers where the keyboard
  // doesn't consistently reduce vv.height by >120px. The pointer media query
  // pair is a sufficient and more reliable signal for "software keyboard only".
  // Hardware keyboards on tablets are covered by _hasFinePointerCoexisting.
  // The 'ctrl+enter' and 'shift+enter' settings also use this behavior
  // (plain Enter = newline).
  // Users can override in Settings by explicitly choosing 'enter' mode.
  if(e.key==='Enter'){
    if(_isImeEnter(e)){return;}
    const isNumpadEnter=_isNumpadEnter(e);
    const _mobileDefault=_isTouchOnlyDevice()
      &&(window._sendKey==='enter'||typeof window._sendKey==='undefined');
    if(window._sendKey==='shift+enter'){
      if(e.shiftKey){e.preventDefault();send();}
    } else if(window._sendKey==='ctrl+enter'||_mobileDefault){
      if(isNumpadEnter||e.ctrlKey||e.metaKey){e.preventDefault();send();}
    } else {
      if(!e.shiftKey){e.preventDefault();send();}
    }
  }
});
// B14: Cmd/Ctrl+K creates a new chat from anywhere
document.addEventListener('keydown',async e=>{
  // Cmd/Ctrl+B toggles desktop sidebar collapse (VS Code convention).
  // Skip when typing in an input/textarea/contenteditable so text-edit
  // shortcuts (e.g. bold in some embedded editors) are never stolen.
  if((e.metaKey||e.ctrlKey)&&!e.shiftKey&&!e.altKey&&(e.key==='b'||e.key==='B')){
    const t=e.target;
    const isText=t&&(t.tagName==='INPUT'||t.tagName==='TEXTAREA'||t.isContentEditable);
    if(!isText&&typeof toggleSidebar==='function'&&_isDesktopWidth()){
      e.preventDefault();
      toggleSidebar();
      return;
    }
  }
  // Cmd/Ctrl+/ focuses the message composer without creating a chat.
  // Match on the '/' CHARACTER (e.key), not the physical key position: on QWERTZ
  // layouts the physical Slash key produces Ctrl+- (browser zoom-out) and '/' is
  // typed as Shift+7, so matching the physical code both steals zoom and misses
  // the real '/' chord. e.key==='/' is layout-correct on every keyboard.
  if((e.metaKey||e.ctrlKey)&&!e.altKey&&e.key==='/'){
    const t=e.target;
    const isText=t&&(t.tagName==='INPUT'||t.tagName==='TEXTAREA'||t.isContentEditable);
    if(isText) return;
    const composer=$('msg');
    if(composer){e.preventDefault();composer.focus();}
    return;
  }
  // Enter on approval card = Allow once (when a button inside the card is focused or
  // card is visible and focus is not on an input/textarea/select)
  if(e.key==='Enter'&&!e.metaKey&&!e.ctrlKey&&!e.shiftKey){
    const card=$('approvalCard');
    const tag=(document.activeElement||{}).tagName||'';
    if(card&&card.classList.contains('visible')&&tag!=='TEXTAREA'&&tag!=='INPUT'&&tag!=='SELECT'){
      e.preventDefault();
      if(typeof respondApproval==='function') respondApproval('once');
      return;
    }
  }
  if((e.metaKey||e.ctrlKey)&&e.key==='k'){
    const t=e.target;
    const isText=t&&(t.tagName==='INPUT'||t.tagName==='TEXTAREA'||t.isContentEditable);
    if(isText) return;
    e.preventDefault();
    // If the current session has no messages AND nothing is in flight, just focus
    // the composer rather than creating another empty session that will clutter
    // the sidebar list (#1171). See the matching guard in $('btnNewChat').onclick
    // and bug #1432 for why the in-flight check is needed.
    if(_currentSessionIsReusableEmptyChat()){
      $('msg').focus();return;
    }
    // Cmd/Ctrl+K should always create a new conversation, even while the current
    // one is still streaming. The old !S.busy guard meant users had to wait for
    // a long generation to finish before they could start something new — exactly
    // the moment they want to switch context. newSession() leaves the in-flight
    // stream running on its own session; the user just gets a fresh blank one.
    await newSession();await renderSessionList();closeMobileSidebar();$('msg').focus();
  }
  // Cmd/Ctrl+, opens/closes Settings (VS Code convention).
  // Fire globally — like VS Code, don't skip text inputs.
  if((e.metaKey||e.ctrlKey)&&!e.shiftKey&&!e.altKey&&e.key===','){
    e.preventDefault();
    if(typeof toggleSettings==='function') toggleSettings();
    return;
  }
  if(e.key==='Escape'){
    // Close onboarding overlay if open (skip/dismiss the wizard)
    const onboardingOverlay=$('onboardingOverlay');
    if(onboardingOverlay&&onboardingOverlay.style.display!=='none'){
      if(typeof skipOnboarding==='function') skipOnboarding();
      return;
    }
    // Close settings panel if active
    if(_currentPanel==='settings'){_closeSettingsPanel();return;}
    // Close workspace dropdown
    closeWsDropdown();
    // Clear session search
    const ss=$('sessionSearch');
    if(ss&&ss.value){
      if(typeof clearSessionSearch==='function') clearSessionSearch(false);
      else { ss.value=''; filterSessions(); }
    }
    // Cancel any active message edit
    const editArea=document.querySelector('.msg-edit-area');
    if(editArea){
      const bar=editArea.closest('.msg-row')&&editArea.closest('.msg-row').querySelector('.msg-edit-bar');
      if(bar){const cancel=bar.querySelector('.msg-edit-cancel');if(cancel)cancel.click();}
    }
    // Blur composer to enable j/k message navigation.
    // Skip while an IME candidate window is composing — Escape there should
    // dismiss the candidate, not blur the composer (CJK input).
    if(document.activeElement===$('msg') && !e.isComposing && !_imeComposing){
      $('msg').blur();
    }
  }
});
const LARGE_TEXT_PASTE_CHAR_THRESHOLD=4000;
const LARGE_TEXT_PASTE_LINE_THRESHOLD=100;
function _largeTextPasteLineCount(text){
  const value=String(text||'');
  const lines=value.split('\n');
  return value.endsWith('\n')?lines.length-1:lines.length;
}
function _shouldAttachLargePastedText(text){
  if(window._largeTextPasteAsAttachment===false)return false;
  const value=String(text||'');
  if(!value.trim())return false;
  return value.length>=LARGE_TEXT_PASTE_CHAR_THRESHOLD || _largeTextPasteLineCount(value)>=LARGE_TEXT_PASTE_LINE_THRESHOLD;
}
function _largeTextPasteFileName(now){
  const d=new Date(now||Date.now());
  const p=n=>String(n).padStart(2,'0');
  const stamp=`${d.getFullYear()}-${p(d.getMonth()+1)}-${p(d.getDate())}_${p(d.getHours())}-${p(d.getMinutes())}-${p(d.getSeconds())}-${String(d.getMilliseconds()).padStart(3,'0')}`;
  const existing=new Set((S.pendingFiles||[]).map(f=>f&&f.name).filter(Boolean));
  let name=`pasted-text-${stamp}.md`;
  for(let i=2;existing.has(name);i++)name=`pasted-text-${stamp}-${i}.md`;
  return name;
}
function _largeTextPasteFile(text,now){
  const name=_largeTextPasteFileName(now||Date.now());
  return new File([String(text||'')],name,{type:'text/markdown;charset=utf-8'});
}
function _largeTextPasteFitsUploadLimit(file){
  return !(file&&typeof MAX_UPLOAD_BYTES==='number'&&file.size>MAX_UPLOAD_BYTES);
}
function _attachLargePastedText(file){
  addFiles([file]);
  if(typeof setStatus==='function')setStatus(t('text_pasted')+file.name);
  return file;
}
$('msg').addEventListener('paste',e=>{
  const items=Array.from(e.clipboardData?.items||[]);
  // Extract image items (kind==='file' filter avoids misclassifying text/html
  // with embedded data URIs as images).
  const imageItems=items.filter(i=>i.kind==='file'&&i.type.startsWith('image/'));
  if(imageItems.length){
    // If text is also present (common when copying images from browsers, Notes,
    // Slack, etc.), let the browser paste the text normally AND attach the image.
    // Only preventDefault when the clipboard is image-only (true screenshot paste).
    const hasText=items.some(i=>i.kind==='string'&&(i.type==='text/plain'||i.type==='text/html'));
    if(!hasText)e.preventDefault();
    const pasteTs=Date.now();
    const files=imageItems.map((i,idx)=>{
      const blob=i.getAsFile();
      const ext=i.type.split('/')[1]||'png';
      const suffix=imageItems.length>1?`-${idx+1}`:'';
      return new File([blob],`screenshot-${pasteTs}${suffix}.${ext}`,{type:i.type});
    });
    addFiles(files);
    setStatus(t('image_pasted')+files.map(f=>f.name).join(', '));
    return;
  }
  const plainText=e.clipboardData?.getData('text/plain')||'';
  if(!_shouldAttachLargePastedText(plainText))return;
  const pastedTextFile=_largeTextPasteFile(plainText);
  if(!_largeTextPasteFitsUploadLimit(pastedTextFile))return;
  e.preventDefault();
  _attachLargePastedText(pastedTextFile);
});
document.querySelectorAll('.suggestion').forEach(btn=>{
  btn.onclick=()=>{$('msg').value=btn.dataset.msg;send();};
});

function applyEmptyStateSuggestionPref(){
  if(!$('emptyState')) return;
  $('emptyState').classList.toggle('no-suggestions',window._hideEmptyStateSuggestions===true);
}

function applyEmptyStatePanelPref(){
  if(!$('emptyState')) return;
  $('emptyState').classList.toggle('no-welcome',window._hideEmptyStatePanel===true);
}

window.addEventListener('resize',()=>{
  _syncWorkspacePanelInlineWidth();
  syncWorkspacePanelState();
  if(!window.visualViewport) _forceMobileViewportReflow();
});

// On PWAs / mobile browsers that expose visualViewport, keyboard show/hide and
// URL-bar collapse fire visualViewport resize/scroll rather than window resize.
// Debounce a reflow so the phone layout repaints against the new geometry.
if(window.visualViewport){
  _syncKeyboardBottomInset();
  let _mobileViewportReflowTimer=0;
  const _scheduleMobileViewportReflow=()=>{
    if(_mobileViewportReflowTimer) clearTimeout(_mobileViewportReflowTimer);
    _mobileViewportReflowTimer=setTimeout(()=>{
      _mobileViewportReflowTimer=0;
      _forceMobileViewportReflow();
    },60);
  };
  window.visualViewport.addEventListener('resize', _scheduleMobileViewportReflow);
  window.visualViewport.addEventListener('scroll', _scheduleMobileViewportReflow);
}

// Boot: restore last session or start fresh
// ── Resizable panels ──────────────────────────────────────────────────────
(function(){
  const SIDEBAR_MIN=180, SIDEBAR_MAX=420;
  const PANEL_MIN=180,   PANEL_MAX=1200;

  function initResize(handleId, targetEl, edge, minW, maxW, storageKey){
    const handle = $(handleId);
    if(!handle || !targetEl) return;

    // Restore saved width
    if(storageKey === 'hermes-panel-w'){
      _syncWorkspacePanelInlineWidth();
    }else{
      const saved = localStorage.getItem(storageKey);
      if(saved) targetEl.style.width = saved + 'px';
    }

    let startX=0, startW=0;

    handle.addEventListener('mousedown', e=>{
      e.preventDefault();
      startX = e.clientX;
      startW = targetEl.getBoundingClientRect().width;
      handle.classList.add('dragging');
      document.body.classList.add('resizing');

      const onMove = ev=>{
        const delta = edge==='right' ? ev.clientX - startX : startX - ev.clientX;
        const newW = Math.min(maxW, Math.max(minW, startW + delta));
        targetEl.style.width = newW + 'px';
      };
      const onUp = ()=>{
        handle.classList.remove('dragging');
        document.body.classList.remove('resizing');
        localStorage.setItem(storageKey, parseInt(targetEl.style.width));
        document.removeEventListener('mousemove', onMove);
        document.removeEventListener('mouseup', onUp);
      };
      document.addEventListener('mousemove', onMove);
      document.addEventListener('mouseup', onUp);
    });
  }

  // Run after DOM ready (called from boot)
  window._initResizePanels = function(){
    const sidebar    = document.querySelector('.sidebar');
    const rightpanel = document.querySelector('.rightpanel');
    initResize('sidebarResize',    sidebar,    'right', SIDEBAR_MIN, SIDEBAR_MAX, 'hermes-sidebar-w');
    initResize('rightpanelResize', rightpanel, 'left',  PANEL_MIN,   PANEL_MAX,   'hermes-panel-w');
  };
})();

// ── Appearance helpers (theme = light/dark/system, skin = palette/accent) ────
const _THEMES=[
  {name:'Light', value:'light', colors:['#FEFCF7','#FAF7F0','#B8860B']},
  {name:'Dark', value:'dark', colors:['#0D0D1A','#141425','#FFD700']},
  {name:'System', value:'system', colors:['#FEFCF7','#0D0D1A','#B8860B']},
];
const _SKINS=[
  {name:'Default',  colors:['#FFD700','#FFBF00','#CD7F32']},
  {name:'Ares',     colors:['#FF4444','#CC3333','#992222']},
  {name:'Mono',     colors:['#CCCCCC','#999999','#666666']},
  {name:'Graphite', colors:['#FFFFFF','#D6D6D6','#242424']},
  {name:'GitHub', colors:['#0969DA','#1F883D','#242424']},
  {name:'Codex', colors:['#72B39A','#242624','#ECEBE4']},
  {name:'Terracotta', colors:['#D97757','#F0EEE6','#141413']},
  {name:'Slate',    colors:['#334155','#475569','#64748b']},
  {name:'Poseidon', colors:['#0EA5E9','#0284C7','#0369A1']},
  {name:'Sisyphus', colors:['#A78BFA','#8B5CF6','#7C3AED']},
  {name:'Charizard',colors:['#FB923C','#F97316','#EA580C']},
  {name:'Sienna',   colors:['#D97757','#C06A49','#9A523A']},
  {name:'Catppuccin',colors:['#CBA6F7','#B4BEFE','#8839EF']},
  {name:'Hepburn',   colors:['#c6246a','#ec5597','#f2abca']},
  {name:'Nous',     colors:['#4682B4','#3A6E9A','#2C5F88']},
  {name:'Neon',     colors:['#B347FF','#C76BFF','#00DDFF']},
  {name:'Neon Soft', value:'neon-soft', colors:['#B347FF','#C76BFF','#00DDFF']},
  {name:'Neon Paint', value:'neon-paint', colors:['#FF2D95','#00E5FF','#FFB800']},
  {name:'Geist Contrast', value:'geist-contrast', colors:['#000000','#ffffff','#FFF175']},
  {name:'Zeus',     colors:['#FFD700','#FFBF00','#1A1A00']},
  {name:'Verdigris', value:'verdigris', colors:['#C89A5A','#0F1714','#22342C']},
];
const _VALID_THEMES=new Set((_THEMES||[]).map(t=>t.value));
const _VALID_SKINS=new Set((_SKINS||[]).map(s=>(s.value||s.name).toLowerCase()));
const _LEGACY_THEME_MAP={
  slate:{theme:'dark',skin:'slate'},
  solarized:{theme:'dark',skin:'poseidon'},
  monokai:{theme:'dark',skin:'sisyphus'},
  nord:{theme:'dark',skin:'slate'},
  oled:{theme:'dark',skin:'default'},
};
let _systemThemeMq=null;
let _onSystemThemeChange=null;
let _resolvedThemeBaseDark=false;

function _normalizeAppearance(theme,skin){
  const rawTheme=typeof theme==='string'?theme.trim().toLowerCase():'';
  const rawSkin=typeof skin==='string'?skin.trim().toLowerCase():'';
  const legacy=_LEGACY_THEME_MAP[rawTheme];
  const nextTheme=legacy?legacy.theme:(_VALID_THEMES.has(rawTheme)?rawTheme:'dark');
  const nextSkin=_VALID_SKINS.has(rawSkin)?rawSkin:(legacy?legacy.skin:'default');
  return {theme:nextTheme,skin:nextSkin};
}

// Sync <meta name="theme-color"> with the active theme's app chrome color.
// This surfaces the WebUI's exact theme background to:
//   1. Mobile Safari status bar (the prefers-color-scheme media variants in index.html
//      cover the pre-load case; this updater handles user-toggled changes mid-session).
//   2. iOS PWA / Add to Home Screen status bar.
//   3. Native WKWebView wrappers (e.g. hermes-swift-mac) that read this attribute as
//      the source of truth for AppKit chrome (tab bar, title bar, traffic-light area)
//      instead of pixel-sampling — overlay-resistant and IPC-free.
// Reading getComputedStyle(html).getPropertyValue('--sidebar') picks up the active skin
// (Default, Sienna, Sisyphus, Charizard, etc.) so each skin's distinct paint reaches
// the meta tag.
function _syncThemeColorMeta(){
  try{
    const bg=getComputedStyle(document.documentElement).getPropertyValue('--sidebar').trim();
    if(!bg) return;
    const known=document.getElementById('hermes-theme-color');
    if(known){
      known.setAttribute('content',bg);
      known.removeAttribute('media');
    }
    document.querySelectorAll('meta[name="theme-color"]').forEach(meta=>{
      meta.setAttribute('content',bg);
      meta.removeAttribute('media');
    });
  }catch(e){}
}

function _skinKey(skin){
  return (skin&&String(skin.value||skin.name||'').toLowerCase())||'';
}

function _findSkinEntry(key){
  const normalized=String(key||'default').toLowerCase();
  return (_SKINS||[]).find(s=>_skinKey(s)===normalized)||null;
}

function _activeSkinScheme(){
  const key=(document.documentElement.dataset.skin||'default').toLowerCase();
  const skin=_findSkinEntry(key);
  const scheme=skin&&skin._extScheme;
  return scheme==='light'||scheme==='dark'?scheme:'';
}

function _effectiveThemeDark(baseIsDark){
  const skinScheme=_activeSkinScheme();
  if(skinScheme==='dark') return true;
  if(skinScheme==='light') return false;
  return !!baseIsDark;
}

function _setResolvedTheme(isDark){
  _resolvedThemeBaseDark=!!isDark;
  const effectiveDark=_effectiveThemeDark(_resolvedThemeBaseDark);
  document.documentElement.classList.toggle('dark',effectiveDark);
  const link=document.getElementById('prism-theme');
  if(!link){ _syncThemeColorMeta(); return; }
  const want=effectiveDark
    ?'https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism-tomorrow.min.css'
    :'https://cdn.jsdelivr.net/npm/prismjs@1.29.0/themes/prism.min.css';
  // No SRI integrity on theme CSS — jsdelivr edge nodes serve different
  // digests for the same pinned version, causing intermittent blocking (#1100).
  if(link.href!==want){ link.integrity=''; link.href=want; }
  _syncThemeColorMeta();
}

function _applyTheme(name){
  const normalized=_normalizeAppearance(name,'default');
  delete document.documentElement.dataset.theme;
  if(_systemThemeMq&&_onSystemThemeChange){
    _systemThemeMq.removeEventListener('change',_onSystemThemeChange);
    _systemThemeMq=null;
    _onSystemThemeChange=null;
  }
  if(normalized.theme==='system'){
    _systemThemeMq=window.matchMedia('(prefers-color-scheme:dark)');
    _onSystemThemeChange=()=>_setResolvedTheme(_systemThemeMq.matches);
    _setResolvedTheme(_systemThemeMq.matches);
    _systemThemeMq.addEventListener('change',_onSystemThemeChange);
    return;
  }
  _setResolvedTheme(normalized.theme==='dark');
}

function _applySkin(name){
  const key=(name||'default').toLowerCase();
  if(key==='default') delete document.documentElement.dataset.skin;
  else document.documentElement.dataset.skin=key;
  _setResolvedTheme(_resolvedThemeBaseDark);
}

function _pickTheme(name){
  const currentSkin=localStorage.getItem('hermes-skin');
  const appearance=_normalizeAppearance(name,currentSkin);
  localStorage.setItem('hermes-theme',appearance.theme);
  localStorage.setItem('hermes-skin',appearance.skin);
  _applyTheme(appearance.theme);
  _applySkin(appearance.skin);
  _syncThemePicker(appearance.theme);
  _syncSkinPicker(appearance.skin);
  const hidden=$('settingsTheme');
  if(hidden) hidden.value=appearance.theme;
  const skinHidden=$('settingsSkin');
  if(skinHidden) skinHidden.value=appearance.skin;
  if(typeof _scheduleAppearanceAutosave==='function') _scheduleAppearanceAutosave();
}

function _pickSkin(name){
  const appearance=_normalizeAppearance(localStorage.getItem('hermes-theme'),name);
  localStorage.setItem('hermes-theme',appearance.theme);
  localStorage.setItem('hermes-skin',appearance.skin);
  _applyTheme(appearance.theme);
  _applySkin(appearance.skin);
  _syncThemePicker(appearance.theme);
  _syncSkinPicker(appearance.skin);
  const hidden=$('settingsSkin');
  if(hidden) hidden.value=appearance.skin;
  const themeHidden=$('settingsTheme');
  if(themeHidden) themeHidden.value=appearance.theme;
  if(typeof _scheduleAppearanceAutosave==='function') _scheduleAppearanceAutosave();
}

function _syncThemePicker(active){
  document.querySelectorAll('#themePickerGrid .theme-pick-btn').forEach(btn=>{
    btn.classList.toggle('active',btn.dataset.themeVal===active);
    btn.style.borderColor='';
    btn.style.boxShadow='';
  });
}

function _syncSkinPicker(active){
  document.querySelectorAll('#skinPickerGrid .skin-pick-btn').forEach(btn=>{
    btn.classList.toggle('active',btn.dataset.skinVal===active);
    btn.style.borderColor='';
    btn.style.boxShadow='';
  });
}

function _applyFontSize(size){
  if(size&&size!=='default'){
    document.documentElement.dataset.fontSize=size;
  } else {
    delete document.documentElement.dataset.fontSize;
  }
}

function _pickFontSize(size){
  localStorage.setItem('hermes-font-size',size);
  _applyFontSize(size);
  _syncFontSizePicker(size);
  const hidden=$('settingsFontSize');
  if(hidden) hidden.value=size;
  if(typeof _scheduleAppearanceAutosave==='function') _scheduleAppearanceAutosave();
}

function _syncFontSizePicker(active){
  document.querySelectorAll('#fontSizePickerGrid .font-size-pick-btn').forEach(btn=>{
    btn.classList.toggle('active',btn.dataset.fontSizeVal===(active||'default'));
    btn.style.borderColor='';
    btn.style.boxShadow='';
  });
}

function _buildSkinPicker(activeSkin){
  const grid=$('skinPickerGrid');
  if(!grid) return;
  grid.innerHTML='';
  for(const skin of _SKINS){
    const key=(skin.value||skin.name).toLowerCase();
    const btn=document.createElement('button');
    btn.type='button';
    btn.className='skin-pick-btn';
    btn.dataset.skinVal=key;
    btn.style.cssText='border:1px solid var(--border2);border-radius:8px;padding:8px 4px;text-align:center;cursor:pointer;background:none;transition:all .15s';
    btn.onclick=()=>_pickSkin(key);
    // Build with DOM nodes + textContent so an extension-registered skin's
    // label/name (registerHermesSkin descriptor) can never inject markup into
    // the picker. Swatch colors are already value-sanitized upstream, but set
    // them via element.style.background (not interpolated HTML) as defense in depth.
    const dotRow=document.createElement('div');
    dotRow.style.cssText='display:flex;gap:3px;justify-content:center;margin-bottom:4px';
    for(const c of (skin.colors||[])){
      const dot=document.createElement('span');
      dot.style.cssText='display:inline-block;width:10px;height:10px;border-radius:50%';
      dot.style.background=c;
      dotRow.appendChild(dot);
    }
    const labelEl=document.createElement('span');
    labelEl.style.cssText='font-size:11px;color:var(--text)';
    labelEl.textContent=skin.label||skin.name||'';
    btn.appendChild(dotRow);
    btn.appendChild(labelEl);
    grid.appendChild(btn);
  }
  _syncSkinPicker((activeSkin||'default').toLowerCase());
}

// ── Extension-registered skins (theme-registration capability) ───────────────
// Lets a trusted local extension contribute a custom skin that appears in the
// NATIVE skin picker (rather than bolting on a parallel theme switcher). An
// extension calls window.registerHermesSkin(descriptor); core validates +
// sanitizes it, injects a managed <style> rule for its CSS-variable tokens,
// appends it to _SKINS so the picker renders it, and re-applies the persisted
// selection if it was waiting on this (late-registered) skin.
//
// Security: token values are written into CSS, so every value is sanitized
// against a strict allowlist HERE, once, so all theme extensions inherit the
// guard safe-by-construction. Reserved core skin keys cannot be overwritten.
const _EXT_SKIN_STYLE_ID='hermesExtensionSkinStyles';
const _EXT_SKIN_KEYS=new Set();                 // keys we registered (for idempotent re-register)
const _RESERVED_SKIN_KEYS=new Set((_SKINS||[]).map(s=>(s.value||s.name).toLowerCase()));
// CSS custom-property names a skin is allowed to set. Mirrors the documented
// design-token contract; anything outside this set is dropped.
const _ALLOWED_SKIN_TOKENS=new Set([
  '--bg','--surface','--surface2','--surface-subtle','--text','--text2','--muted',
  '--accent','--accent2','--accent3','--accent-contrast','--accent-hover',
  '--accent-text','--accent-bg','--accent-bg-strong','--accent-rgb',
  '--border','--border2','--hover-bg','--code-bg','--code-text',
  '--sidebar','--sidebar-text','--user-bubble','--assistant-bubble',
  '--success','--warning','--danger','--info','--link'
]);
// Accept only safe color / simple numeric-with-unit values, OR a bare RGB triple
// (e.g. "0, 0, 0" for --accent-rgb, consumed inside rgba(...)). Rejects anything
// with url(), expression(), semicolons, braces, or other CSS-injection vectors.
const _SAFE_SKIN_VALUE_RE=/^(#(?:[0-9a-fA-F]{3,8})|rg(?:b|ba)\(\s*[0-9.,%\s/]+\)|hsl(?:a)?\(\s*[0-9.,%\s/deg]+\)|[0-9]{1,3}\s*,\s*[0-9]{1,3}\s*,\s*[0-9]{1,3}|[a-zA-Z]{3,20}|[0-9.]+(?:px|em|rem|%)?)$/;

function _sanitizeSkinScheme(scheme){
  const value=String(scheme||'').trim().toLowerCase();
  return value==='light'||value==='dark'?value:'';
}

function _sanitizeSkinTokens(tokens){
  const out={};
  if(!tokens||typeof tokens!=='object') return out;
  for(const rawKey of Object.keys(tokens)){
    const key=String(rawKey).trim();
    if(!_ALLOWED_SKIN_TOKENS.has(key)) continue;          // unknown token → drop
    const val=String(tokens[rawKey]).trim();
    if(val.length>64) continue;                            // absurd length → drop
    if(!_SAFE_SKIN_VALUE_RE.test(val)) continue;          // unsafe value → drop
    out[key]=val;
  }
  return out;
}

function _renderExtensionSkinStyles(){
  let styleEl=document.getElementById(_EXT_SKIN_STYLE_ID);
  if(!styleEl){
    styleEl=document.createElement('style');
    styleEl.id=_EXT_SKIN_STYLE_ID;
    document.head.appendChild(styleEl);
  }
  const blocks=[];
  for(const skin of _SKINS){
    if(!skin||!skin._extToken) continue;                  // only ext-registered skins
    const key=(skin.value||skin.name).toLowerCase();
    const decls=Object.keys(skin._extToken).map(k=>`${k}:${skin._extToken[k]}`).join(';');
    if(decls) blocks.push(`:root[data-skin="${key}"]{${decls}}`);
  }
  styleEl.textContent=blocks.join('\n');
}

// Public API for extensions. Returns true on success, false if rejected.
function registerHermesSkin(descriptor){
  try{
    if(!descriptor||typeof descriptor!=='object') return false;
    const name=String(descriptor.name||'').trim();
    if(!name) return false;
    const rawVal=String(descriptor.value||name).trim().toLowerCase();
    // key must be a simple slug (safe as a data-skin attr + CSS attr selector)
    const key=rawVal.replace(/[^a-z0-9_-]/g,'');
    if(!key) return false;
    if(_RESERVED_SKIN_KEYS.has(key)) return false;        // never shadow a core skin
    const tokens=_sanitizeSkinTokens(descriptor.tokens);
    if(Object.keys(tokens).length===0) return false;      // nothing valid to apply
    const scheme=_sanitizeSkinScheme(descriptor.scheme);
    // 3 swatch colors for the picker (sanitized); fall back to accent/bg/text.
    let colors=Array.isArray(descriptor.colors)?descriptor.colors.slice(0,3):[];
    colors=colors.map(c=>String(c).trim()).filter(c=>_SAFE_SKIN_VALUE_RE.test(c));
    while(colors.length<3) colors.push(tokens['--accent']||tokens['--bg']||tokens['--text']||'#888');
    const label=String(descriptor.label||name).slice(0,40);
    const entry={name:name.slice(0,40),value:key,label,colors,_extToken:tokens,_extScheme:scheme,_extension:true};

    const existingIdx=_SKINS.findIndex(s=>(s.value||s.name).toLowerCase()===key);
    if(existingIdx>=0&&_EXT_SKIN_KEYS.has(key)){
      _SKINS[existingIdx]=entry;                           // idempotent update
    }else if(existingIdx>=0){
      return false;                                        // collides w/ a non-ext skin
    }else{
      _SKINS.push(entry);
    }
    _EXT_SKIN_KEYS.add(key);
    _VALID_SKINS.add(key);
    _renderExtensionSkinStyles();
    // Refresh the picker if it's already built.
    if(document.getElementById('skinPickerGrid')){
      _buildSkinPicker((localStorage.getItem('hermes-skin')||'default').toLowerCase());
    }
    // If the user had previously selected this (now-available) skin, apply it.
    if((localStorage.getItem('hermes-skin')||'').toLowerCase()===key){
      _applySkin(key);
    }
    return true;
  }catch(_){ return false; }
}
if(typeof window!=='undefined') window.registerHermesSkin=registerHermesSkin;

function applyBotName(){
  // The saved assistant name applies to the default profile only.
  // Non-default profiles use their own profile names.
  const name=assistantDisplayName();
  if(!S.session) document.title=name;
  const sidebarH1=document.querySelector('.sidebar-header h1');
  if(sidebarH1) sidebarH1.textContent=name;
  const logo=document.querySelector('.sidebar-header .logo');
  if(logo) logo.textContent=name.charAt(0).toUpperCase();
  const topbarTitle=$('topbarTitle');
  if(topbarTitle && (!S.session)) topbarTitle.textContent=name;
  const msg=$('msg');
  if(msg) msg.placeholder='Message '+name+'\u2026';
  if(typeof _applyBusyComposerPlaceholder==='function') _applyBusyComposerPlaceholder();
}

const _COMPOSER_CONTROL_TOGGLE_DEFS=[
  {key:'hide_composer_attach',label:'Attach',labelKey:'composer_control_attach',selectors:['#btnAttach'],orderSelector:'#btnAttach',orderGroup:'left'},
  {key:'hide_composer_saved_prompts',label:'Saved prompts',labelKey:'composer_control_saved_prompts',selectors:['#btnSavedPrompts'],orderSelector:'#btnSavedPrompts',orderGroup:'left'},
  {key:'hide_composer_mic',label:'Mic',labelKey:'composer_control_mic',selectors:['#btnMic'],orderSelector:'#btnMic',orderGroup:'left'},
  {key:'hide_composer_profile',label:'Profile',labelKey:'composer_control_profile',selectors:['#profileChipWrap'],orderSelector:'#profileChipWrap',orderGroup:'left'},
  {key:'hide_composer_workspace',label:'Workspace',labelKey:'composer_control_workspace',selectors:['.composer-ws-wrap','#composerMobileWorkspaceAction'],orderSelector:'.composer-ws-wrap',orderGroup:'left'},
  {key:'hide_composer_model',label:'Model',labelKey:'composer_control_model',selectors:['.composer-model-wrap','#composerMobileModelAction'],orderSelector:'.composer-model-wrap',orderGroup:'left'},
  {key:'hide_composer_reasoning',label:'Reasoning',labelKey:'composer_control_reasoning',selectors:['#composerReasoningWrap','#composerMobileReasoningAction'],orderSelector:'#composerReasoningWrap',orderGroup:'left'},
  {key:'hide_composer_context',label:'Context',labelKey:'composer_control_context',selectors:['#ctxIndicatorWrap','#composerMobileContextAction'],orderSelector:'#ctxIndicatorWrap',orderGroup:'right'},
];
window._COMPOSER_CONTROL_TOGGLE_DEFS=_COMPOSER_CONTROL_TOGGLE_DEFS;

const _COMPOSER_SITUATIONAL_CONTROL_TOGGLE_DEFS=[
  {key:'hide_composer_voice_mode',label:'Voice mode',labelKey:'composer_control_voice_mode',selectors:['#btnVoiceMode'],orderSelector:'#btnVoiceMode',orderGroup:'left'},
  {key:'hide_composer_yolo',label:'YOLO',labelKey:'composer_control_yolo',selectors:['#yoloPill'],orderSelector:'#yoloPill',orderGroup:'left'},
  {key:'hide_composer_bg_badge',label:'Background badge',labelKey:'composer_control_bg_badge',selectors:['#bgBadge'],orderSelector:'#bgBadge',orderGroup:'right'},
  {key:'hide_composer_mobile_config',label:'Mobile config',labelKey:'composer_control_mobile_config',selectors:['#composerMobileConfigBtn'],orderSelector:'#composerMobileConfigBtn',orderGroup:'left'},
  {key:'hide_composer_quota_chip',label:'Quota chip',labelKey:'composer_control_quota_chip',selectors:['#providerQuotaChip','#composerMobileQuotaAction'],orderSelector:'#providerQuotaChip',orderGroup:'left'},
  {key:'hide_composer_toolsets',label:'Toolsets',labelKey:'composer_control_toolsets',selectors:['#composerToolsetsWrap'],orderSelector:'#composerToolsetsWrap',orderGroup:'left'},
  {key:'hide_composer_status',label:'Status',labelKey:'composer_control_status',selectors:['#composerStatus'],orderSelector:'#composerStatus',orderGroup:'right'},
];
window._COMPOSER_SITUATIONAL_CONTROL_TOGGLE_DEFS=_COMPOSER_SITUATIONAL_CONTROL_TOGGLE_DEFS;

function _allComposerControlToggleDefs(){
  return _COMPOSER_CONTROL_TOGGLE_DEFS.concat(_COMPOSER_SITUATIONAL_CONTROL_TOGGLE_DEFS);
}

function _sanitizeComposerControlOrder(order){
  if(!Array.isArray(order)) return [];
  const allowed=new Set(_allComposerControlToggleDefs().map(def=>def.key));
  const out=[];
  order.forEach(key=>{
    if(typeof key!=='string') return;
    key=key.trim();
    if(!key||!allowed.has(key)||out.includes(key)) return;
    out.push(key);
  });
  return out;
}
window._sanitizeComposerControlOrder=_sanitizeComposerControlOrder;

function _orderedComposerControlDefs(order){
  const defs=_allComposerControlToggleDefs();
  const byKey=new Map(defs.map(def=>[def.key,def]));
  const out=[];
  _sanitizeComposerControlOrder(Array.isArray(order)?order:window._composerControlOrder).forEach(key=>{
    if(byKey.has(key)) out.push(byKey.get(key));
  });
  defs.forEach(def=>{if(!out.includes(def)) out.push(def);});
  return out;
}
window._orderedComposerControlDefs=_orderedComposerControlDefs;

function _applyComposerControlOrder(order){
  window._composerControlOrder=_sanitizeComposerControlOrder(order);
  const grouped=new Map();
  _orderedComposerControlDefs(window._composerControlOrder).forEach(def=>{
    const node=document.querySelector(def.orderSelector||def.selectors&&def.selectors[0]);
    if(!node||!node.parentNode) return;
    const parent=node.parentNode;
    if(!grouped.has(parent)) grouped.set(parent,[]);
    grouped.get(parent).push(node);
  });
  grouped.forEach((nodes,parent)=>{
    if(!nodes.length) return;
    const marker=document.createComment('composer-control-order');
    parent.insertBefore(marker,nodes[0]);
    let ref=marker;
    nodes.forEach(node=>{
      parent.insertBefore(node,ref.nextSibling);
      ref=node;
    });
    marker.remove();
  });
  if(typeof _fitComposerFooter==='function') _fitComposerFooter();
}
window._applyComposerControlOrder=_applyComposerControlOrder;

function _composerControlVisibilityFromSettings(settings){
  const next={};
  for(const def of _allComposerControlToggleDefs()){
    next[def.key]=!!(settings&&settings[def.key]);
  }
  return next;
}
window._composerControlVisibilityFromSettings=_composerControlVisibilityFromSettings;

function _setComposerControlHidden(el, hidden){
  if(!el) return;
  el.classList.toggle('composer-control-hidden', !!hidden);
  if(hidden) el.setAttribute('aria-hidden','true');
  else el.removeAttribute('aria-hidden');
}

function _applyComposerFooterVisibilitySettings(){
  const hidden=window._composerControlVisibility||{};
  for(const def of _allComposerControlToggleDefs()){
    const isHidden=!!hidden[def.key];
    for(const selector of def.selectors){
      document.querySelectorAll(selector).forEach(el=>_setComposerControlHidden(el,isHidden));
    }
  }

  const hideMic=!!hidden.hide_composer_mic;
  if(hideMic&&window._micActive&&typeof window._stopMic==='function'){
    try{window._stopMic();}catch(_){ }
  }

  const hideSavedPrompts=!!hidden.hide_composer_saved_prompts;
  const savedBtn=$('btnSavedPrompts');
  const savedPopup=$('savedPromptsPopup');
  if(hideSavedPrompts&&savedPopup){
    savedPopup.style.display='none';
    if(savedBtn) savedBtn.setAttribute('aria-expanded','false');
  }

  if(hidden.hide_composer_workspace&&typeof closeWsDropdown==='function') closeWsDropdown();
  if(hidden.hide_composer_profile&&typeof closeProfileDropdown==='function') closeProfileDropdown();
  if(hidden.hide_composer_model&&typeof closeModelDropdown==='function') closeModelDropdown();
  if(hidden.hide_composer_reasoning&&typeof closeReasoningDropdown==='function') closeReasoningDropdown();
  if(hidden.hide_composer_toolsets&&typeof closeToolsetsDropdown==='function') closeToolsetsDropdown();
  if(hidden.hide_composer_mobile_config&&typeof closeMobileComposerConfig==='function') closeMobileComposerConfig();

  // Hide the divider when all left-group buttons before it are hidden
  // Stops a lone vertical separator from appearing when attach/saved-prompts/mic/voice are all hidden.
  const _divider=document.querySelector('.composer-divider');
  if(_divider){
    const _leftBtnSelectors=['#btnAttach','#btnSavedPrompts','#btnMic','#btnVoiceMode'];
    const _allLeftHidden=_leftBtnSelectors.every(sel=>{
      const el=document.querySelector(sel);
      return !el||el.classList.contains('composer-control-hidden')||el.style.display==='none';
    });
    // Use classList.toggle directly instead of _setComposerControlHidden
    // so we don't strip the intentional aria-hidden="true" on the decorative divider
    // when buttons are visible (Greptile feedback).
    _divider.classList.toggle('composer-control-hidden',_allLeftHidden);
  }
}
window._applyComposerFooterVisibilitySettings=_applyComposerFooterVisibilitySettings;

function _applyTitlebarProfileVisibility(){
  const btn=$('titlebarProfileBtn');
  if(!btn) return;
  btn.style.display=window._showTitlebarProfile?'':'none';
}
window._applyTitlebarProfileVisibility=_applyTitlebarProfileVisibility;

function _mirrorSpeechSettingsFromServer(s){
  if(!s||typeof s!=='object') return;
  const persistedSpeechKeys = new Set(
    Array.isArray(s.persisted_speech_keys) ? s.persisted_speech_keys : []
  );
  const hasServerValue=(settingKey)=>persistedSpeechKeys.has(settingKey);
  const defaults={
    tts_enabled:false,
    tts_auto_read:false,
    tts_engine:'browser',
    tts_voice:'',
    tts_rate:1,
    tts_pitch:1,
    voice_mode_button:false,
    voice_continuous:false,
    voice_silence_ms:1800,
    raw_audio_mode:false,
  };
  const cachedValue=(storageKey)=>{
    try{return localStorage.getItem(storageKey);}catch(_){return null;}
  };
  const boolValue=(value)=>value===true||value==='true';
  const resolveBool=(settingKey,storageKey)=>{
    const server=hasServerValue(settingKey)?s[settingKey]:defaults[settingKey];
    const cached=cachedValue(storageKey);
    if(!hasServerValue(settingKey)&&cached!==null){
      return boolValue(cached);
    }
    return boolValue(server);
  };
  const resolveScalar=(settingKey,storageKey)=>{
    const server=hasServerValue(settingKey)?s[settingKey]:defaults[settingKey];
    const cached=cachedValue(storageKey);
    if(!hasServerValue(settingKey)&&cached!==null){
      return cached;
    }
    return server;
  };
  const boolKeys=[
    ['tts_enabled','hermes-tts-enabled'],
    ['tts_auto_read','hermes-tts-auto-read'],
    ['voice_mode_button','hermes-voice-mode-button'],
    ['voice_continuous','hermes-voice-continuous'],
  ];
  boolKeys.forEach(([settingKey,storageKey])=>{
    if(hasServerValue(settingKey)){
      try{localStorage.setItem(storageKey,resolveBool(settingKey,storageKey)?'true':'false');}catch(_){}
    }
  });
  [
    ['tts_engine','hermes-tts-engine'],
    ['tts_voice','hermes-tts-voice'],
    ['tts_rate','hermes-tts-rate'],
    ['tts_pitch','hermes-tts-pitch'],
    ['voice_silence_ms','hermes-voice-silence-ms'],
  ].forEach(([settingKey,storageKey])=>{
    if(hasServerValue(settingKey)){
      try{localStorage.setItem(storageKey,String(resolveScalar(settingKey,storageKey)));}catch(_){}
    }
  });
  if(hasServerValue('raw_audio_mode')){
    const rawAudioMode=resolveBool('raw_audio_mode','hermes-raw-audio-mode');
    if(typeof window._applyRawAudioModePreference==='function'){
      window._applyRawAudioModePreference(rawAudioMode);
    }else{
      try{localStorage.setItem('hermes-raw-audio-mode',rawAudioMode?'true':'false');}catch(_){}
    }
  }
}
window._mirrorSpeechSettingsFromServer=_mirrorSpeechSettingsFromServer;

(async()=>{
  // Load send key preference
  let _bootSettings={};
  const prefillIntent=(typeof _composerPrefillIntentFromLocation==='function')?_composerPrefillIntentFromLocation():null;
  try{
    const s=await api('/api/settings');
    _bootSettings=s;
    if(typeof checkWebUIVersionSkew==='function'){try{checkWebUIVersionSkew(s);}catch(_){}}
    window._sendKey=s.send_key||'enter';
    // Persist default workspace so the blank new-chat page can show it
    // and workspace actions (New file/folder) work before the first session (#804).
    if(s.default_workspace) S._profileDefaultWorkspace=s.default_workspace;
    window._showTokenUsage=!!s.show_token_usage;
    window._showQuotaChip=s.show_quota_chip===true;
    window._showConversationOutline=s.show_conversation_outline===true;
    document.documentElement.dataset.conversationOutline=window._showConversationOutline?'enabled':'disabled';
    if(typeof applyConversationOutlinePreference==='function') applyConversationOutlinePreference();
    window._hideEmptyStateSuggestions=s.hide_empty_state_suggestions===true;
    applyEmptyStateSuggestionPref();
    window._hideEmptyStatePanel=s.hide_empty_state_panel===true;
    applyEmptyStatePanelPref();
    // #4343: transcript virtualization is EXPERIMENTAL/opt-IN (default OFF).
    // #4346 Phase B (footer-jitter suppression during virtual-scroll
    // measurement re-renders) resolved the scroll-up flicker root cause,
    // but virtualization remains opt-in until battle-tested further.
    // Users can explicitly enable it via Settings → virtualize_transcript.
    window._virtualizeTranscript=s.virtualize_transcript===true;
    window._showTps=!!s.show_tps;
    window._fadeTextEffect=!!s.fade_text_effect;
    window._showCliSessions=s.show_cli_sessions!==false;
    window._showPreviousMessagingSessions=!!s.show_previous_messaging_sessions;
    window._soundEnabled=!!s.sound_enabled;
    window._notificationsEnabled=!!s.notifications_enabled;
    window._whatsNewSummaryEnabled=!!s.whats_new_summary_enabled;
    window._showThinking=s.show_thinking!==false;
    window._simplifiedToolCalling=true;
    window._chatActivityDisplayMode=s.chat_activity_display_mode==='transparent_stream'||s.chat_activity_display_mode==='hide_all_activity'
      ? s.chat_activity_display_mode
      : 'compact_worklog';
    window._transparentStream=window._chatActivityDisplayMode==='transparent_stream';
    window._transparentEventTimestamps=s.transparent_stream_event_timestamps!==false;
    window._terminalAutoExpandOnOutput=!!s.terminal_auto_expand_on_output;
    window._worklogDetailsExpandedByDefault=!!(
      Object.prototype.hasOwnProperty.call(s,'worklog_details_expanded_default')
        ? s.worklog_details_expanded_default
        : s.activity_feed_expanded_default
    );
    window._workspaceTodosTab=!!s.workspace_todos_tab;
    if(typeof _applyWorkspaceTodosTabVisibility==='function') _applyWorkspaceTodosTabVisibility();
    window._sidebarDensity=(s.sidebar_density==='detailed'?'detailed':'compact');
    window._pinnedSessionsLimit=parseInt(s.pinned_sessions_limit||3,10)||3;
    window._inflightStateLimits={
      maxSessions:parseInt(s.inflight_state_max_sessions||8,10)||8,
      messages:parseInt(s.inflight_state_max_messages||24,10)||24,
      toolCalls:parseInt(s.inflight_state_max_tool_calls||48,10)||48,
      stringChars:parseInt(s.inflight_state_max_string_chars||60000,10)||60000,
      jsonChars:parseInt(s.inflight_state_max_json_chars||1500000,10)||1500000,
    };
    // #5162 rename + steer default, layered on the #5170 localStorage mirror:
    // resolve the mode (new key, legacy busy_input_mode fallback, else 'steer'
    // via _normalizeDefaultMessageMode) and persist it so the very first send
    // after a reload honors the saved choice.
    window._defaultMessageMode=_persistDefaultMessageMode(s.default_message_mode||s.busy_input_mode);
    window._showBusyPlaceholderHint=!!s.show_busy_placeholder_hint;
    window._newChatOnWorkspaceSwitch=!!s.new_chat_on_workspace_switch;  // #5473 opt-in
    window._sessionEndlessScrollEnabled=!!s.session_endless_scroll;
    // #6819: persist the resolved auto-follow value into the global mirror.
    // The mirror is NOT profile-keyed (the backend setting is one global
    // settings.json), so it can be written synchronously here — no deferred
    // write needed.
    window._autoScrollFollow=_persistAutoScrollFollow(s.auto_scroll_follow!==false);
    window._largeTextPasteAsAttachment=s.large_text_paste_as_attachment!==false;
    window._projectQuickCreate=!!s.project_quick_create_buttons;
    window._composerControlVisibility=_composerControlVisibilityFromSettings(s);
    window._composerControlOrder=_sanitizeComposerControlOrder(s.composer_control_order);
    _applyComposerControlOrder(window._composerControlOrder);
    window._showTitlebarProfile=!!s.show_titlebar_profile;
    _applyTitlebarProfileVisibility();
    window._botName=s.bot_name||'Hermes';
    if(s.default_model_provider) window._activeProvider=s.default_model_provider;
    if(s.default_model){
      window._defaultModel=s.default_model;
      const sel=$('modelSelect');
      if(sel&&typeof _applyModelToDropdown==='function'){
        // Fresh page boot must prefer the profile/server default over stale
        // browser-persisted model state. A restored session can still apply its
        // own persisted model later through loadSession(). Preserve the browser
        // keys for legacy/no-default fallback paths instead of deleting them.
        const existingDefaultOpt=Array.from(sel.options).find(o=>o.value===s.default_model);
        if(existingDefaultOpt&&window._activeProvider&&!existingDefaultOpt.dataset.provider){
          existingDefaultOpt.dataset.provider=window._activeProvider;
        }
        if(!existingDefaultOpt){
          const opt=document.createElement('option');
          opt.value=s.default_model;
          opt.textContent=typeof getModelLabel==='function'?getModelLabel(s.default_model):s.default_model;
          opt.dataset.custom='1';
          opt.dataset.provider=window._activeProvider||'';
          sel.querySelectorAll('option[data-custom]').forEach(o=>o.remove());
          sel.appendChild(opt);
        }
        _applyModelToDropdown(s.default_model,sel,window._activeProvider||null);
      }
    }
    window._sessionJumpButtonsEnabled=!!s.session_jump_buttons;
    window._renderUserMarkdown=!!s.render_user_markdown;
    // JSON/YAML structured code-block default view (#484): auto | on | off,
    // plus the 'auto'-mode line threshold (sanitized int 1..1000, fallback 10).
    window._structuredCodeDefaultView=['on','off','auto'].includes(s.structured_code_default_view)?s.structured_code_default_view:'auto';
    const _sctLines=parseInt(s.structured_code_auto_tree_lines,10);
    window._structuredCodeAutoTreeLines=(Number.isFinite(_sctLines)&&_sctLines>=1&&_sctLines<=1000)?_sctLines:10;
    // Reconcile appearance: prefer localStorage (what the user last saw) over
    // the server.  If they diverge (e.g. a previous autosave POST failed),
    // push the localStorage values back to the server so settings.json stays
    // in sync without ever clobbering the user's chosen theme/skin.
    //
    // Caveat: the pre-paint inline script in index.html normalises empty
    // localStorage into 'dark'/'default' BEFORE this code runs, so a truly
    // empty (new-browser) state is indistinguishable from a user who chose
    // the defaults.  To avoid blocking server→client sync on first visit we
    // only let localStorage override the server when it carries an explicit
    // user-selectable theme value or a NON-DEFAULT skin.  That keeps the
    // server in charge for empty first-visit state while preserving explicit
    // light/dark/system choices after a failed autosave.
    const srvAppearance=_normalizeAppearance(s.theme,s.skin);
    const lsTheme=(localStorage.getItem('hermes-theme')||'').trim().toLowerCase();
    const lsSkin=(localStorage.getItem('hermes-skin')||'').trim().toLowerCase();
    const lsAppearance=_normalizeAppearance(lsTheme||null,lsSkin||null);
    // An unknown non-default persisted skin is most likely an extension-provided
    // skin (registerHermesSkin) whose extension script hasn't registered it yet
    // at this point in boot. Preserve it verbatim instead of normalizing it away
    // to 'default' — the extension's registerHermesSkin() will inject the CSS and
    // re-apply it once it loads. Without this, the boot sync would clobber the
    // saved choice before the extension runs.
    const lsSkinIsPendingExt=!!lsSkin&&lsSkin!=='default'&&!_VALID_SKINS.has(lsSkin)&&!_LEGACY_THEME_MAP[lsSkin];
    const lsHasExplicitSkin=lsSkin&&lsSkin!=='default';
    const lsHasExplicitTheme=lsTheme&&['system','light','dark'].includes(lsTheme);
    const theme=lsHasExplicitTheme?lsAppearance.theme:srvAppearance.theme;
    const skin=lsHasExplicitSkin?(lsSkinIsPendingExt?lsSkin:lsAppearance.skin):srvAppearance.skin;
    localStorage.setItem('hermes-theme',theme);
    _applyTheme(theme);
    localStorage.setItem('hermes-skin',skin);
    _applySkin(skin);
    // Reconcile: if localStorage and server disagree, push localStorage
    // values to the server so the next refresh won't revert. Skip the push for a
    // still-pending extension skin (don't persist it server-side until it's a
    // confirmed-registered skin — avoids writing a skin the server can't validate).
    if((lsHasExplicitTheme||lsHasExplicitSkin)&&!lsSkinIsPendingExt&&(theme!==srvAppearance.theme||skin!==srvAppearance.skin)){
      try{
        api('/api/settings',{method:'POST',body:JSON.stringify({theme,skin})});
      }catch(_){}
    }
    const fontSize=(s.font_size||localStorage.getItem('hermes-font-size')||'default');
    localStorage.setItem('hermes-font-size',fontSize);
    _applyFontSize(fontSize);
    if(typeof setLocale==='function'){
      // #7622 (round 3): the settings payload's `s.language` is
      // absent (None) for a fresh install, so an explicit non-empty
      // value is the user's genuine saved choice.  The browser
      // navigator hint is now read via the guarded
      // `_detectBrowserLanguageHint()` helper (round-3 finding 2) so
      // a throwing `navigator` accessor in some embedded webviews
      // can no longer abort this branch and reset loaded preferences.
      // The fallback ternary preserves the pre-#7622 boot behaviour
      // when neither helper is in scope (defence in depth).
      const _lang=typeof resolvePreferredLocale==='function'
        ? resolvePreferredLocale(s.language, localStorage.getItem('hermes-lang'), _detectBrowserLanguageHint())
        : (s.language || localStorage.getItem('hermes-lang') || 'en');
      setLocale(_lang);
      if(typeof applyLocaleToDOM==='function')applyLocaleToDOM();
    }
    _mirrorSpeechSettingsFromServer(s);
    // Apply voice-mode visibility BEFORE computing the divider so the
    // .composer-divider (#5451) sees #btnVoiceMode final display even
    // when a server/localStorage sync path flipped the pref between
    // module init and settings-load completion (round-2 SILENT race).
    // Note: must use window._applyVoiceModePref — the bare name is
    // closure-local to the voice-mode IIFE and not visible here.
    if(typeof window._applyVoiceModePref==='function') window._applyVoiceModePref();
    _applyComposerFooterVisibilitySettings();
    // TTS: apply enabled state on boot so buttons show/hide correctly (#499)
    if(typeof _applyTtsEnabled==='function') _applyTtsEnabled(localStorage.getItem('hermes-tts-enabled')==='true');
  }catch(e){
    window._sendKey='enter';
    window._showTokenUsage=false;
    window._showQuotaChip=false;
    window._showConversationOutline=false;
    document.documentElement.dataset.conversationOutline='disabled';
    if(typeof applyConversationOutlinePreference==='function') applyConversationOutlinePreference();
    window._hideEmptyStateSuggestions=false;
    applyEmptyStateSuggestionPref();
    window._hideEmptyStatePanel=false;
    applyEmptyStatePanelPref();
    window._virtualizeTranscript=false;  // settings-load failed: default-OFF (experimental/opt-in) (#4343)
    window._showTps=false;
    window._fadeTextEffect=false;
    window._showCliSessions=true;  // settings-load failed: mirror the True config default (#3988)
    window._soundEnabled=false;
    window._notificationsEnabled=false;
    window._whatsNewSummaryEnabled=false;
    window._showThinking=true;
    window._simplifiedToolCalling=true;
    window._chatActivityDisplayMode='compact_worklog';
    window._transparentStream=false;
    window._transparentEventTimestamps=true;
    window._terminalAutoExpandOnOutput=false;
    window._workspaceTodosTab=false;
    if(typeof _applyWorkspaceTodosTabVisibility==='function') _applyWorkspaceTodosTabVisibility();
    window._sessionJumpButtonsEnabled=false;
    window._structuredCodeDefaultView='auto';
    window._structuredCodeAutoTreeLines=10;
    window._sidebarDensity='compact';
    window._pinnedSessionsLimit=3;
    // Settings load failed: keep the persisted default-message-mode preference
    // (the eager default already read it from the localStorage mirror) instead
    // of clobbering it, so a saved 'steer'/'interrupt'/'queue' still applies
    // when the server is unreachable (#5167). The placeholder-hint has no
    // persisted mirror, so it defaults off on failure.
    window._defaultMessageMode=_readPersistedDefaultMessageMode();
    window._showBusyPlaceholderHint=false;
    window._sessionEndlessScrollEnabled=false;
    // #6819: honor the persisted auto-follow preference on settings-fetch
    // failure instead of hardcoding ON (which silently clobbered an explicit
    // OFF and caused post-turn scroll yanks until the next refresh). The
    // mirror is global (matches the one global settings.json), so it is read
    // synchronously here — no profile resolution or deferral needed.
    window._autoScrollFollow=_readPersistedAutoScrollFollow();
    window._composerControlVisibility=_composerControlVisibilityFromSettings(null);
    window._composerControlOrder=[];
    _applyComposerControlOrder(window._composerControlOrder);
    window._botName='Hermes';
    _bootSettings={check_for_updates:false};
    if(typeof setLocale==='function'){
      const _lang=typeof resolvePreferredLocale==='function'
        ? resolvePreferredLocale(null, localStorage.getItem('hermes-lang'))
        : (localStorage.getItem('hermes-lang') || 'en');
      setLocale(_lang);
      if(typeof applyLocaleToDOM==='function')applyLocaleToDOM();
    }
    // Apply voice-mode visibility BEFORE computing the divider so the
    // .composer-divider (#5451) sees #btnVoiceMode final display even when
    // a server/localStorage sync path flipped the pref between module init
    // and settings-load completion (round-2 SILENT race fix; safe no-op on
    // the failure-fallback path because _applyVoiceModePref is idempotent).
    // Note: must use window._applyVoiceModePref — the bare name is
    // closure-local to the voice-mode IIFE and not visible here.
    if(typeof window._applyVoiceModePref==='function') window._applyVoiceModePref();
    _applyComposerFooterVisibilitySettings();
    if(typeof _applyTtsEnabled==='function') _applyTtsEnabled(localStorage.getItem('hermes-tts-enabled')==='true');
  }
  // Non-blocking update check (fire-and-forget, once per tab session)
  // ?test_updates=1 in URL forces banner display for testing (bypasses sessionStorage guards)
  const _testUpdates=new URLSearchParams(location.search).get('test_updates')==='1';
  if(_testUpdates||(_bootSettings.check_for_updates!==false&&!sessionStorage.getItem('hermes-update-checked')&&!sessionStorage.getItem('hermes-update-dismissed'))){
    const _checkUrl='api/updates/check'+(_testUpdates?'?simulate=1':'');
    api(_checkUrl,{method:_testUpdates?'GET':'POST',body:_testUpdates?undefined:JSON.stringify({force:false}),timeoutMs:300000}).then(d=>{if(!_testUpdates)sessionStorage.setItem('hermes-update-checked','1');if((d.webui&&d.webui.behind>0)||(d.agent&&d.agent.behind>0))_showUpdateBanner(d);}).catch(()=>{});
  }
  const _bootActiveProfileUnauthRedirectBudget=(()=>{
    const markerKey='hermes-webui-active-profile-bootstrap-401';
    let consumed=false;
    const readAttempted=(storage=sessionStorage)=>{
      try{
        const attempted=storage&&storage.getItem?storage.getItem(markerKey)==='1':false;
        if(attempted) consumed=true;
        return attempted;
      }catch(_){
        return false;
      }
    };
    const markAttempted=(storage=sessionStorage)=>{
      consumed=true;
      try{
        if(storage&&storage.setItem) storage.setItem(markerKey,'1');
      }catch(_){}
    };
    const clearAttempted=(storage=sessionStorage)=>{
      try{
        if(storage&&storage.removeItem) storage.removeItem(markerKey);
      }catch(_){}
    };
    const spendOnFallback=(storage=sessionStorage)=>{
      consumed=true;
      clearAttempted(storage);
    };
    const spendOnRedirect=(storage=sessionStorage)=>{
      if(consumed) return false;
      markAttempted(storage);
      return true;
    };
    const redirectToLogin=(nextUrl)=>{
      // #5578: never nest the login URL into its own next= — if already on a
      // login-shaped page, reload 'login' bare (the page keeps its inner next).
      const _p=(window.location.pathname||'').replace(/\/+$/,'');
      if(/(?:^|\/)login$/.test(_p)){window.location.href='login';return;}
      window.location.href='login?next='+encodeURIComponent(nextUrl);
    };
    return {
      readAttempted,
      clearAttempted,
      spendOnFallback,
      spendOnRedirect,
      redirectToLogin,
      isConsumed:()=>consumed,
    };
  })();
  async function _resolveActiveProfileBootstrapState({
    loadActiveProfile = () => api('/api/profile/active', {redirect401: false}),
    getNextUrl = () => window.location.pathname + window.location.search,
    redirectToLogin = (nextUrl) => {
      _bootActiveProfileUnauthRedirectBudget.redirectToLogin(nextUrl);
    },
    markerStorage = sessionStorage,
  } = {}) {
    const alreadyAttempted = _bootActiveProfileUnauthRedirectBudget.readAttempted(markerStorage);
    try {
      const p = await loadActiveProfile();
      if (p && typeof p === 'object' && typeof p.name === 'string') {
        _bootActiveProfileUnauthRedirectBudget.clearAttempted(markerStorage);
        if (p.default_workspace) S._profileDefaultWorkspace = p.default_workspace;
        return {status: 'resolved', profile: p.name || 'default', isDefault: !!p.is_default};
      }
      if (p === undefined && !alreadyAttempted) {
        if (_bootActiveProfileUnauthRedirectBudget.spendOnRedirect(markerStorage)) {
          redirectToLogin(getNextUrl());
        }
        return {status: 'recovery-redirect'};
      }
      if (p === undefined) _bootActiveProfileUnauthRedirectBudget.spendOnFallback(markerStorage);
      else _bootActiveProfileUnauthRedirectBudget.clearAttempted(markerStorage);
      return {status: 'fallback', profile: 'default', isDefault: true};
    } catch (e) {
      _bootActiveProfileUnauthRedirectBudget.clearAttempted(markerStorage);
      if (!alreadyAttempted && e && e.status === 401) {
        if (_bootActiveProfileUnauthRedirectBudget.spendOnRedirect(markerStorage)) {
          redirectToLogin(getNextUrl());
        }
        return {status: 'recovery-redirect'};
      }
      if (e && e.status === 401) _bootActiveProfileUnauthRedirectBudget.spendOnFallback(markerStorage);
      return {status: 'fallback', profile: 'default', isDefault: true};
    }
  }

  // Fetch active profile
  const activeProfileState = await _resolveActiveProfileBootstrapState();
  if (activeProfileState.status === 'recovery-redirect') return;
  S.activeProfile = activeProfileState.profile;
  S.activeProfileIsDefault = activeProfileState.isDefault;
  applyBotName();
  // Update profile chip label immediately
  const profileLabel=$('profileChipLabel');
  if(profileLabel) profileLabel.textContent=S.activeProfile||'default';
  const titleLabel=$('titlebarProfileLabel');
  if(titleLabel) titleLabel.textContent=S.activeProfile||'default';
  const profileIntent=(typeof _profileQueryIntentFromLocation==='function')?_profileQueryIntentFromLocation():null;
  const _savedLocalBeforeProfileSwitch=localStorage.getItem('hermes-webui-session');
  const _profileSwitchProfileBefore=S.activeProfile||'default';
  const _profileSwitchIsDefaultBefore=!!S.activeProfileIsDefault;
  let _profileSwitchCompleted=false;
  let _profileSwitchChangedProfile=false;
  if(profileIntent&&profileIntent.hasParam){
    try{
      if(profileIntent.valid){
        if(typeof switchToProfile==='function'){
          _profileSwitchCompleted=await switchToProfile(profileIntent.name)===true;
          if(_profileSwitchCompleted){
            _profileSwitchChangedProfile=(S.activeProfile||'default')!==_profileSwitchProfileBefore||!!S.activeProfileIsDefault!==_profileSwitchIsDefaultBefore;
            if(typeof _consumeProfileQueryParamFromLocation==='function') _consumeProfileQueryParamFromLocation();
          }
        }
      }else{
        console.warn('[boot] ignored invalid profile query', profileIntent.name);
        if(typeof _consumeProfileQueryParamFromLocation==='function') _consumeProfileQueryParamFromLocation();
      }
    }catch(e){
      console.warn('[boot] profile query switch failed', e);
    }
  }
  if(typeof fetchReasoningChip==='function'&&(!_profileSwitchCompleted||!_profileSwitchChangedProfile)) fetchReasoningChip();
  // Fetch available models without blocking session restore. The static HTML
  // options enough for first paint; the dynamic provider list can settle
  // after the saved session is visible.
  const _redirectBootModelDropdownIfUnauth=(res)=>{
    if(!res||res.status!==401) return false;
    window._modelDropdownReady=null;
    if(_bootActiveProfileUnauthRedirectBudget.isConsumed()) return true;
    if(_bootActiveProfileUnauthRedirectBudget.spendOnRedirect(sessionStorage)){
      _bootActiveProfileUnauthRedirectBudget.redirectToLogin(window.location.pathname+window.location.search);
    }
    return true;
  };
  const _hydrateModelDropdown=({redirectIfUnauth=null}={})=>populateModelDropdown({
    preferProfileDefaultOnFreshBoot:true,
    ...(redirectIfUnauth?{redirectIfUnauth}:{}),
  }).then(()=>{
    const sessionModelState=S.session&&S.session.model
      ? {model:S.session.model,model_provider:S.session.model_provider||null}
      : null;
    const savedState=(typeof _readPersistedModelState==='function')
      ? _readPersistedModelState()
      : (localStorage.getItem('hermes-webui-model')?{model:localStorage.getItem('hermes-webui-model'),model_provider:null}:null);
    // Active sessions are authoritative. On fresh boot without a restored
    // session, keep the profile/server default ahead of stale browser model
    // state when a default exists.
    const stateToApply=sessionModelState||(!window._defaultModel?savedState:null);
    const savedModel=stateToApply&&stateToApply.model;
    if(savedModel && $('modelSelect')){
      const applied=(typeof _applyModelToDropdown==='function')
        ? (sessionModelState
          ? _applyModelToDropdown(sessionModelState.model,$('modelSelect'),sessionModelState.model_provider||null)
          : _applyModelToDropdown(savedState.model,$('modelSelect'),savedState.model_provider||null))
        : null;
      if(!applied) $('modelSelect').value=stateToApply.model;
      // If the value didn't take (model not in list), clear the bad pref only
      // for persisted browser preferences. Active sessions remain authoritative.
      if(!applied&&sessionModelState&&typeof _ensureModelOptionInDropdown==='function'){
        _ensureModelOptionInDropdown(sessionModelState.model,$('modelSelect'),sessionModelState.model_provider||null);
      }
      else if(!applied&&!sessionModelState&&$('modelSelect').value!==stateToApply.model){
        if(typeof _clearPersistedModelState==='function') _clearPersistedModelState();
        else {
          localStorage.removeItem('hermes-webui-model');
          localStorage.removeItem('hermes-webui-model-state');
        }
      }
      else if(typeof syncModelChip==='function') syncModelChip();
    }
    if(S.session) syncTopbar();
    else if(typeof syncReasoningChip==='function') syncReasoningChip();
  }).catch(e=>{
    window._modelDropdownReady=null;
    throw e;
  });
  const _startModelDropdown=()=>{
    const ready=window._modelDropdownReady;
    if(ready&&typeof ready.then==='function') return ready;
    const next=_hydrateModelDropdown();
    window._modelDropdownReady=next;
    return next;
  };
  const _startBootModelDropdown=()=>{
    const ready=window._modelDropdownReady;
    if(ready&&typeof ready.then==='function') return ready;
    const next=_hydrateModelDropdown({redirectIfUnauth:_redirectBootModelDropdownIfUnauth});
    window._modelDropdownReady=next;
    return next;
  };
  window._modelDropdownReady=null;
  window._startBootModelDropdown=_startBootModelDropdown;
  window._ensureModelDropdownReady=_startModelDropdown;
  setTimeout(()=>{
    try{Promise.resolve(_startBootModelDropdown()).catch(()=>{});}catch(_){}
  },0);
  // Start independent boot fetches without holding the conversation list behind
  // them. The sidebar can render from /api/sessions while workspace/onboarding
  // metadata settles in parallel.
  const _workspaceListReady=loadWorkspaceList();
  const _onboardingReady=_bootSettings.onboarding_completed?Promise.resolve(false):loadOnboardingWizard();
  // Render the session list before restoring the saved conversation so a stale
  // saved-session/client-side boot error cannot leave the sidebar empty forever.
  await renderSessionList();
  await _workspaceListReady;
  await _onboardingReady;
  _initResizePanels();
  // Workspace panel restore happens AFTER loadSession so we know if
  // the session has a workspace — prevents the snap-open-then-closed flash (#576).
  // Fix #822: clear any browser-restored value before first render. This
  // covers fresh page loads and reloads. The bfcache restore case is handled
  // separately below by a `pageshow` listener — the async IIFE here does NOT
  // re-run when the browser restores the page from bfcache.
  const _srch = document.getElementById('sessionSearch'); if (_srch) _srch.value = '';
  if (typeof syncSessionSearchClear === 'function') syncSessionSearchClear();
  if(typeof refreshProviderQuotaIndicator==='function') refreshProviderQuotaIndicator();
  const urlSession=(typeof _sessionIdFromLocation==='function')?_sessionIdFromLocation():null;
  const pwaLaunchAction=(window.HermesPWA&&typeof window.HermesPWA.launchAction==='function')
    ? window.HermesPWA.launchAction()
    : null;
  if(_shouldStartFreshPwaChat(pwaLaunchAction,urlSession)){
    try{
      await newSession(true);
      // New-chat PWA launches need the empty conversation visible immediately.
      // Boot model hydration can take several seconds when /api/models falls
      // into a cold provider-catalog rebuild; it is already safe to finish in
      // the background because newSession() posted the configured default and
      // rendered the session's authoritative model/provider.
      if(S.session){
        try{Promise.resolve(_startBootModelDropdown()).catch(()=>{});}catch(_){}
      }
      S._bootReady=true;
      syncTopbar();syncWorkspacePanelState();await renderSessionList();await _finalizeComposerPrefillOnBoot(prefillIntent);if(typeof startGatewaySSE==='function')startGatewaySSE();return;
    }catch(e){console.warn('[pwa] new-chat launch action failed', e);}
  }
  const _profileQueryBlocksSavedLocal=_profileQueryBlocksSavedLocalRestore(profileIntent, urlSession);
  if(_profileQueryBlocksSavedLocal&&_profileSwitchCompleted&&_profileSwitchChangedProfile){
    try{
      if(localStorage.getItem('hermes-webui-session')===_savedLocalBeforeProfileSwitch) localStorage.removeItem('hermes-webui-session');
    }catch(_){}
  }
  const savedLocal=localStorage.getItem('hermes-webui-session');
  const saved=urlSession||savedLocal;
  if(saved){
    try{
      const savedSidebarOnlyState=(!urlSession&&savedLocal)
        ? await _savedSessionSidebarOnlyState(savedLocal)
        : null;
      if(savedSidebarOnlyState&&savedSidebarOnlyState.sidebarOnly){
        if(savedSidebarOnlyState.archived){
          try{localStorage.removeItem('hermes-webui-session');}catch(_){}
        }
        S.session=null; S.messages=[]; S.activeStreamId=null; S.busy=false;
        S._bootReady=true;
        syncTopbar();syncWorkspacePanelState();
        $('emptyState').style.display='';
        await renderSessionList();await _finalizeComposerPrefillOnBoot(prefillIntent);if(typeof startGatewaySSE==='function')startGatewaySSE();
        return;
      }
      if(_rootPrefillNeedsFreshComposer(urlSession, savedLocal, prefillIntent)){
        S.session=null; S.messages=[]; S.activeStreamId=null; S.busy=false;
        S._bootReady=true;
        const _ephPanelPref=localStorage.getItem('hermes-webui-workspace-panel-pref')==='open'
          || localStorage.getItem('hermes-webui-workspace-panel')==='open';
        if(_ephPanelPref&&!_isCompactWorkspaceViewport()) _workspacePanelMode='browse';
        await _maybeBindFreshDefaultWorkspaceSession(prefillIntent);
        syncTopbar();syncWorkspacePanelState();
        $('emptyState').style.display='';
        await renderSessionList();await _finalizeComposerPrefillOnBoot(prefillIntent);if(typeof startGatewaySSE==='function')startGatewaySSE();
        return;
      }
      await loadSession(saved, {preserveActiveInput:true});
      // Hard refresh starts from the static HTML model list. Hydrate the live
      // catalog after the saved session is known, then re-apply that session's
      // model before S._bootReady lets syncModelChip reveal the composer label.
      // Otherwise the chip can display the static default (e.g. GPT-5.4 Mini)
      // even though S.session already points at the Codex/current model.
      if(S.session) await _startBootModelDropdown();
      // If the restored session has no messages it is an ephemeral scratch pad —
      // treat the page as a fresh start rather than resuming a blank conversation.
      // loadSession() already ran, so loadDir() has populated the workspace file tree.
      // Do NOT remove the session ID from localStorage — keeping it means every
      // subsequent refresh will also run loadSession() → loadDir() → files stay visible.
      // Removing it here caused the file tree to go blank on the second refresh
      // because the "no saved session" path never calls loadDir (#workspace-files).
      const _restoredInFlight = S.session && (
        S.session.active_stream_id ||
        S.session.pending_user_message
      );
      const _restoredDraft = (S.session && S.session.composer_draft) || {};
      const _restoredDraftText = String(_restoredDraft.text||'').trim();
      const _restoredDraftFiles = Array.isArray(_restoredDraft.files)
        ? _restoredDraft.files.filter(Boolean)
        : [];
      const _restoredHasDraft = !!(_restoredDraftText || _restoredDraftFiles.length);
      if(S.session && (S.session.message_count||0) === 0 && !_restoredInFlight && !_restoredHasDraft){
        S.session=null; S.messages=[];
        S._bootReady=true;
        // Restore panel pref before syncing so the workspace panel stays visible
        // even though there is no active session (#workspace-persist).
        const _ephPanelPref=localStorage.getItem('hermes-webui-workspace-panel-pref')==='open'
          || localStorage.getItem('hermes-webui-workspace-panel')==='open';
        if(_ephPanelPref&&!_isCompactWorkspaceViewport()) _workspacePanelMode='browse';
        await _maybeBindFreshDefaultWorkspaceSession(prefillIntent);
        syncTopbar();syncWorkspacePanelState();
        $('emptyState').style.display='';
        await renderSessionList();await _finalizeComposerPrefillOnBoot(prefillIntent);if(typeof startGatewaySSE==='function')startGatewaySSE();
        return;
      }
      // Restore the panel from localStorage when the session has a workspace.
      // Preference key takes priority over runtime state so that closing
      // the panel via toolbar X doesn't suppress the "keep open" setting.
      const panelPref=localStorage.getItem('hermes-webui-workspace-panel-pref')==='open'
        || localStorage.getItem('hermes-webui-workspace-panel')==='open';
      if(S.session&&S.session.workspace&&panelPref&&!_isCompactWorkspaceViewport()){
        _workspacePanelMode='browse';
      }
      S._bootReady=true;
      syncTopbar();syncWorkspacePanelState();await renderSessionList();if(typeof startGatewaySSE==='function')startGatewaySSE();await checkInflightOnBoot(saved);await _finalizeComposerPrefillOnBoot(prefillIntent);return;}
    catch(e){localStorage.removeItem('hermes-webui-session');}
  }
  // no saved session - show empty state, wait for user to hit +
  S._bootReady=true;
  syncTopbar();
  // Restore panel pref so the workspace panel stays visible on a fresh load if the
  // user had it open during their last session (#workspace-persist).
  const _freshPanelPref=localStorage.getItem('hermes-webui-workspace-panel-pref')==='open'
    || localStorage.getItem('hermes-webui-workspace-panel')==='open';
  if(_freshPanelPref&&!_isCompactWorkspaceViewport()) _workspacePanelMode='browse';
  await _maybeBindFreshDefaultWorkspaceSession(prefillIntent);
  syncWorkspacePanelState();
  $('emptyState').style.display='';
  await renderSessionList();await _finalizeComposerPrefillOnBoot(prefillIntent);
  // Start real-time gateway session sync if setting is enabled
  if(typeof startGatewaySSE==='function') startGatewaySSE();
})().catch(e=>{
  console.error('[hermes] boot failed', e);
  try{S._bootReady=true;}catch(_){}
  try{syncTopbar();}catch(_){}
  try{syncWorkspacePanelState();}catch(_){}
  try{$('emptyState').style.display='';}catch(_){}
  try{if(typeof renderSessionList==='function') void renderSessionList();}catch(_){}
});

// Fix #822 (bfcache path): when the browser restores the page from the
// back-forward cache, the async boot IIFE above does NOT re-run, but the
// DOM — including any stale value in #sessionSearch — IS restored.  A
// prior search string would silently hide all sessions via the filter in
// renderSessionListFromCache().  Clear the field and re-run the full layout
// sync whenever the page is restored from cache (`event.persisted === true`).
// Fix #1045: also re-run topbar/workspace/panel state so the rail and layout
// chrome aren't left in the stale bfcache snapshot.
window.addEventListener('pageshow', async (event) => {
  if (!event.persisted) return;  // fresh loads are handled by the IIFE above
  _syncKeyboardBottomInset();
  const _srch = document.getElementById('sessionSearch');
  if (_srch) _srch.value = '';
  if (typeof syncSessionSearchClear === 'function') syncSessionSearchClear();
  // Close any dropdowns/popovers that were open when the user navigated away.
  // bfcache freezes DOM state, so a dropdown left open remains open on restore.
  if (typeof closeModelDropdown === 'function') try { closeModelDropdown(); } catch (_) {}
  if (typeof closeReasoningDropdown === 'function') try { closeReasoningDropdown(); } catch (_) {}
  if (typeof closeWsDropdown === 'function') try { closeWsDropdown(); } catch (_) {}
  if (typeof closeProfileDropdown === 'function') try { closeProfileDropdown(); } catch (_) {}
  // BFCache restores the frozen DOM without rerunning boot. Refresh the active
  // session through the normal load path so in-flight sessions with
  // active_stream_id / pending_user_message can reattach like a reload restore.
  if (S.session && S.session.session_id && typeof loadSession === 'function') {
    try {
      await loadSession(S.session.session_id);
      if (S.session && S.session.session_id && typeof checkInflightOnBoot === 'function') {
        try { await checkInflightOnBoot(S.session.session_id); } catch (_) {}
      }
    } catch (_) {}
  }
  // Re-synchronise layout chrome that the boot IIFE sets up but bfcache
  // doesn't re-run. Each call is guarded so missing helpers degrade silently.
  if (typeof syncTopbar === 'function') try { syncTopbar(); } catch (_) {}
  if (typeof syncWorkspacePanelState === 'function') try { syncWorkspacePanelState(); } catch (_) {}
  if (typeof renderSessionListFromCache === 'function') {
    try { renderSessionListFromCache(); } catch (_) {}
  }
  // Restart the gateway SSE watcher — the persisted connection is dead after bfcache
  if (typeof startGatewaySSE === 'function') try { startGatewaySSE(); } catch (_) {}
  // Re-sync sidebar collapse state from localStorage. bfcache restored the
  // frozen DOM but another tab may have toggled the sidebar in the meantime.
  if (typeof _isSidebarCollapsed === 'function' && typeof toggleSidebar === 'function') {
    try {
      const _want = localStorage.getItem('hermes-webui-sidebar-collapsed') === '1';
      const _have = _isSidebarCollapsed();
      if (_want !== _have) toggleSidebar(_want);
      if (typeof _syncSidebarAria === 'function') _syncSidebarAria();
    } catch (_) {}
  }
});

async function shutdownServer() {
  const ok = await showConfirmDialog({
    title: (typeof t === 'function' ? t('settings_shutdown_confirm_title') : 'Stop Hermes WebUI'),
    message: (typeof t === 'function' ? t('settings_shutdown_confirm_message') : 'Stop the Hermes WebUI server?'),
    confirmLabel: (typeof t === 'function' ? t('settings_shutdown_confirm_btn') : 'Stop'),
    danger: true,
  });
  if (!ok) return;
  localStorage.setItem('hermes-webui-server-stopped', '1');
  try { var bc = new BroadcastChannel('hermes-webui-shutdown'); bc.postMessage('stop'); bc.close(); } catch(_) {}
  _showServerStopped();
  try { await api('/api/shutdown', { method: 'POST' }); } catch (_) {}
}

function _showServerStopped() {
  var stoppedMsg = (typeof t === 'function' ? t('settings_shutdown_stopped_message') : 'Server stopped. You can close this tab.');
  document.body.innerHTML = '<div style="display:flex;align-items:center;justify-content:center;height:100vh;color:var(--muted);font-family:var(--font-ui);font-size:14px"><p>' + stoppedMsg + '</p></div>';
}