@clawpump/claw-agent 0.1.4 → 0.1.6

package/agent/ui-tui/src/config/env.ts

@@ -1,4 +1,5 @@
 import type { MouseTrackingMode } from '@hermes/ink'
+
 import { isTermuxTuiMode } from '../lib/termux.js'
 
 const truthy = (v?: string) => /^(?:1|true|yes|on)$/i.test((v ?? '').trim())
@@ -43,12 +44,23 @@ export const STARTUP_IMAGE = (process.env.HERMES_TUI_IMAGE ?? '').trim()
 //   behavior.
 const mouseTrackingOverride = parseToggle(process.env.HERMES_TUI_MOUSE_TRACKING)
 const mouseTrackingDisabledLegacy = truthy(process.env.HERMES_TUI_DISABLE_MOUSE)
+
 const resolvedBootMouseEnabled =
   mouseTrackingOverride ?? (TERMUX_TUI_MODE ? false : !mouseTrackingDisabledLegacy)
+
 export const MOUSE_TRACKING: MouseTrackingMode = resolvedBootMouseEnabled ? 'all' : 'off'
 
 export const NO_CONFIRM_DESTRUCTIVE = truthy(process.env.HERMES_TUI_NO_CONFIRM)
 
+// Set by the dashboard PTY launcher. This is intentionally narrower than
+// INLINE_MODE: users can opt into inline terminal rendering locally, but the
+// browser-embedded TUI has no healthy restart path after an idle exit.
+export const DASHBOARD_TUI_MODE = truthy(process.env.HERMES_TUI_DASHBOARD)
+
+// HERMES_DEV_CREDITS — dev-only live-spend readout (Δ status segment + "(dev credits)"
+// banner). Throwaway dev scaffolding; the whole readout gates on this one flag.
+export const DEV_CREDITS_MODE = truthy(process.env.HERMES_DEV_CREDITS)
+
 const inlineOverride = parseToggle(process.env.HERMES_TUI_INLINE)
 
 // Skip AlternateScreen — TUI renders into the primary buffer so the host

package/agent/ui-tui/src/config/limits.ts

@@ -3,6 +3,19 @@ export const LARGE_PASTE = { lines: 5 }
 export const LIVE_RENDER_MAX_CHARS = 16_000
 export const LIVE_RENDER_MAX_LINES = 240
 
+// Persisted verbose tool-trail blocks (Args/Result embedded in a completed
+// tool line) are kept for the WHOLE session in transcript Msg.tools[] and
+// rendered expanded by default, so a render-node tree is built for every one
+// of up to MAX_HISTORY messages at once. Capping these to the live-render
+// budget (16KB) let a heavy browser/large-output session retain ~12MB of
+// strings that exploded into a few hundred MB of Ink nodes and silently OOM-
+// killed the Node parent (→ stdin EOF, gateway death; issue #34095). The live
+// streaming tail still uses the larger LIVE_RENDER budget — only the persisted
+// per-call block shrinks to a readable preview here. Full output remains in the
+// agent context and the SQLite session; the trail is a glance, not a log.
+export const VERBOSE_TRAIL_MAX_CHARS = 800
+export const VERBOSE_TRAIL_MAX_LINES = 12
+
 export const LONG_MSG = 300
 export const MAX_HISTORY = 800
 export const THINKING_COT_MAX = 160

package/agent/ui-tui/src/domain/blockLayout.ts

