Keep chat responsive under heavy load (lean hidden panels)

What it is

What it does

When you have a lot of sessions open at once, Omniscio keeps many of their chat panels alive in the background so switching between them is instant. The cost of that convenience: every time any running session sends a new chunk of output (which happens many times a second), each of those background panels used to do a little bit of bookkeeping work — checking whether anything it cares about had changed. With 40+ sessions open, that adds up to hundreds of tiny operations many times a second, which can bog the app down and, in particular, make the chat scroll land in the wrong place — the scroll never gets a free moment to settle where it should.

Lean hidden panels stops the panels you can't see from doing that work. A hidden, non-active session is rendered as a tiny placeholder that reacts to nothing — it just sits there until you click it. The result: the per-update cost stops growing with how many sessions you have open, so scrolling stays smooth and the chat lands in the right place no matter how many sessions are running.

This is a performance setting, not a workflow change. What you see and how switching feels are identical; the only difference is that hidden sessions stop quietly reacting to each other.

It is on by default (opt-out). It is a fully reversible layer: turn the setting off (or use the kill switch) and Omniscio behaves exactly as it did before — every hidden panel is mounted in full again, the off path is byte-for-byte unchanged.

Where to find it

Settings → Performance, as the toggle for lean hidden panels. It is on by default, and its effect shows up as steadier scrolling once you have a lot of sessions open.

How it behaves

Turning it off

It is already on — there is nothing to enable. To go back to mounting every hidden panel in full: Settings → Performance → "Keep chat responsive under heavy load" and turn it off.

The toggle's own description reads: "When you have many sessions open at once, Omniscio stops the ones you can't see from doing background work every time another session sends a message. This keeps scrolling smooth and the chat landing in the right place no matter how many sessions are running. On by default; turn off to mount every hidden session in full like before."

No restart required — flipping it off immediately mounts hidden panels in full again; flipping it on slims them down from your next update.

When it applies

• The panel is hidden (not the session you're currently looking at).
• It is not pre-warmed for instant switching — i.e. not one of your pinned "Needs You" inbox panels (those stay fully built so switching into them is instant) and not a recently-viewed "frozen" panel.

In short: the session you're looking at, your inbox panels, and recent ones all stay fully built. Everything else in the background goes lean.

When it does NOT apply

• The active (visible) session — always fully built; this never touches what you're looking at.
• Pre-warmed inbox ("Needs You") panels and recently-viewed (frozen) panels — kept fully built so switching into them is still instant. Lean panels and these never overlap. They do pause their background redrawing while off-screen: a fully-built panel you can't see stops repainting its chat as new output arrives and catches up the moment you open it, so a busy background session no longer competes with the one you're actually reading. What you see when you click is unchanged.
• When the feature is off — every panel mounts in full, exactly as before.

What you might notice

Switching back to a plain background running session you'd visited can take a hair longer than before — it rebuilds when you click it instead of being kept fully alive in the background. It is work paid once, on the click (not many times a second), and your already-loaded history makes it quick. Your pinned inbox and recently-viewed sessions are unaffected — those stay instant.

How it relates to the other "responsiveness" features

• The keep-alive pool decides which panels stay mounted in the background.
• Lean hidden panels (this page) decides how cheap those hidden panels are — the ones that aren't pre-warmed render as a do-nothing placeholder.
• Pre-render inbox sessions and frozen-panel retention are the opposite end: they deliberately keep a small, bounded set of panels fully built so switching into those is instant. Lean panels never touch that set.

For agents

The kill switch

There are two independent off-switches, and the kill switch always wins:

1. The Settings toggle above (leanHiddenPanels, default on).
2. An environment kill switch: launch Omniscio with AMC_DISABLE_LEAN_HIDDEN_PANELS=1 and the feature is forced off even if the setting is on — the field escape hatch. A missing or malformed switch is treated as "not killed," so the setting alone governs in the normal case.

Where it lives in code

• src/renderer/src/features/sessions/SessionPanel.tsx — SessionPanel is memo(SessionPanelImpl), where SessionPanelImpl is a thin wrapper that renders a subscription-free SessionPanelShell (lean + hidden) or the full SessionPanelHeavy (the former body, moved verbatim).
• src/renderer/src/features/sessions/session-panel-heavy-gate.ts — computeShouldRenderHeavy(...), the single shared heavy-vs-shell predicate.
• src/renderer/src/lib/lean-hidden-panels-flag.ts — isLeanHiddenPanelsEnabled(setting): setting first, then the AMC_DISABLE_LEAN_HIDDEN_PANELS kill switch wins.
• src/preload/index.ts — bridges the kill switch to the renderer before first paint.

The full engineering contract (test-locked invariants + safe-change checklist) is the "Lean hidden panels" section of .claude/memory/contracts/keep-alive-pool-contract.md.

Related

• frozen-panel-retention.md — keeps recent sessions fully built for instant switch-back.
• inbox-prerender.md — pre-builds your inbox panels for instant switching.
• lazy-content-load.md — instant first cold-mount of a long session.