@pellux/goodvibes-tui 0.25.0 → 0.27.0

package/src/input/handler-onboarding.ts

@@ -1,6 +1,6 @@
 import { createOAuthLocalListener } from '@pellux/goodvibes-sdk/platform/config';
 import { beginOpenAICodexLogin, exchangeOpenAICodexCode } from '@pellux/goodvibes-sdk/platform/config';
-import { openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
+import { summarizeError, openExternalUrl } from '@pellux/goodvibes-sdk/platform/utils';
 import { getProviderIdFromModel } from '../config/provider-model.ts';
 import { buildProviderAccountSnapshot } from '@/runtime/index.ts';
 import { OnboardingWizardController, type OnboardingWizardAction, type OnboardingWizardApplyFeedback } from './onboarding/onboarding-wizard.ts';
@@ -258,7 +258,7 @@ export async function handleOnboardingActionForHandler(handler: InputHandler, ac
           deleteWizardProgress(handler.uiServices.environment.shellPaths);
         } catch (markerError) {
           handler.commandContext?.print?.(
-            `Onboarding check marker could not be written: ${markerError instanceof Error ? markerError.message : String(markerError)}`,
+            `Onboarding check marker could not be written: ${summarizeError(markerError)}`,
           );
         }
         const activationVerification = await handler.restartOnboardingExternalServicesIfNeeded(request);
@@ -275,7 +275,7 @@ export async function handleOnboardingActionForHandler(handler: InputHandler, ac
         severity: 'error',
         title: 'Apply failed',
         summary: 'The wizard could not persist these settings. No service restart was attempted.',
-        messages: [error instanceof Error ? error.message : String(error)],
+        messages: [summarizeError(error)],
       });
       return;
     } finally {
@@ -346,7 +346,7 @@ export async function refreshOnboardingHydrationForHandler(handler: InputHandler
       handler.requestRender();
     } catch (error) {
       if (!handler.onboardingWizard.active || hydrationSerial !== handler.onboardingHydrationSerial) return;
-      const message = error instanceof Error ? error.message : String(error);
+      const message = summarizeError(error);
       handler.onboardingWizard.failRuntimeHydration(message);
       handler.requestRender();
     }
@@ -405,7 +405,7 @@ export async function handleOpenAiSubscriptionStartForHandler(handler: InputHand
       listener?.close();
       handler.commandContext?.print?.([
         'OpenAI subscription sign-in could not start.',
-        `  ${error instanceof Error ? error.message : String(error)}`,
+        `  ${summarizeError(error)}`,
       ].join('\n'));
       handler.requestRender();
     } finally {
@@ -449,7 +449,7 @@ export async function completeOpenAiSubscriptionFromListenerForHandler(
     } catch (error) {
       handler.commandContext?.print?.([
         'OpenAI subscription listener could not complete automatically.',
-        `  listener: ${error instanceof Error ? error.message : String(error)}`,
+        `  listener: ${summarizeError(error)}`,
         'Paste the callback code or URL into the OpenAI callback field to finish in onboarding.',
       ].join('\n'));
       handler.requestRender();
@@ -501,7 +501,7 @@ export async function handleOpenAiSubscriptionFinishForHandler(handler: InputHan
     } catch (error) {
       handler.commandContext?.print?.([
         'OpenAI subscription sign-in could not finish.',
-        `  ${error instanceof Error ? error.message : String(error)}`,
+        `  ${summarizeError(error)}`,
       ].join('\n'));
       handler.requestRender();
     } finally {
@@ -663,7 +663,7 @@ export async function restartOnboardingExternalServicesIfNeededForHandler(handle
       return [{
         id: 'runtime:activation-restart',
         status: 'fail',
-        message: `Background services could not restart: ${error instanceof Error ? error.message : String(error)}`,
+        message: `Background services could not restart: ${summarizeError(error)}`,
         target: 'service',
       }];
     }

package/src/input/handler-ui-state.ts

@@ -345,7 +345,7 @@ export function handleHistorySearchToken(state: HistorySearchRouteState, token:
     if (token.logicalName === 'escape' || (token.ctrl && token.logicalName === 'g')) {
       state.prompt = state.historySearch.cancel();
       state.cursorPos = state.prompt.length;
-    } else if (token.logicalName === 'return') {
+    } else if (token.logicalName === 'enter' || token.logicalName === 'return') {
       state.prompt = state.historySearch.accept();
       state.cursorPos = state.prompt.length;
     } else if (token.logicalName === 'backspace') {

package/src/input/tts-settings-actions.ts

@@ -1,6 +1,7 @@
 import type { ConfigKey } from '@pellux/goodvibes-sdk/platform/config';
 import type { CommandContext } from './command-registry.ts';
 import type { SelectionItem } from './selection-modal.ts';
+import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
 
 function getStreamingTtsProviders(ctx: CommandContext): Array<{ id: string; label: string; capabilities: readonly string[] }> {
   const registry = ctx.platform.voiceProviderRegistry;
@@ -94,7 +95,7 @@ export async function openTtsVoicePicker(ctx: CommandContext, providerArg?: stri
     });
     return true;
   } catch (error) {
-    ctx.print(`Unable to list TTS voices: ${error instanceof Error ? error.message : String(error)}`);
+    ctx.print(`Unable to list TTS voices: ${summarizeError(error)}`);
     return true;
   }
 }

package/src/main.ts

@@ -52,6 +52,7 @@ import { renderToolCallBlock } from './renderer/tool-call.ts';
 import { wireSpokenTurnRuntime } from './audio/spoken-turn-wiring.ts';
 import { attachSpokenTurnModelRouting, createSpokenTurnInputOptions } from './audio/spoken-turn-model-routing.ts';
 import { allowTerminalWrite, installTuiTerminalOutputGuard } from './runtime/terminal-output-guard.ts';
+import { installProcessLifecycle } from './runtime/process-lifecycle.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { summarizeRunningAgents } from './renderer/process-summary.ts';
 import { formatUserFacingErrorLine } from './core/format-user-error.ts';
@@ -165,6 +166,9 @@ async function main() {
 
   let scrollTop = 0;
   let scrollLocked = true;
+  // Cached from the overlay-aware clamp the renderer computes (conversation-layout) each
+  // frame so scroll() clamps against exactly what is displayed, not a footer estimate.
+  let lastMaxScroll: number | null = null;
   // Stream and tool-timer state; mutated by wireStreamEventMetrics handlers, read during render.
   const streamMetrics: StreamMetrics = {
     startTime: 0,
@@ -187,18 +191,23 @@ async function main() {
     if (input.onboardingWizard.active) return stdout.rows || 24;
     const promptLines: number = input.getVisiblePromptLineCount(getPromptContentWidth());
     const currentModel = providerRegistry.getCurrentModel();
-    return (stdout.rows || 24) - 2 - estimateShellFooterHeight(promptLines, currentModel.contextWindow);
+    const contextWindow = providerRegistry.getContextWindowForModel(currentModel);
+    return (stdout.rows || 24) - 2 - estimateShellFooterHeight(promptLines, contextWindow);
   };
 
   const scroll = (delta: number) => {
-    const vHeight = getViewportHeight();
-    const maxScroll = Math.max(0, conversation.history.getLineCount() - vHeight);
+    // Prefer the last clamp the renderer computed (overlay- and real-footer-aware).
+    // The footer estimate is only a fallback for the pre-first-render frame.
+    const maxScroll = lastMaxScroll ?? Math.max(0, conversation.history.getLineCount() - getViewportHeight());
     scrollTop = Math.max(0, Math.min(scrollTop + delta, maxScroll));
     // Re-lock if user scrolled to bottom, otherwise unlock
     scrollLocked = scrollTop >= maxScroll;
   };
 
   const scrollToEnd = (vHeight: number) => {
+    // Respect a manual scroll-up by the user: only auto-follow the tail when parked at the
+    // bottom (scrollLocked). submitInput re-locks on new input so turns resume following.
+    if (!scrollLocked) return;
     scrollTop = Math.max(0, conversation.history.getLineCount() - vHeight);
   };
 
@@ -207,59 +216,31 @@ async function main() {
   let stopSpokenOutputForExit: (() => void) | null = null;
   let recoveryPending = false;
 
-  const sigintHandler = (): void => input.feed('\x03');
-  let _unhandledRejectionCount = 0;
-  let _unhandledRejectionWindowStart = Date.now();
-  const unhandledRejectionHandler = (reason: unknown): void => {
-    const now = Date.now();
-    if (now - _unhandledRejectionWindowStart > 10000) {
-      _unhandledRejectionCount = 0;
-      _unhandledRejectionWindowStart = now;
-    }
-    _unhandledRejectionCount++;
-    const msg = reason instanceof Error ? reason.message : String(reason);
-    if (_unhandledRejectionCount > 3) {
-      logger.error('CRITICAL: cascading unhandled rejections — consider restarting', {
-        count: _unhandledRejectionCount,
-        windowMs: now - _unhandledRejectionWindowStart,
-        error: String(reason),
-      });
-      systemMessageRouter.high(
-        `[Critical] Multiple errors detected (${_unhandledRejectionCount} in 10s). If the issue persists, please restart. Latest: ${msg}`
-      );
-    } else {
-      const formatted = formatUserFacingErrorLine(reason);
-      systemMessageRouter.high(`[Error] ${formatted}`);
-      logger.error('unhandledRejection', { error: String(reason) });
-    }
-    render();
-  };
-  const resizeHandler = (): void => {
-    input.setContentWidth(getPromptContentWidth());
-    compositor.resetDiff();
-    render();
-  };
-
-  const exitApp = (): void => {
-    stopSpokenOutputForExit?.();
-    unsubs.forEach(fn => fn());
-    const snapshot = conversation.toJSON() as { messages: Array<import('./core/conversation.ts').ConversationMessageSnapshot>; timestamp?: number };
-    ctx.shutdown({ ...snapshot, ...buildPersistedSessionContext(snapshot.messages, conversation.getTitleSource(), buildSessionContinuityHints()) }).catch((err) => {
-      logger.debug('ctx.shutdown error during exitApp (non-fatal)', { error: summarizeError(err) });
-    });
-    if (recoveryInterval !== null) { clearInterval(recoveryInterval); recoveryInterval = null; }
-    deleteRecoveryFile({ homeDirectory });
-    stdin.removeAllListeners('data');
-    stdout.removeListener('resize', resizeHandler);
-    process.removeListener('SIGINT', sigintHandler);
-    process.removeListener('unhandledRejection', unhandledRejectionHandler);
-    const exitScreen = cli.flags.noAltScreen ? CLEAR_SCREEN : CLEAR_SCREEN + ALT_SCREEN_EXIT;
-    allowTerminalWrite(() => stdout.write(PASTE_DISABLE + KEYBOARD_EXT_DISABLE + MOUSE_DISABLE + CURSOR_SHOW + exitScreen));
-    terminalOutputGuard.dispose();
-    stdin.setRawMode(false);
-    process.exit(0);
-  };
-
+  const lifecycle = installProcessLifecycle({
+    stdin,
+    stdout,
+    ctx,
+    noAltScreen: cli.flags.noAltScreen,
+    ansi: { CLEAR_SCREEN, ALT_SCREEN_EXIT, PASTE_DISABLE, KEYBOARD_EXT_DISABLE, MOUSE_DISABLE, CURSOR_SHOW },
+    getInput: () => input,
+    render: () => render(),
+    getPromptContentWidth,
+    getTerminalOutputGuard: () => terminalOutputGuard,
+    buildSessionContinuityHints,
+    unsubs,
+    getRecoveryInterval: () => recoveryInterval,
+    setRecoveryInterval: (value) => { recoveryInterval = value; },
+    getStopSpokenOutputForExit: () => stopSpokenOutputForExit,
+  });
+  const {
+    exitApp,
+    resizeHandler,
+    sigintHandler,
+    unhandledRejectionHandler,
+    uncaughtExceptionHandler,
+    terminationSignalHandler,
+    exitListener,
+  } = lifecycle;
   commandContext.exit = exitApp;
 
   const spokenTurns = wireSpokenTurnRuntime({
@@ -456,6 +437,9 @@ async function main() {
 
     // Cache the current model for consistent values across the entire render frame
     const currentModel = providerRegistry.getCurrentModel();
+    // Resolve the effective context window (provider_api / configured_cap overrides) once,
+    // so the footer meter, footer-height, and context inspector agree with the Tokens panel.
+    const contextWindow = providerRegistry.getContextWindowForModel(currentModel);
     const sessionSnapshot = uiServices.readModels.session.getSnapshot();
     const agentSnapshot = uiServices.readModels.agents.getSnapshot();
 
@@ -481,7 +465,7 @@ async function main() {
     const maintenanceStatus = evaluateSessionMaintenance({
       configManager,
       currentTokens: orchestrator.lastInputTokens,
-      contextWindow: currentModel.contextWindow,
+      contextWindow,
       sessionMemoryCount: ctx.services.sessionMemoryStore.list().length,
     });
     const contextStatusHint = buildContextStatusHint({
@@ -505,7 +489,7 @@ async function main() {
       toolCount: toolRegistry.list().length,
       workingDir,
       provider: runtime.provider,
-      contextWindow: currentModel.contextWindow,
+      contextWindow,
       contextStatusHint,
       // behavior.autoCompactThreshold is stored as a percent integer (e.g. 80);
       // the meter expects a fraction [0..1]. Clamp to [0,1] to guard nonsense values.
@@ -586,6 +570,7 @@ async function main() {
       overlayRows,
     });
     scrollTop = conversationViewport.nextScrollTop;
+    lastMaxScroll = conversationViewport.maxScroll;
     let viewport = conversationViewport.viewport;
 
     if (orchestrator.isThinking) {
@@ -628,7 +613,7 @@ async function main() {
       keybindingsManager: ctx.services.keybindingsManager,
       conversationWidth,
       viewportHeight: vHeight,
-      contextWindow: currentModel.contextWindow,
+      contextWindow,
     });
 
     // Panel composite data
@@ -732,6 +717,14 @@ async function main() {
     }
   });
 
+  // Register terminal-restoring crash/termination handlers BEFORE entering raw mode so a
+  // throw during terminal setup or the initial render still restores the terminal; the
+  // 'exit' listener is the final safety net for any process.exit path.
+  process.on('uncaughtException', uncaughtExceptionHandler);
+  process.on('SIGTERM', terminationSignalHandler);
+  process.on('SIGHUP', terminationSignalHandler);
+  process.on('exit', exitListener);
+
   // --- Terminal setup ---
   stdin.setRawMode(true);
   stdin.resume();

package/src/panels/agent-inspector-panel.ts

@@ -91,6 +91,15 @@ export interface AgentInspectorPanelDeps {
   readonly workingDirectory: string;
   /** Cancel the agent by id. Uses the same orphan-free path as WRFC. Returns true if cancelled. */
   readonly cancelAgent: (agentId: string) => boolean;
+  /**
+   * Request a compositor repaint. The 500ms refresh timer and other async
+   * update paths call this (via markDirty) so live agent output is painted
+   * while the main thread is idle — render() is otherwise only invoked on
+   * input/turn/resize, which makes a running agent's timeline look frozen.
+   * Optional: when omitted the panel still marks dirty and repaints on the
+   * next event.
+   */
+  readonly requestRender?: () => void;
 }
 
 export class AgentInspectorPanel extends BasePanel {
@@ -115,6 +124,9 @@ export class AgentInspectorPanel extends BasePanel {
   /** Pending cancel confirmation — subject is the agent id to cancel. */
   private confirmCancel: ConfirmState<string> | null = null;
 
+  /** True while this panel is the active view — gates async repaint requests. */
+  private _active = false;
+
   constructor(private readonly deps: AgentInspectorPanelDeps) {
     super('inspector', 'Inspector', 'I', 'agent');
   }
@@ -131,6 +143,10 @@ export class AgentInspectorPanel extends BasePanel {
   override markDirty(): void {
     this._cachedRows = null;
     super.markDirty();
+    // T17: a bare markDirty() does not repaint — render() only runs on
+    // input/turn/resize. While active, ask the compositor for a frame so
+    // timer/async refreshes (live streaming output) are not stuck off-screen.
+    if (this._active) this.deps.requestRender?.();
   }
 
   // -------------------------------------------------------------------------
@@ -152,11 +168,13 @@ export class AgentInspectorPanel extends BasePanel {
   // -------------------------------------------------------------------------
 
   override onActivate(): void {
+    this._active = true;
     this.needsRender = true;
     this._startRefresh();
   }
 
   override onDeactivate(): void {
+    this._active = false;
     this._stopRefresh();
   }
 
@@ -441,8 +459,21 @@ export class AgentInspectorPanel extends BasePanel {
 
     // Merge bus messages (live) + JSONL (historical), sorted by timestamp
     const busEntries = this._busToTimeline();
-    const merged = [...this.timeline, ...busEntries]
-      .sort((a, b) => a.timestamp - b.timestamp);
+    const merged = [...this.timeline, ...busEntries];
+
+    // T13: the JSONL timeline only records coarse per-turn summaries
+    // ([assistant] N chars, M tool calls) and never the model's actual text,
+    // so a mid-turn agent looks idle here. Surface the selected agent's live
+    // streaming output while it runs, and its final output once terminal.
+    const liveRec = this.selectedAgentId
+      ? this.deps.agentManager.getStatus(this.selectedAgentId)
+      : null;
+    if (liveRec) {
+      const liveEntry = this._buildLiveOutputEntry(liveRec);
+      if (liveEntry) merged.push(liveEntry);
+    }
+
+    merged.sort((a, b) => a.timestamp - b.timestamp);
 
     // Deduplicate: bus messages that already appear in JSONL will have
     // approximate timestamps. We just show all — bus msgs tend to have
@@ -505,6 +536,45 @@ export class AgentInspectorPanel extends BasePanel {
     return result;
   }
 
+  /**
+   * Build a synthetic timeline entry exposing the selected agent's live model
+   * output. While the agent runs this is the streaming token buffer
+   * (tail-truncated like AgentDetailModal); once it terminates it is the final
+   * assistant text (expandable). Exactly one is produced — the SDK clears
+   * streamingContent on completion — so live and final rows never coexist.
+   * Returns null when there is nothing to show.
+   */
+  private _buildLiveOutputEntry(rec: AgentRecord): TimelineEntry | null {
+    const STREAM_MAX_CHARS = 500;
+    if (rec.status === 'running' && rec.streamingContent) {
+      const sc = rec.streamingContent;
+      const truncated = sc.length > STREAM_MAX_CHARS;
+      const tail = (truncated ? sc.slice(-STREAM_MAX_CHARS) : sc)
+        .replace(/\s+/g, ' ')
+        .trim();
+      return {
+        kind: 'assistant',
+        timestamp: Date.now(),
+        label: 'streaming',
+        content: `(live) ${truncated ? '…' : ''}${tail}`,
+        expanded: false,
+      } satisfies TimelineEntry;
+    }
+    if (AGENT_TERMINAL_STATUSES.has(rec.status) && rec.fullOutput) {
+      const fo = rec.fullOutput;
+      const firstLine = (fo.split('\n').find((l) => l.trim().length > 0) ?? '').trim();
+      return {
+        kind: 'assistant',
+        timestamp: rec.completedAt ?? Date.now(),
+        label: 'output',
+        content: `(final) ${firstLine}`,
+        detail: fo,
+        expanded: false,
+      } satisfies TimelineEntry;
+    }
+    return null;
+  }
+
   // -------------------------------------------------------------------------
   // Private — refresh
   // -------------------------------------------------------------------------

package/src/panels/agent-logs-panel.ts

@@ -29,8 +29,17 @@ import {
 const POLL_INTERVAL_MS = 500;
 
 export interface AgentLogsPanelDeps {
-  readonly agentManager: Pick<AgentManager, 'list'>;
+  readonly agentManager: Pick<AgentManager, 'list'> & Partial<Pick<AgentManager, 'getStatus'>>;
   readonly workingDirectory: string;
+  /**
+   * Request a compositor repaint. The 500ms poll timer, fs.watch callback and
+   * other async update paths call this (via markDirty) so new log lines and
+   * live streaming output are painted while the main thread is idle — render()
+   * is otherwise only invoked on input/turn/resize, which makes a running
+   * agent's log tail look frozen. Optional: when omitted the panel still marks
+   * dirty and repaints on the next event.
+   */
+  readonly requestRender?: () => void;
 }
 
 
@@ -47,12 +56,22 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
   private allEntries: LogEntry[] = []; // raw parsed JSONL for selected agent
   private filteredEntries: LogEntry[] = []; // after filter applied
   private lastFileSize = 0;
+  /**
+   * Length of the selected agent's live streamingContent buffer at the last
+   * poll. During an LLM turn the record's streamingContent grows token-by-token
+   * with NO JSONL append, so the file-size gate alone never repaints the live
+   * tail; we also watch this length and markDirty when it advances.
+   */
+  private lastStreamLen = 0;
 
   // ── Modes ────────────────────────────────────────────────────────────────
   private autoFollow = true;
   private paused = false;
   private filter: FilterType = 'all';
 
+  /** True while this panel is the active view — gates async repaint requests. */
+  private _active = false;
+
   // ── Infrastructure ───────────────────────────────────────────────────────
   private pollTimer: ReturnType<typeof setInterval> | null = null;
   private fsWatcher: FSWatcher | null = null;
@@ -81,12 +100,14 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
   // ── Lifecycle ─────────────────────────────────────────────────────────────
 
   override onActivate(): void {
+    this._active = true;
     super.onActivate();
     this._refreshAgents();
     this._pollCurrentAgent();
   }
 
   override onDeactivate(): void {
+    this._active = false;
     super.onDeactivate();
   }
 
@@ -95,6 +116,18 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
     this._unsubscribeEvents();
   }
 
+  /**
+   * T17: a bare markDirty() does not repaint — render() only runs on
+   * input/turn/resize. While active, ask the compositor for a frame so the
+   * background poll / fs.watch updates (new log lines, live streaming output)
+   * are not stuck off-screen. Gated on active state so the always-on poller
+   * does not force full-frame rebuilds while this panel is hidden.
+   */
+  protected override markDirty(): void {
+    super.markDirty();
+    if (this._active) this.deps.requestRender?.();
+  }
+
   // ── Input ─────────────────────────────────────────────────────────────────
 
   handleInput(key: string): boolean {
@@ -180,7 +213,17 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
       ]));
     }
 
-    if (this.filteredEntries.length === 0) {
+    // T13: surface the selected agent's live streaming output (running) or
+    // final output (terminal) — the per-turn JSONL tail never carries it. Pull
+    // the freshest record via getStatus so the streaming buffer reflects the
+    // current turn; the list() snapshot in this.agents only refreshes on
+    // spawn/complete/fail events, never mid-stream.
+    const liveAgent = selectedAgent
+      ? (this.deps.agentManager.getStatus?.(selectedAgent.id) ?? selectedAgent)
+      : null;
+    const liveLines = liveAgent ? this._buildLiveOutputLines(width, liveAgent) : [];
+
+    if (this.filteredEntries.length === 0 && liveLines.length === 0) {
       return buildPanelWorkspace(width, height, {
         title: ' Agents',
         intro: 'View-only live session stream for running agents, with per-agent switching and filtered event tails.',
@@ -202,9 +245,13 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
       });
     }
 
+    const scrollableLines = [
+      ...this.filteredEntries.map((entry) => this._renderEntry(entry, width)),
+      ...liveLines,
+    ];
     const focusIndex = this.autoFollow
-      ? Math.max(0, this.filteredEntries.length - 1)
-      : Math.min(this.selectedIndex, Math.max(0, this.filteredEntries.length - 1));
+      ? Math.max(0, scrollableLines.length - 1)
+      : Math.min(this.selectedIndex, Math.max(0, scrollableLines.length - 1));
     const summarySection = { title: 'Summary', lines: summaryLines } as const;
     const agentsSection = { title: 'Agents', lines: [selectorLine] } as const;
     const logStreamSection = resolveScrollablePanelSection(width, height, {
@@ -214,7 +261,7 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
       beforeSections: [summarySection, agentsSection],
       section: {
         title: 'Log Stream',
-        scrollableLines: this.filteredEntries.map((entry) => this._renderEntry(entry, width)),
+        scrollableLines,
         selectedIndex: focusIndex,
         scrollOffset: this.scrollStart,
         minRows: 8,
@@ -264,28 +311,50 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
     const agent = this._selectedAgent();
     if (!agent) return;
 
+    // Detect live streaming growth even when no JSONL is written this tick.
+    // During an LLM turn the record's streamingContent grows token-by-token
+    // with no session-log append, so the file-size gate below would never fire
+    // and the live tail (_buildLiveOutputLines) would never repaint.
+    let streamChanged = false;
+    const live = this.deps.agentManager.getStatus?.(agent.id);
+    if (live) {
+      const streamLen = (live.streamingContent ?? '').length;
+      if (streamLen !== this.lastStreamLen) {
+        this.lastStreamLen = streamLen;
+        streamChanged = true;
+      }
+    }
+
     const sessionFile = this._sessionFilePath(agent.id);
+    let fileExists = true;
     try {
       await fsPromises.access(sessionFile);
     } catch {
-      return;
+      fileExists = false;
     }
 
-    try {
-      const content = await fsPromises.readFile(sessionFile, 'utf-8');
-      if (content.length === this.lastFileSize) return;
-      this.lastFileSize = content.length;
-
-      // Re-parse all lines (simple: no partial-line tracking needed at 500ms)
-      this.allEntries = parseAgentJsonl(content);
-      this._applyFilter();
-      if (this.autoFollow) {
-        this.selectedIndex = Math.max(0, this.filteredEntries.length - 1);
+    if (fileExists) {
+      try {
+        const content = await fsPromises.readFile(sessionFile, 'utf-8');
+        if (content.length !== this.lastFileSize) {
+          this.lastFileSize = content.length;
+
+          // Re-parse all lines (simple: no partial-line tracking needed at 500ms)
+          this.allEntries = parseAgentJsonl(content);
+          this._applyFilter();
+          if (this.autoFollow) {
+            this.selectedIndex = Math.max(0, this.filteredEntries.length - 1);
+          }
+          this.markDirty();
+          return;
+        }
+      } catch {
+        // Non-fatal: file may be mid-write
       }
-      this.markDirty();
-    } catch {
-      // Non-fatal: file may be mid-write
     }
+
+    // File unchanged or absent, but the live stream advanced — repaint the tail.
+    if (streamChanged) this.markDirty();
   }
 
   // ── Private: fs.watch (supplemental) ─────────────────────────────────────
@@ -382,6 +451,7 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
     this.allEntries = [];
     this.filteredEntries = [];
     this.lastFileSize = 0;
+    this.lastStreamLen = 0;
     this.selectedIndex = 0;
     this.scrollStart = 0;
     this.autoFollow = true;
@@ -414,6 +484,7 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
       this.allEntries = [];
       this.filteredEntries = [];
       this.lastFileSize = 0;
+      this.lastStreamLen = 0;
       this.markDirty();
       return;
     }
@@ -545,6 +616,43 @@ export class AgentLogsPanel extends ScrollableListPanel<LogEntry> {
     return buildStyledPanelLine(width, [{ text: fullText, fg: entry.color, bold: entry.bold }]);
   }
 
+  /**
+   * Build trailing lines exposing the selected agent's live model output. The
+   * JSONL tail is written per-turn, so while an agent is mid-turn its actual
+   * work is invisible here; this surfaces the streaming token buffer
+   * (tail-truncated like AgentDetailModal) for a running agent, and the final
+   * assistant text once it terminates. Empty when there is nothing live to show.
+   */
+  private _buildLiveOutputLines(width: number, agent: AgentRecord): Line[] {
+    const STREAM_MAX_CHARS = 500;
+    if (agent.status === 'running' && agent.streamingContent) {
+      const sc = agent.streamingContent;
+      const truncated = sc.length > STREAM_MAX_CHARS;
+      const display = truncated ? sc.slice(-STREAM_MAX_CHARS) : sc;
+      const header = truncated
+        ? `  streaming (last ${STREAM_MAX_CHARS} of ${sc.length} chars):`
+        : '  streaming:';
+      const lines: Line[] = [
+        buildStyledPanelLine(width, [{ text: header, fg: COLOR.auto_follow, bold: true }]),
+      ];
+      for (const raw of display.split('\n')) {
+        lines.push(buildStyledPanelLine(width, [{ text: `    ${raw}`, fg: COLOR.assistant }]));
+      }
+      return lines;
+    }
+    if (agent.status !== 'running' && agent.status !== 'pending' && agent.fullOutput) {
+      const fo = agent.fullOutput;
+      const lines: Line[] = [
+        buildStyledPanelLine(width, [{ text: '  output:', fg: COLOR.header_accent, bold: true }]),
+      ];
+      for (const raw of fo.split('\n')) {
+        lines.push(buildStyledPanelLine(width, [{ text: `    ${raw}`, fg: COLOR.assistant }]));
+      }
+      return lines;
+    }
+    return [];
+  }
+
   private _agentStatusColor(status: AgentRecord['status']): string {
     switch (status) {
       case 'running': return COLOR.agent_running;

package/src/panels/base-panel.ts

@@ -142,7 +142,8 @@ export abstract class BasePanel implements Panel {
    */
   protected renderLoadingLine(width: number, frame = 0): Line | null {
     if (this.loadingState !== 'loading') return null;
-    const spinner = SPINNER_FRAMES[frame % SPINNER_FRAMES.length] ?? SPINNER_FRAMES[0]!;
+    const idx = (frame || Math.floor(Date.now() / 100)) % SPINNER_FRAMES.length;
+    const spinner = SPINNER_FRAMES[idx] ?? SPINNER_FRAMES[0]!;
     const text = ` ${spinner} ${this._loadingLabel}`;
     return UIFactory.stringToLine(fitDisplay(text, width), width, { fg: '135', bold: true });
   }