@@ -0,0 +1,146 @@
+import type { DetailsMode, Msg, SectionVisibility } from '../types.js'
+
+import { sectionMode } from './details.js'
+
+/**
+ * Visual group a transcript block belongs to. Blocks in the same group render
+ * flush; a single blank line opens at each group boundary. So a run of tool
+ * trails (or model paragraphs) reads as one section and the eye only catches a
+ * gap where the *kind* of content actually changes — the boundary between
+ * reasoning/tool trails, model prose, and notes/errors.
+ *
+ *   user   — the human turn (owns its separator + margins in MessageLine)
+ *   model  — assistant prose, the model's voice
+ *   trail  — reasoning + tool-call trails (the agent's working area)
+ *   note   — system notes and errors (a quieter band)
+ *   diff   — inline patch segments (an island, owns its own margins)
+ *   slash  — slash-command echoes (owns its margin)
+ *   intro  — banner / panels (rendered out-of-band, never gapped here)
+ */
+export type BlockGroup = 'diff' | 'intro' | 'model' | 'note' | 'slash' | 'trail' | 'user'
+
+export const messageGroup = (msg: Pick<Msg, 'kind' | 'role'>): BlockGroup => {
+  switch (msg.kind) {
+    case 'intro':
+    case 'panel':
+      return 'intro'
+    case 'slash':
+      return 'slash'
+    case 'diff':
+      return 'diff'
+    case 'trail':
+      return 'trail'
+  }
+
+  if (msg.role === 'user') {
+    return 'user'
+  }
+
+  // Assistant prose is the model's voice; system notes/errors are their own
+  // band. (No runtime block uses role 'tool' — tool *results* fold into
+  // trails — so a stray 'tool' falls through to the note band harmlessly.)
+  return msg.role === 'assistant' ? 'model' : 'note'
+}
+
+// Groups whose leading gap is already owned by their own chrome in
+// MessageLine (the turn separator + top margin for user, the top margin for
+// slash, the top+bottom margins for diff) or that are painted out-of-band
+// (intro). The grouping primitive only spaces the model working area —
+// model prose, reasoning/tool trails, and notes/errors.
+const SELF_SPACED: ReadonlySet<BlockGroup> = new Set(['diff', 'intro', 'slash', 'user'])
+
+// Groups that already paint a trailing blank line beneath themselves
+// (marginBottom in MessageLine), so the block that follows must not add its
+// own leading gap or the single boundary would become a double gap.
+const PAINTS_TRAILING_GAP: ReadonlySet<BlockGroup> = new Set(['diff', 'user'])
+
+/**
+ * Whether `cur` renders one blank line above it, given the block rendered
+ * directly above it (`prev`). True only where the visual group changes, and
+ * only for the model-working-area bands (model / trail / note) — user, slash,
+ * diff, and intro keep their existing spacing.
+ *
+ * Streaming-safe by construction: the result depends on the *predecessor's*
+ * group, never on `cur`'s own (live, changing) content. The actively-streaming
+ * assistant block therefore computes the same gap while it streams as the
+ * settled segment does once it flushes, so the live area never jumps.
+ */
+export const hasLeadGap = (
+  prev: Pick<Msg, 'kind' | 'role'> | undefined,
+  cur: Pick<Msg, 'kind' | 'role'>
+): boolean => {
+  const group = messageGroup(cur)
+
+  if (SELF_SPACED.has(group)) {
+    return false
+  }
+
+  if (!prev) {
+    return false
+  }
+
+  const prevGroup = messageGroup(prev)
+
+  return prevGroup !== group && !PAINTS_TRAILING_GAP.has(prevGroup)
+}
+
+export interface DetailsCtx {
+  commandOverride?: boolean
+  detailsMode: DetailsMode
+  sections?: SectionVisibility
+}
+
+const trailAllHidden = (ctx: DetailsCtx): boolean =>
+  sectionMode('thinking', ctx.detailsMode, ctx.sections, ctx.commandOverride) === 'hidden' &&
+  sectionMode('tools', ctx.detailsMode, ctx.sections, ctx.commandOverride) === 'hidden' &&
+  sectionMode('activity', ctx.detailsMode, ctx.sections, ctx.commandOverride) === 'hidden'
+
+/**
+ * Whether a settled transcript block paints anything. A trail renders nothing
+ * when it has no reasoning/tools/todos to show (e.g. the finalDetails segment
+ * that carries only a token tally) or when every section it does have is hidden
+ * (`/details hidden`); every other block draws at least one row. A block that
+ * renders nothing is *transparent* to grouping: the block below it draws its
+ * boundary against the nearest visible block instead (see prevRenderedMsg), so
+ * a hidden or content-less trail never leaves a floating blank line, doubles
+ * the gap after a user prompt, or pads the space above the final reply. In the
+ * default/collapsed modes content-bearing trails always render, so this is a
+ * no-op there.
+ */
+export const blockRenders = (msg: Pick<Msg, 'kind' | 'thinking' | 'todos' | 'tools'>, ctx: DetailsCtx): boolean => {
+  if (msg.kind !== 'trail') {
+    return true
+  }
+
+  if (msg.todos?.length) {
+    return true
+  }
+
+  if (!(msg.tools?.length || msg.thinking?.trim())) {
+    return false
+  }
+
+  return !trailAllHidden(ctx)
+}
+
+/**
+ * The nearest block above `index` that actually renders, resolved through a
+ * lazy accessor so it works over either the virtualized history rows or the
+ * live block list. This is the grouping predecessor — using it (instead of the
+ * literal previous row) keeps hidden trails from interrupting the rhythm.
+ */
+export const prevRenderedMsg = (
+  msgAt: (i: number) => Msg | undefined,
+  index: number,
+  ctx: DetailsCtx
+): Msg | undefined => {
+  for (let i = index - 1; i >= 0; i--) {
+    const candidate = msgAt(i)
+
+    if (candidate && blockRenders(candidate, ctx)) {
+      return candidate
+    }
+  }
+
+  return undefined
+}

