The agent that grows with you
Python aiai-agentai-agentsanthropicchatgptclaudeclaude-codecodexhermeshermes-agentllmnous-researchopenai
import { atom, computed } from 'nanostores'
import type { OverlayState } from './interfaces.js'
import { captureDestination, isCurrentDestination } from './submissionDestination.js'
import { $uiState } from './uiStore.js'
export function capturePromptResponseGuard<K extends 'approval' | 'clarify' | 'sudo' | 'secret'>(
key: K,
prompt: OverlayState[K]
): () => boolean {
const destination = captureDestination()
const info = $uiState.get().info
return () => Boolean(prompt) && isCurrentDestination(destination) &&
$uiState.get().info?.execution_epoch === info?.execution_epoch &&
$uiState.get().info?.execution_generation === info?.execution_generation &&
$overlayState.get()[key] === prompt
}
const buildOverlayState = (): OverlayState => ({
agents: false,
agentsInitialHistoryIndex: 0,
approval: null,
billing: null,
clarify: null,
confirm: null,
connection: null,
connectors: false,
ambient: [],
widget: null,
journey: false,
modelPicker: false,
pager: null,
petPicker: false,
pluginsHub: false,
secret: null,
vaultCode: null,
vaultSaveLogin: null,
vaultUnlock: null,
sessions: false,
skillsHub: false,
subscription: null,
sudo: null
})
export const $overlayState = atom<OverlayState>(buildOverlayState())
// Every overlay that suspends text input. `ambient` is the one non-blocking key.
const BLOCKING_KEYS = [
'agents',
'approval',
'billing',
'clarify',
'confirm',
'connection',
'connectors',
'journey',
'modelPicker',
'pager',
'petPicker',
'pluginsHub',
'secret',
'sessions',
'skillsHub',
'subscription',
'sudo',
'vaultCode',
'vaultSaveLogin',
'vaultUnlock',
'widget'
] as const satisfies readonly (keyof OverlayState)[]
export const $isBlocked = computed($overlayState, overlay => BLOCKING_KEYS.some(key => Boolean(overlay[key])))
/**
* Does an open overlay actually PAINT OVER the status rule?
*
* Deliberately NOT `$isBlocked`. That aggregate answers a different
* question — "is text input suspended" — and `appLayout` uses it only to hide
* the input rows (`appLayout.tsx:384`). `StatusRulePane` is rendered OUTSIDE
* that guard (`appLayout.tsx:365` for `at="top"`, `:449` for `at="bottom"`),
* so most `$isBlocked` fields leave the rule fully visible.
*
* Occluding (included here):
*
* - `widget` — the modal widget slot renders at viewport level
* (`ActiveWidgetSlot`, `sdk/host.tsx:209`, outside the ComposerPane
* subtree) so it can anchor the full-screen absolute `Overlay`
* (`components/overlay.tsx`) against the whole terminal.
* - The FloatingOverlays set — `modelPicker`, `pager`, `petPicker`,
* `sessions`, `skillsHub`, `pluginsHub`, `connectors` — but ONLY when the rule sits at
* the top. That panel is `position="absolute" bottom="100%"` inside
* ComposerPane's relative Box (`appOverlays.tsx:387`), so it grows UPWARD
* over the `at="top"` rule and never reaches the `at="bottom"` one.
*
* NOT occluding (deliberately excluded):
*
* - The PromptZone flow states — `approval`, `billing`, `subscription`,
* `confirm`, `clarify`, `sudo`, `secret` (`appOverlays.tsx:58-162`). They
* render in NORMAL FLOW above ComposerPane (`appLayout.tsx:553-568`): they
* push content down, they do not cover it. The rule stays on screen and
* its clock must keep running.
* - `agents` and `journey`. They unmount the entire ComposerPane subtree
* (`appLayout.tsx:553`), so `StatusRule` unmounts with it and React's own
* effect cleanup clears the intervals. Gating on them would be dead code.
* - `ambient` — a glanceable in-flow dock that reserves its own rows.
* - Composer completions. They share the FloatingOverlays grid and do
* occlude, but they are a render prop rather than store state and they
* change on every keystroke; re-arming a 1s interval per character would
* restart the countdown each time and starve the tick outright — strictly
* worse than the churn this gate removes.
*
* `statusBar: 'off'` needs no branch: `StatusRulePane` returns null for both
* slots, so the timers are never mounted in the first place.
*/
/**
* True when any floating overlay PANEL is open (widget overlays and inline
* completions are separate concerns — see $isStatusRuleOccluded for why
* completions never occlude the status rule).
*
* SINGLE SOURCE for the floating-panel kind set: consumed by both
* FloatingOverlays' render gate (plus completions, which it adds locally)
* and $isStatusRuleOccluded's top-statusbar occlusion arm. Add new floating
* panels HERE so the timer gate can't silently miss them.
*/
export const hasFloatingPanel = (overlay: OverlayState): boolean =>
Boolean(
overlay.connectors ||
overlay.modelPicker ||
overlay.pager ||
overlay.petPicker ||
overlay.pluginsHub ||
overlay.sessions ||
overlay.skillsHub
)
export const $isStatusRuleOccluded = computed([$overlayState, $uiState], (overlay, ui) =>
Boolean(overlay.widget || (ui.statusBar === 'top' && hasFloatingPanel(overlay)))
)
/**
* SINGLE SOURCE for the credential prompts (sudo, secret, the vault cards):
* Esc / Ctrl+C decline them, the tab title and pet read them as "waiting on
* you". Add new credential prompts HERE so no gate silently misses one.
*/
export const SENSITIVE_PROMPTS = ['sudo', 'secret', 'vaultUnlock', 'vaultSaveLogin', 'vaultCode'] as const
export const hasSensitivePrompt = (overlay: Pick<OverlayState, (typeof SENSITIVE_PROMPTS)[number]>): boolean =>
SENSITIVE_PROMPTS.some(key => Boolean(overlay[key]))
/** The agent's questions and confirms, which take the keyboard from any open panel. */
export const PROMPT_KEYS = ['approval', 'clarify', 'confirm', 'connection', ...SENSITIVE_PROMPTS] as const
export const hasPromptOpen = (overlay: OverlayState): boolean => PROMPT_KEYS.some(key => Boolean(overlay[key]))
export const getOverlayState = () => $overlayState.get()
export const patchOverlayState = (next: Partial<OverlayState> | ((state: OverlayState) => OverlayState)) =>
$overlayState.set(typeof next === 'function' ? next($overlayState.get()) : { ...$overlayState.get(), ...next })
/** Full reset — used by session/turn teardown and tests. */
export const resetOverlayState = () => $overlayState.set(buildOverlayState())
/**
* Soft reset: drop FLOW-scoped overlays (approval / clarify / confirm / sudo
* / secret / pager) but PRESERVE user-toggled ones — agents dashboard, model
* picker, skills hub, sessions overlay. Those are opened deliberately and
* shouldn't vanish when a turn ends. Called from turnController.idle() on
* every turn completion / interrupt; the old "reset everything" behaviour
* silently closed /agents the moment delegation finished.
*
* `connection` is preserved too: the card belongs to a backend operation that outlives the turn's
* idle edge, and only the operation's own settlement may close it.
*/
export const resetFlowOverlays = () =>
$overlayState.set({
...buildOverlayState(),
agents: $overlayState.get().agents,
agentsInitialHistoryIndex: $overlayState.get().agentsInitialHistoryIndex,
ambient: $overlayState.get().ambient,
connection: $overlayState.get().connection,
connectors: $overlayState.get().connectors,
widget: $overlayState.get().widget,
journey: $overlayState.get().journey,
modelPicker: $overlayState.get().modelPicker,
petPicker: $overlayState.get().petPicker,
pluginsHub: $overlayState.get().pluginsHub,
sessions: $overlayState.get().sessions,
skillsHub: $overlayState.get().skillsHub
})