package/agent/ui-tui/src/domain/paths.ts

@@ -14,3 +14,27 @@ export const fmtCwdBranch = (cwd: string, branch: null | string, max = 40) => {
 
   return `${shortCwd(cwd, Math.max(8, max - tag.length))}${tag}`
 }
+
+/**
+ * Compose the terminal titlebar string:
+ *   `<marker> <session name> · <model> · <cwd>`
+ *
+ * The session name and cwd are each omitted when empty, and a long session
+ * name is truncated. The marker is always glued to the first present segment
+ * with a plain space (not a ` · ` separator). When no model is known yet the
+ * caller should fall back to a plain brand string instead of calling this.
+ */
+export const composeTabTitle = (
+  marker: string,
+  sessionName: string,
+  model: string,
+  cwd: string,
+  maxName = 28
+): string => {
+  const name = sessionName.trim()
+  const shortName = name.length > maxName ? `${name.slice(0, maxName - 1)}…` : name
+
+  const segments = [shortName, model, cwd].filter(Boolean)
+
+  return segments.length ? `${marker} ${segments.join(' · ')}` : marker
+}

package/agent/ui-tui/src/domain/slash.ts

@@ -8,3 +8,43 @@ export const parseSlashCommand = (cmd: string) => {
 
   return { arg: rest.join(' '), cmd, name: name.toLowerCase() }
 }
+
+/**
+ * Apply a completion row to the current input, mirroring the editor's
+ * replace semantics: replace from `compReplace` with the row text, dropping
+ * the leading slash when both the input and the row carry one (the gateway's
+ * slash completer returns bare command names whose replace span begins after
+ * the leading `/`).
+ */
+export const applyCompletion = (value: string, rowText: string, compReplace: number): string => {
+  const text = value.startsWith('/') && rowText.startsWith('/') ? rowText.slice(1) : rowText
+
+  return value.slice(0, compReplace) + text
+}
+
+/**
+ * Decide what Enter does when a completion is highlighted: returns the value
+ * to set (accept the completion) or `null` to fall through to submit.
+ *
+ * Enter accepts a completion only when it changes the command/argument token.
+ * A completion that merely appends trailing whitespace to an already-complete
+ * command (e.g. `/exit` → `/exit `, the trailing space the gateway adds so the
+ * classic CLI's prompt_toolkit dropdown stays open) must NOT swallow the Enter
+ * — otherwise every slash command needs an extra keypress: type → Enter
+ * completes the name → Enter adds the space → Enter finally submits. Treating a
+ * whitespace-only delta as "already complete" collapses that back to the
+ * expected one/two presses.
+ */
+export const completionToApplyOnSubmit = (
+  value: string,
+  rowText: string | undefined,
+  compReplace: number
+): string | null => {
+  if (!rowText) {
+    return null
+  }
+
+  const next = applyCompletion(value, rowText, compReplace)
+
+  return next !== value && next.trimEnd() !== value.trimEnd() ? next : null
+}

package/agent/ui-tui/src/entry.tsx

@@ -5,7 +5,7 @@ import './lib/forceTruecolor.js'
 
 import type { FrameEvent } from '@hermes/ink'
 
-import { TERMUX_TUI_MODE } from './config/env.js'
+import { DASHBOARD_TUI_MODE, TERMUX_TUI_MODE } from './config/env.js'
 import { GatewayClient } from './gatewayClient.js'
 import { setupGracefulExit } from './lib/gracefulExit.js'
 import { formatBytes, type HeapDumpResult, performHeapDump } from './lib/memory.js'
@@ -23,6 +23,22 @@ if (!process.stdin.isTTY) {
 // terminal tab can still have mouse/focus/paste modes enabled.
 resetTerminalModes()
 
+// Final backstop for terminal cleanup. setupGracefulExit() resets modes on
+// signals/uncaught errors, and die()/dieWithCode() call process.exit() after
+// Ink's unmount specifically so this handler can fire (see useMainApp.ts and
+// #19194). But that handler was never actually installed — so /quit, Ctrl+C,
+// Ctrl+D, and any process.exit() path left DEC mouse tracking (?1000/1002/
+// 1003/1006) armed in the parent shell. The terminal then keeps emitting mouse
+// reports into whatever reads stdin next — the shell or a freshly relaunched
+// TUI mid-init — which surface as `102;71M5;104;62M`-style garbage in the input
+// box (#28419). 'exit' fires exactly once on real termination and only runs
+// synchronous code; resetTerminalModes() writes via writeSync, so it completes
+// before the process is gone. Idempotent and cheap, so layering it under the
+// graceful-exit cleanups is safe.
+process.on('exit', () => {
+  resetTerminalModes()
+})
+
 // Desktop terminals benefit from a clean startup slate because the TUI usually
 // runs in AlternateScreen. On Termux we keep prior output intact so users can
 // review/copy earlier assistant replies after reopening the app.
@@ -37,7 +53,7 @@ const gw = new GatewayClient()
 gw.start()
 
 const dumpNotice = (snap: MemorySnapshot, dump: HeapDumpResult | null) =>
-  `hermes-tui: ${snap.level} memory (${formatBytes(snap.heapUsed)}) — auto heap dump → ${dump?.heapPath ?? '(failed)'}\n`
+  `hermes-tui: ${snap.level} memory (${formatBytes(snap.heapUsed)}) — auto heap dump → ${dump?.heapPath ?? dump?.diagPath ?? '(failed)'}\n`
 
 setupGracefulExit({
   cleanups: [
@@ -60,7 +76,12 @@ setupGracefulExit({
     recordParentLifecycle(`graceful-exit received signal=${signal} → killing gateway`)
     resetTerminalModes()
     process.stderr.write(`hermes-tui lifecycle: received ${signal}\n`)
-  }
+  },
+  // The dashboard chat tab has no in-page restart path after the PTY child
+  // exits. Ignore SIGINT there so Ctrl+C cannot kill the embedded TUI if raw
+  // mode briefly drops and the terminal driver turns the keystroke into a
+  // signal instead of input bytes. SIGTERM/SIGHUP still cleanly shut down.
+  ignoredSignals: DASHBOARD_TUI_MODE ? ['SIGINT'] : []
 })
 
 const stopMemoryMonitor = startMemoryMonitor({
@@ -75,7 +96,17 @@ const stopMemoryMonitor = startMemoryMonitor({
     process.stderr.write('hermes-tui: exiting to avoid OOM; restart to recover\n')
     process.exit(137)
   },
-  onHigh: (snap, dump) => process.stderr.write(dumpNotice(snap, dump))
+  onHigh: (snap, dump) => process.stderr.write(dumpNotice(snap, dump)),
+  // Sub-threshold abnormal heap growth (#34095). The TUI used to die silently
+  // here — Node OOMs from a render-tree blowup well below the exit threshold,
+  // so the only trace was a bare gateway `stdin EOF`. Persist a breadcrumb +
+  // stderr line so the next such death is attributable instead of silent.
+  onWarn: snap => {
+    recordParentLifecycle(`memory-warning fast heap growth heap=${formatBytes(snap.heapUsed)} rss=${formatBytes(snap.rss)}`)
+    process.stderr.write(
+      `hermes-tui: heap climbing fast (${formatBytes(snap.heapUsed)}) — a large tool output or long session may be straining memory\n`
+    )
+  }
 })
 
 if (process.env.HERMES_HEAPDUMP_ON_START === '1') {

package/agent/ui-tui/src/gatewayClient.ts

@@ -4,6 +4,8 @@ import { existsSync } from 'node:fs'
 import { delimiter, resolve } from 'node:path'
 import { createInterface } from 'node:readline'
 
+import { WebSocket as UndiciWebSocket } from 'undici'
+
 import type { GatewayEvent } from './gatewayTypes.js'
 import { CircularBuffer } from './lib/circularBuffer.js'
 import { recordParentLifecycle } from './lib/parentLog.js'
@@ -19,6 +21,9 @@ const WS_OPEN = 1
 const WS_CLOSING = 2
 const WS_CLOSED = 3
 
+const getWebSocketCtor = (): typeof WebSocket =>
+  typeof WebSocket === 'undefined' ? (UndiciWebSocket as unknown as typeof WebSocket) : WebSocket
+
 const truncateLine = (line: string) =>
   line.length > MAX_LOG_LINE_BYTES ? `${line.slice(0, MAX_LOG_LINE_BYTES)}… [truncated ${line.length} bytes]` : line
 
@@ -79,12 +84,8 @@ const asWireText = (raw: unknown): string | null => {
     return raw
   }
 
-  if (raw instanceof ArrayBuffer) {
-    return _wireDecoder.decode(raw)
-  }
-
-  if (ArrayBuffer.isView(raw)) {
-    return _wireDecoder.decode(raw)
+  if (raw instanceof ArrayBuffer || ArrayBuffer.isView(raw)) {
+    return _wireDecoder.decode(raw as any as ArrayBuffer)
   }
 
   return null
@@ -266,14 +267,16 @@ export class GatewayClient extends EventEmitter {
       return
     }
 
-    if (typeof WebSocket === 'undefined') {
+    const WebSocketCtor = getWebSocketCtor()
+
+    if (typeof WebSocketCtor === 'undefined') {
       this.pushLog(`[sidecar] WebSocket unavailable; skipping mirror to ${redactUrl(this.sidecarUrl)}`)
 
       return
     }
 
     try {
-      const ws = new WebSocket(this.sidecarUrl)
+      const ws = new WebSocketCtor(this.sidecarUrl)
 
       this.sidecarWs = ws
       ws.addEventListener('close', () => {
@@ -304,6 +307,13 @@ export class GatewayClient extends EventEmitter {
     }
   }
 
+  publishLocalEvent(ev: GatewayEvent) {
+    const frame = JSON.stringify({ jsonrpc: '2.0', method: 'event', params: ev })
+
+    this.mirrorEventToSidecar(frame)
+    this.publish(ev)
+  }
+
   private handleWebSocketFrame(raw: unknown) {
     const text = asWireText(raw)
 
@@ -406,7 +416,9 @@ export class GatewayClient extends EventEmitter {
     const safeAttachUrl = redactUrl(attachUrl)
     this.startReadyTimer('websocket', safeAttachUrl)
 
-    if (typeof WebSocket === 'undefined') {
+    const WebSocketCtor = getWebSocketCtor()
+
+    if (typeof WebSocketCtor === 'undefined') {
       const line = `[startup] WebSocket API unavailable; cannot attach to ${safeAttachUrl}`
 
       this.pushLog(line)
@@ -417,7 +429,7 @@ export class GatewayClient extends EventEmitter {
     }
 
     try {
-      const ws = new WebSocket(attachUrl)
+      const ws = new WebSocketCtor(attachUrl)
       let settled = false
 
       this.ws = ws

package/agent/ui-tui/src/gatewayTypes.ts

@@ -43,6 +43,105 @@ export interface SlashExecResponse {
   warning?: string
 }
 
+// ── Credits / top-up ─────────────────────────────────────────────────
+
+export interface CreditsViewResponse {
+  balance_lines: string[]
+  depleted: boolean
+  identity_line: string | null
+  logged_in: boolean
+  topup_url: string | null
+}
+
+// ── Terminal billing (Phase 2b) ──────────────────────────────────────
+
+export interface BillingCardInfo {
+  brand: string
+  last4: string
+  masked: string
+}
+
+export interface BillingMonthlyCap {
+  is_default_ceiling: boolean
+  limit_display: string
+  limit_usd: string | null
+  spent_display: string
+  spent_this_month_usd: string | null
+}
+
+export interface BillingAutoReload {
+  enabled: boolean
+  reload_to_display: string
+  reload_to_usd: string | null
+  threshold_display: string
+  threshold_usd: string | null
+}
+
+export interface BillingStateResponse {
+  auto_reload: BillingAutoReload | null
+  balance_display: string
+  balance_usd: string | null
+  can_charge: boolean
+  card: BillingCardInfo | null
+  charge_presets: string[]
+  charge_presets_display: string[]
+  cli_billing_enabled: boolean
+  error?: string | null
+  is_admin: boolean
+  logged_in: boolean
+  max_usd: string | null
+  min_usd: string | null
+  monthly_cap: BillingMonthlyCap | null
+  ok: boolean
+  org_name: string | null
+  portal_url: string | null
+  role: string | null
+}
+
+/**
+ * Raw error payload echoed from the server (`_serialize_billing_error`). Carries
+ * the extra fields a few error codes attach — notably `remainingUsd` on
+ * `monthly_cap_exceeded` — so the client can render the same detail the CLI does.
+ */
+export interface BillingErrorPayload {
+  isDefaultCeiling?: boolean
+  remainingUsd?: string
+}
+
+export interface BillingChargeResponse {
+  charge_id?: string
+  error?: string
+  idempotency_key?: string
+  message?: string
+  ok: boolean
+  payload?: BillingErrorPayload
+  portal_url?: string | null
+  retry_after?: number | null
+}
+
+export interface BillingChargeStatusResponse {
+  amount_usd?: string | null
+  error?: string
+  message?: string
+  ok: boolean
+  payload?: BillingErrorPayload
+  portal_url?: string | null
+  reason?: string | null
+  retry_after?: number | null
+  settled_at?: string | null
+  status?: string
+}
+
+export interface BillingMutationResponse {
+  error?: string
+  granted?: boolean
+  message?: string
+  ok: boolean
+  payload?: BillingErrorPayload
+  portal_url?: string | null
+  retry_after?: number | null
+}
+
 export type CommandDispatchResponse =
   | { output?: string; type: 'exec' | 'plugin' }
   | { target: string; type: 'alias' }
@@ -103,6 +202,8 @@ export interface ConfigGetValueResponse {
 }
 
 export interface ConfigSetResponse {
+  confirm_message?: string
+  confirm_required?: boolean
   credential_warning?: string
   history_reset?: boolean
   info?: SessionInfo
@@ -122,11 +223,15 @@ export interface SessionCreateResponse {
 }
 
 export interface SessionResumeResponse {
+  inflight?: null | SessionInflightTurn
   info?: SessionInfo
   message_count?: number
   messages: GatewayTranscriptMessage[]
   resumed?: string
+  running?: boolean
   session_id: string
+  started_at?: number
+  status?: LiveSessionStatus
 }
 
 export type LiveSessionStatus = 'idle' | 'starting' | 'waiting' | 'working'
@@ -214,6 +319,7 @@ export interface SessionUsageResponse {
   context_used?: number
   cost_status?: 'estimated' | 'exact'
   cost_usd?: number
+  credits_lines?: string[]
   input?: number
   model?: string
   output?: number
@@ -508,8 +614,27 @@ export type GatewayEvent =
   | { payload?: { text?: string }; session_id?: string; type: 'thinking.delta' }
   | { payload?: undefined; session_id?: string; type: 'message.start' }
   | { payload?: { kind?: string; text?: string }; session_id?: string; type: 'status.update' }
+  | {
+      payload?: {
+        id?: string
+        key?: string
+        kind?: 'sticky' | 'ttl'
+        level?: 'error' | 'info' | 'success' | 'warn'
+        text?: string
+        ttl_ms?: null | number
+      }
+      session_id?: string
+      type: 'notification.show'
+    }
+  | { payload?: { key?: string }; session_id?: string; type: 'notification.clear' }
+  | {
+      payload: { user_code?: string; verification_url: string }
+      session_id?: string
+      type: 'billing.step_up.verification'
+    }
   | { payload?: { state?: 'idle' | 'listening' | 'transcribing' }; session_id?: string; type: 'voice.status' }
   | { payload?: { no_speech_limit?: boolean; text?: string }; session_id?: string; type: 'voice.transcript' }
+  | { payload?: { reason?: string }; session_id?: string; type: 'dashboard.new_session_requested' }
   | { payload: { line: string }; session_id?: string; type: 'gateway.stderr' }
   | {
       payload?: { level?: 'info' | 'warn' | 'error'; message?: string }
@@ -549,7 +674,11 @@ export type GatewayEvent =
       session_id?: string
       type: 'clarify.request'
     }
-  | { payload: { command: string; description: string }; session_id?: string; type: 'approval.request' }
+  | {
+      payload: { allow_permanent?: boolean; command: string; description: string }
+      session_id?: string
+      type: 'approval.request'
+    }
   | { payload: { request_id: string }; session_id?: string; type: 'sudo.request' }
   | { payload: { env_var: string; prompt: string; request_id: string }; session_id?: string; type: 'secret.request' }
   | { payload: { task_id: string; text: string }; session_id?: string; type: 'background.complete' }

package/agent/ui-tui/src/lib/gracefulExit.ts

@@ -1,11 +1,16 @@
 interface SetupOptions {
   cleanups?: (() => Promise<void> | void)[]
   failsafeMs?: number
+  ignoredSignals?: GracefulSignal[]
   onError?: (scope: 'uncaughtException' | 'unhandledRejection', err: unknown) => void
   onSignal?: (signal: NodeJS.Signals) => void
 }
 
-const SIGNAL_EXIT_CODE: Record<'SIGHUP' | 'SIGINT' | 'SIGTERM', number> = {
+export type GracefulSignal = 'SIGHUP' | 'SIGINT' | 'SIGTERM'
+
+const SIGNALS: readonly GracefulSignal[] = ['SIGINT', 'SIGTERM', 'SIGHUP']
+
+const SIGNAL_EXIT_CODE: Record<GracefulSignal, number> = {
   SIGHUP: 129,
   SIGINT: 130,
   SIGTERM: 143
@@ -13,7 +18,16 @@ const SIGNAL_EXIT_CODE: Record<'SIGHUP' | 'SIGINT' | 'SIGTERM', number> = {
 
 let wired = false
 
-export function setupGracefulExit({ cleanups = [], failsafeMs = 4000, onError, onSignal }: SetupOptions = {}) {
+export const shouldExitForSignal = (signal: GracefulSignal, ignoredSignals: readonly GracefulSignal[] = []) =>
+  !ignoredSignals.includes(signal)
+
+export function setupGracefulExit({
+  cleanups = [],
+  failsafeMs = 4000,
+  ignoredSignals = [],
+  onError,
+  onSignal
+}: SetupOptions = {}) {
   if (wired) {
     return
   }
@@ -38,8 +52,14 @@ export function setupGracefulExit({ cleanups = [], failsafeMs = 4000, onError, o
     void Promise.allSettled(cleanups.map(fn => Promise.resolve().then(fn))).finally(() => process.exit(code))
   }
 
-  for (const sig of ['SIGINT', 'SIGTERM', 'SIGHUP'] as const) {
-    process.on(sig, () => exit(SIGNAL_EXIT_CODE[sig], sig))
+  for (const sig of SIGNALS) {
+    process.on(sig, () => {
+      if (!shouldExitForSignal(sig, ignoredSignals)) {
+        return
+      }
+
+      exit(SIGNAL_EXIT_CODE[sig], sig)
+    })
   }
 
   process.on('uncaughtException', err => onError?.('uncaughtException', err))