@pellux/goodvibes-tui 0.29.0 → 1.1.0

package/src/input/handler-content-actions.ts

@@ -121,10 +121,15 @@ export function registerPaste(
     }
   }
 
-  const lines = content.split('\n');
-  if (lines.length <= 8) return { marker: content, nextPasteId: state.nextPasteId, nextImageId: state.nextImageId };
+  // Terminals transmit the line breaks inside a bracketed paste as \r (the
+  // byte Enter sends), and external clipboards can carry \r\n. Normalize to
+  // \n only here in the text branch — the image sniffing above must see the
+  // raw bytes (PNG's magic sequence itself contains \r\n).
+  const text = content.replace(/\r\n?/g, '\n');
+  const lines = text.split('\n');
+  if (lines.length <= 8) return { marker: text, nextPasteId: state.nextPasteId, nextImageId: state.nextImageId };
   const id = `p${state.nextPasteId++}`;
-  state.pasteRegistry.set(id, content);
+  state.pasteRegistry.set(id, text);
   return { marker: `[TEXT: ${id}, ${lines.length} lines]`, nextPasteId: state.nextPasteId, nextImageId: state.nextImageId };
 }
 
@@ -422,6 +427,8 @@ export function handleCtrlC(
   lastCtrlCTime: number,
   setLastCtrlCTime: (value: number) => void,
   setShowExitNotice: (value: boolean) => void,
+  lastCtrlCTimeoutId: ReturnType<typeof setTimeout> | null,
+  setLastCtrlCTimeoutId: (value: ReturnType<typeof setTimeout> | null) => void,
 ): void {
   if (prompt.length > 0) {
     saveUndoState();
@@ -431,17 +438,29 @@ export function handleCtrlC(
   }
   cancelGeneration?.();
   const now = Date.now();
+  // Clear any hide-timer pending from a prior press before deciding this
+  // one's outcome, whichever branch below runs. Without this, a hide-timer
+  // scheduled by an earlier press could still fire after a newer notice
+  // window opened, or after exitApp() was just called (if exitApp isn't
+  // synchronous) — flipping showExitNotice/requestRender during a shutdown
+  // the user already believes is in progress.
+  if (lastCtrlCTimeoutId !== null) {
+    clearTimeout(lastCtrlCTimeoutId);
+    setLastCtrlCTimeoutId(null);
+  }
   if (now - lastCtrlCTime < 1000) {
     exitApp();
-  } else {
-    setLastCtrlCTime(now);
-    setShowExitNotice(true);
-    requestRender();
-    setTimeout(() => {
-      setShowExitNotice(false);
-      requestRender();
-    }, 1000);
+    return;
   }
+  setLastCtrlCTime(now);
+  setShowExitNotice(true);
+  requestRender();
+  const timeoutId = setTimeout(() => {
+    setShowExitNotice(false);
+    setLastCtrlCTimeoutId(null);
+    requestRender();
+  }, 1000);
+  setLastCtrlCTimeoutId(timeoutId);
 }
 
 export function handleClipboardPaste(

package/src/input/handler-feed-routes.ts

@@ -30,6 +30,15 @@ export type PanelFocusRouteState = {
   handlePathCompletion: () => boolean;
   cyclePanelTab: (direction: 'next' | 'prev') => void;
   onPanelInputConsumed?: (activePanel: import('../panels/types.ts').Panel | null, key: string) => void;
+  /**
+   * True when the tokens produced by the current feed() call carry more than
+   * one printable character total (a bracketed paste, or several 1-char text
+   * tokens from a fast-typed burst in one stdin chunk). A burst can never be
+   * a deliberate single-key panel hotkey, so it must not be exploded into
+   * per-char activePanel.handleInput(ch) calls — see the text-token branch
+   * below.
+   */
+  isPrintableBurst: boolean;
 };
 
 export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputToken): {
@@ -113,6 +122,19 @@ export function handlePanelFocusToken(state: PanelFocusRouteState, token: InputT
 
   if (token.type === 'text' && token.value) {
     const activePanel = state.panelManager.getActive();
+    // A burst (paste or several fast-typed chars in one stdin chunk) is never
+    // a deliberate single-key panel hotkey. Eating it silently as per-char
+    // hotkeys leaves the user with no echo and no error, looking exactly
+    // like dead keystrokes. Unless the active panel has its own text-capture
+    // buffer open (a `/`-search or draft-answer field that deliberately
+    // wants every character, burst or not — see isCapturingTextBurst), unfocus
+    // the panel and let the token fall through to the prompt route instead,
+    // same as it would from an unfocused panel.
+    if (state.isPrintableBurst && !activePanel?.isCapturingTextBurst?.()) {
+      panelFocused = false;
+      state.requestRender();
+      return { handled: false, panelFocused };
+    }
     if (activePanel?.handleInput) {
       for (const ch of token.value) {
         activePanel.handleInput(ch);
@@ -229,7 +251,15 @@ export function handlePromptTextToken(state: TextRouteState, token: InputToken):
     }
   }
 
-  if (prompt === '/' && state.commandRegistry) {
+  if (prompt === '/') {
+    // Arm commandMode as soon as the prompt becomes a bare '/', regardless of
+    // whether commandRegistry has been (re)attached yet — this is a one-shot
+    // transition (the only place commandMode ever becomes true), and gating
+    // it on commandRegistry meant a transient null during a modal/overlay
+    // handoff would permanently miss the window: every following keystroke
+    // is then processed as plain chat text with no way to recover. Dispatch
+    // (handleCommandModeToken, and the enter-key fallback below) still checks
+    // commandRegistry itself before actually running anything.
     commandMode = true;
     state.modalOpened('command');
     state.autocomplete?.update('');
@@ -257,6 +287,14 @@ export type KeyRouteState = {
   indicatorFocused: boolean;
   conversationManager: ConversationManager | null;
   commandContext: CommandContext | undefined;
+  /**
+   * Optional: only used by the enter-key desync safety net below (a stray
+   * slash-prefixed submission with commandMode somehow still false). When
+   * absent, that fallback simply doesn't trigger — the primary fix (arming
+   * commandMode on the '/' keystroke regardless of registry attachment, in
+   * handlePromptTextToken above) is what actually prevents the desync.
+   */
+  commandRegistry?: CommandRegistry | null;
   autocomplete: AutocompleteEngine | null;
   blockActionsMenu: { open: (block: BlockMeta) => void };
   processModal: { open: () => void };
@@ -351,6 +389,30 @@ export function handlePromptKeyToken(state: KeyRouteState, token: InputToken): {
       return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
     }
     if (text) {
+      // Safety net for a desynced commandMode: text is command-shaped (starts
+      // with '/') but commandMode never armed — e.g. the '/' keystroke landed
+      // during a modal/overlay handoff window. handleCommandModeToken (the
+      // normal dispatch path for '/name ...') never runs in this state since
+      // it early-returns when commandMode is false, so without this the text
+      // would fall straight through to submitInput as ordinary chat. Re-derive
+      // intent from the literal text instead of trusting commandMode alone.
+      if (!commandMode && text.startsWith('/') && state.commandRegistry && state.commandContext?.executeCommand) {
+        const parts = text.slice(1).trim().split(/\s+/);
+        const name = parts[0];
+        const args = parts.slice(1);
+        prompt = '';
+        cursorPos = 0;
+        if (name) {
+          const executeCommand = state.commandContext.executeCommand;
+          void executeCommand(name, args).then((handled) => {
+            if (!handled) {
+              state.commandContext?.submitInput?.(text);
+            }
+            state.requestRender();
+          });
+        }
+        return { handled: true, prompt, cursorPos, inputScrollTop, commandMode, indicatorFocused };
+      }
       const expanded = state.expandPrompt(text);
       const historyRecallText = typeof expanded === 'string'
         ? expanded

package/src/input/handler-feed.ts

@@ -180,6 +180,16 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
   const lineCount = history.getLineCount();
   const keybindings = context.keybindingsManager;
 
+  // A single stdin chunk can tokenize into several 'text' tokens (fast-typed
+  // burst) or one 'text' token with a multi-char value (bracketed paste).
+  // Computed once per feed() call, not per token, so per-token cost stays
+  // the same O(1) check it always was.
+  let totalPrintableChars = 0;
+  for (const t of tokens) {
+    if (t.type === 'text') totalPrintableChars += t.value.length;
+  }
+  const isPrintableBurst = totalPrintableChars > 1;
+
   for (const token of tokens) {
     if (token.type === 'key' && context.keybindingsManager.matches('clear-cancel', token)) {
       context.handleCtrlC();
@@ -320,6 +330,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
       panelManager: context.panelManager,
       keybindingsManager: context.keybindingsManager,
       onPanelInputConsumed: context.onPanelInputConsumed,
+      isPrintableBurst,
     }, token);
     context.panelFocused = panelRoute.panelFocused;
     if (panelRoute.handled) {
@@ -408,6 +419,7 @@ export function feedInputTokens(context: InputFeedContext, tokens: readonly Inpu
         indicatorFocused: context.indicatorFocused,
         conversationManager: context.conversationManager,
         commandContext: context.commandContext,
+        commandRegistry: context.commandRegistry,
         autocomplete: context.autocomplete,
         blockActionsMenu: { open: (block: BlockMeta) => context.blockActionsMenu.open(block) },
         processModal: context.processModal,

package/src/input/handler-interactions.ts

@@ -193,6 +193,8 @@ export function handleCtrlCForHandler(handler: InputHandler): void {
       handler.lastCtrlCTime,
       (value) => { handler.lastCtrlCTime = value; },
       (value) => { handler.showExitNotice = value; },
+      handler.lastCtrlCTimeoutId,
+      (value) => { handler.lastCtrlCTimeoutId = value; },
     );
   }
 

package/src/input/handler-types.ts

@@ -88,6 +88,7 @@ export interface InputHandlerLike {
   lastCopyTime: number;
   lastBlockCopyTime: number;
   lastCtrlCTime: number;
+  lastCtrlCTimeoutId: ReturnType<typeof setTimeout> | null;
 
   // ── Modal state ───────────────────────────────────────────────────────────
   commandMode: boolean;

package/src/input/handler.ts

@@ -172,6 +172,10 @@ export class InputHandler implements InputHandlerLike {
   public pasteRegistry = new Map<string, string>();
   public nextPasteId = 1;
   public lastCtrlCTime = 0;
+  /** Pending "hide the exit notice" timer from the last empty-prompt Ctrl+C
+   * press, if any — cleared before every subsequent press decides its own
+   * outcome (see handleCtrlC in handler-content-actions.ts). */
+  public lastCtrlCTimeoutId: ReturnType<typeof setTimeout> | null = null;
   /** Long-lived feed context — reused across every feed() call to avoid per-keystroke allocation. */
   public feedContext!: import('./handler-feed.ts').InputFeedContext;
   public commandRegistry: CommandRegistry | null = null;

package/src/input/input-history.ts

@@ -351,15 +351,28 @@ export class InputHistory {
     return redactedText;
   }
 
+  /**
+   * Entries persisted before CR normalization was deployed (registerPaste now
+   * converts the \r line separators terminals send in bracketed pastes to \n)
+   * may still carry literal \r bytes; launder them on load so history recall
+   * cannot reintroduce \r into the composer.
+   */
+  private launderLineBreaks(text: string): string {
+    return text.replace(/\r\n?/g, '\n');
+  }
+
   private normalizeStoredEntry(entry: unknown): StoredInputHistoryEntry | null {
-    if (typeof entry === 'string') return entry;
+    if (typeof entry === 'string') return this.launderLineBreaks(entry);
     if (!entry || typeof entry !== 'object') return null;
     const record = entry as Record<string, unknown>;
     if (typeof record.text !== 'string') return null;
-    const text = record.text.trim();
+    const text = this.launderLineBreaks(record.text).trim();
     if (!text) return null;
-    if (typeof record.recallText === 'string' && record.recallText.trim() && record.recallText.trim() !== text) {
-      return { text, recallText: record.recallText.trim() };
+    const recallText = typeof record.recallText === 'string'
+      ? this.launderLineBreaks(record.recallText).trim()
+      : '';
+    if (recallText && recallText !== text) {
+      return { text, recallText };
     }
     return text;
   }

package/src/main.ts

@@ -24,6 +24,7 @@ import { GitStatusProvider } from './renderer/git-status.ts';
 import type { GitHeaderInfo } from './renderer/git-status.ts';
 import { createShellLayout } from './renderer/layout-engine.ts';
 import { buildShellFooter, estimateShellFooterHeight } from './renderer/shell-surface.ts';
+import { computePromptContentWidth } from './renderer/prompt-content-width.ts';
 import { buildConversationViewport } from './renderer/conversation-layout.ts';
 import { applyConversationOverlays } from './renderer/conversation-overlays.ts';
 import { buildPanelCompositeData } from './renderer/panel-composite.ts';
@@ -53,6 +54,7 @@ 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 { createRenderScheduler } from './runtime/render-scheduler.ts';
 import { buildCommandArgsHint } from './input/command-args-hint.ts';
 import { summarizeRunningAgents } from './renderer/process-summary.ts';
 import { formatUserFacingErrorLine } from './core/format-user-error.ts';
@@ -128,13 +130,9 @@ async function main() {
     }
   }
 
-  // TUI default: show token speed ON. The SDK schema default is false;
-  // applyRuntimeConfigDefault reads both the global settings file and the project
-  // settings file from disk before deciding whether to apply the default. If the
-  // user has explicitly set this key to false in EITHER their global or project
-  // persisted config, their value is respected and the default is NOT applied.
-  // Only when the key is absent from both files (e.g. a new install) does the
-  // TUI default of true take effect in-memory — no disk write occurs either way.
+  // TUI default: show token speed ON (SDK schema default is false). applyRuntimeConfigDefault
+  // reads the global + project settings files and only applies the default in-memory when the
+  // key is absent from both (e.g. a new install); an explicit user value is respected. No disk write.
   applyRuntimeConfigDefault(configManager, 'display.showTokenSpeed', true);
 
   const panelManager = ctx.services.panelManager;
@@ -178,21 +176,21 @@ async function main() {
     ttftRecorded: false,
     activeToolStartedAtMs: undefined,
     activeToolName: undefined,
+    lastDeltaAtMs: undefined, stallEpisode: 0,
+    reconnectAttempt: undefined, reconnectMaxAttempts: undefined,
   };
 
-  const getPromptContentWidth = () => {
-    const w = stdout.columns || 80;
-    const boxMargin = 2;
-    const boxWidth = w - (boxMargin * 2);
-    return boxWidth - 4 - 3; // minus padding (4) minus prefix width (3: ' > ')
-  };
+  const getPromptContentWidth = () => computePromptContentWidth(stdout.columns);
 
   const getViewportHeight = (): number => {
     if (input.onboardingWizard.active) return stdout.rows || 24;
     const promptLines: number = input.getVisiblePromptLineCount(getPromptContentWidth());
     const currentModel = providerRegistry.getCurrentModel();
     const contextWindow = providerRegistry.getContextWindowForModel(currentModel);
-    return (stdout.rows || 24) - 2 - estimateShellFooterHeight(promptLines, contextWindow);
+    const rows = stdout.rows || 24;
+    // Compact threshold must match buildShellFooter's `compact: height < 30` posture below,
+    // else estimateShellFooterHeight's cached-height fast path answers with the wrong mode.
+    return rows - 2 - estimateShellFooterHeight(promptLines, contextWindow, rows < 30);
   };
 
   const scroll = (delta: number) => {
@@ -223,7 +221,7 @@ async function main() {
     noAltScreen: cli.flags.noAltScreen,
     ansi: { CLEAR_SCREEN, ALT_SCREEN_EXIT, PASTE_DISABLE, KEYBOARD_EXT_DISABLE, MOUSE_DISABLE, CURSOR_SHOW },
     getInput: () => input,
-    render: () => render(),
+    render: () => renderScheduler.flushNow(), // resize: synchronous immediate path
     getPromptContentWidth,
     getTerminalOutputGuard: () => terminalOutputGuard,
     buildSessionContinuityHints,
@@ -346,6 +344,7 @@ async function main() {
     allowTerminalWrite(() => stdout.write(CLEAR_SCREEN));
     render();
   };
+  commandContext.requestFullRepaint = () => { compositor.resetDiff(); render(); };
   permissionPromptRef.requestPermission = (request) =>
     new Promise((resolve) => {
       pendingPermission = {
@@ -432,7 +431,7 @@ async function main() {
     lastSessionId: readLastSessionPointer({ workingDirectory: workingDir, homeDirectory, surfaceRoot: 'tui' }) ?? undefined,
   };
 
-  const render = () => {
+  const renderNow = () => {
     const width = stdout.columns || 80;
     const height = stdout.rows || 24;
 
@@ -512,6 +511,8 @@ async function main() {
       hitlMode: modeManager.getHITLMode(),
       runningAgentCount,
       runningProcessCount,
+      // Composer must not read as focused while the panel/process indicator owns keyboard focus.
+      promptFocused: !input.panelFocused && !input.indicatorFocused,
       indicatorFocused: input.indicatorFocused,
       runningAgentProgress: runningAgentSummary.progress,
       composerMode: composerState.modeLabel,
@@ -582,6 +583,8 @@ async function main() {
       const partialToolPreview = showPreview ? sessionSnapshot.streamToolPreview : undefined;
       // Elapsed from turn start (stream or tool execution), used for the thinking indicator timer.
       const turnElapsedMs = streamMetrics.startTime > 0 ? Date.now() - streamMetrics.startTime : undefined;
+      // Suppressed while a tool executes — its ticking timer is the honest indicator then.
+      const stallInfo = UIFactory.computeRenderStallInfo(streamMetrics, Date.now());
       const thinking = UIFactory.createThinkingFragment(
         conversationWidth,
         orchestrator.getSpinner(),
@@ -592,6 +595,7 @@ async function main() {
         orchestrator.streamingOutputTokens > 0 ? orchestrator.streamingOutputTokens : undefined,
         turnElapsedMs,
         streamMetrics.ttftMs,
+        stallInfo,
       );
       viewport.push(...thinking);
       // Live tool timer: render the currently executing tool row with ticking elapsed.
@@ -648,9 +652,11 @@ async function main() {
       panelWidth: panelComposite.panelWidth,
     });
   };
+  const renderScheduler = createRenderScheduler(renderNow); // WO-208 same-tick coalescer
+  const render = (): void => renderScheduler.schedule();
   const terminalOutputGuard = installTuiTerminalOutputGuard({ stdout, stderr: process.stderr, notify: (message) => { systemMessageRouter.low(message); render(); } });
 
-  setRenderRequest(render);
+  setRenderRequest(renderNow); // bootstrap's 16ms coalescer calls the composite directly
   orchestratorRefs.requestRender = render;
   commandContext.renderRequest = render;
   wireShellUiOpeners({
@@ -694,9 +700,8 @@ async function main() {
 
   // Stable turn context for failover retry — set in submitInput, read by retryTurn.
   let retryCtx: { count: number; text: string; content?: ContentPart[]; opts?: Parameters<typeof orchestrator.handleUserInput>[2] } | null = null;
-  // One-key retry affordance: active immediately after a user-visible TURN_ERROR.
-  // While active, 'r' re-submits on the current provider, 'm' opens the model
-  // picker. Any other character clears the affordance and routes normally.
+  // One-key retry affordance, active right after a user-visible TURN_ERROR: 'r' re-submits on the
+  // current provider, 'm' opens the model picker, any other character clears it and routes normally.
   let errorAffordanceActive = false;
   const retryTurn = (): void => {
     if (!retryCtx) return;
@@ -720,9 +725,8 @@ 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.
+  // Register terminal-restoring crash/termination handlers BEFORE entering raw mode so a throw
+  // during setup or the initial render still restores the terminal; 'exit' is the final safety net.
   process.on('uncaughtException', uncaughtExceptionHandler);
   process.on('SIGTERM', terminationSignalHandler);
   process.on('SIGHUP', terminationSignalHandler);

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

@@ -1,5 +1,5 @@
 import { formatDuration } from '../utils/format-duration.ts';
-import { calcSessionCost } from '../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
 import type { AgentEvent } from '@/runtime/index.ts';
 import type { UiEventFeed } from '../runtime/ui-events.ts';
 
@@ -171,6 +171,8 @@ export function formatAgentCost(usd: number): string {
 export interface AgentUsageSummary {
   readonly tokens: number;
   readonly cost: number;
+  /** False when the model never resolved to a real price — `cost` is a zero placeholder, not a real reading. */
+  readonly priced: boolean;
 }
 
 interface AgentUsageLike {
@@ -183,22 +185,43 @@ interface AgentUsageLike {
   readonly model?: string | null;
 }
 
+/**
+ * True when a usage object carries actual reported token data rather than
+ * being present-but-empty. W0.9: the SDK's AgentRecord.usage is initialised
+ * to an all-zero object at agent spawn (platform/tools/agent/manager.ts) and
+ * — in the currently pinned SDK version — is never updated past that, so a
+ * plain truthiness check on `rec.usage` treats every agent, including ones
+ * that did real work, as "has data" and renders a fabricated $0.00/0-token
+ * reading. Guarding on real (nonzero) counts instead keeps today's "n/a"
+ * honest and lights up automatically once a future SDK actually populates
+ * usage — no further TUI change needed.
+ */
+export function hasReportedUsage(
+  usage: AgentUsageLike['usage'],
+): usage is NonNullable<AgentUsageLike['usage']> {
+  if (!usage) return false;
+  return usage.inputTokens > 0 || usage.outputTokens > 0
+    || (usage.cacheReadTokens ?? 0) > 0 || (usage.cacheWriteTokens ?? 0) > 0;
+}
+
 /**
  * Total token count + cost for an agent record's usage, or null when no usage
  * data has landed yet (honest-UX: never fabricate a $0.00/0-token reading for
  * an agent that simply hasn't reported usage).
  */
 export function summarizeAgentUsage(rec: AgentUsageLike): AgentUsageSummary | null {
-  if (!rec.usage) return null;
-  const inputTokens = rec.usage.inputTokens + (rec.usage.cacheReadTokens ?? 0) + (rec.usage.cacheWriteTokens ?? 0);
+  if (!hasReportedUsage(rec.usage)) return null;
+  const usage = rec.usage;
+  const model = rec.model ?? 'unknown';
+  const inputTokens = usage.inputTokens + (usage.cacheReadTokens ?? 0) + (usage.cacheWriteTokens ?? 0);
   const cost = calcSessionCost(
-    rec.usage.inputTokens,
-    rec.usage.outputTokens,
-    rec.usage.cacheReadTokens ?? 0,
-    rec.usage.cacheWriteTokens ?? 0,
-    rec.model ?? 'unknown',
+    usage.inputTokens,
+    usage.outputTokens,
+    usage.cacheReadTokens ?? 0,
+    usage.cacheWriteTokens ?? 0,
+    model,
   );
-  return { tokens: inputTokens + rec.usage.outputTokens, cost };
+  return { tokens: inputTokens + usage.outputTokens, cost, priced: isModelPriced(model) };
 }
 
 // ---------------------------------------------------------------------------
@@ -226,7 +249,7 @@ export function buildWrfcCostSegments(
     segments.push([segments.length > 0 ? '   Tokens ' : ' Tokens ', palette.label]);
     segments.push([formatTokens(usage.tokens), palette.info]);
     segments.push(['   Cost ', palette.label]);
-    segments.push([formatAgentCost(usage.cost), palette.info]);
+    segments.push([usage.priced ? formatAgentCost(usage.cost) : 'unpriced', palette.info]);
   }
   return segments.length > 0 ? segments : null;
 }

package/src/panels/base-panel.ts

@@ -3,7 +3,7 @@ import type { Panel, PanelCategory } from './types.ts';
 import type { ComponentResourceContract, ComponentHealthState } from '../runtime/perf/panel-contracts.ts';
 import type { ComponentHealthMonitor } from '../runtime/perf/panel-health-monitor.ts';
 import { UIFactory } from '../renderer/ui-factory.ts';
-import { SPINNER_FRAMES } from '../renderer/progress.ts';
+import { SPINNER_FRAMES } from '../renderer/ui-primitives.ts';
 import { fitDisplay } from '../utils/terminal-width.ts';
 
 /** Canonical error-surface foreground (bad/red), kept out of the render body. */

package/src/panels/builtin/development.ts

@@ -46,7 +46,7 @@ export function registerDevelopmentPanels(manager: PanelManager, deps: ResolvedB
     icon: 'D',
     category: 'development',
     description: 'Unified diff view of agent file changes',
-    factory: () => new DiffPanel(requireUiServices(deps).environment.workingDirectory),
+    factory: () => new DiffPanel(requireUiServices(deps).environment.workingDirectory, deps.requestRender),
   });
 
   // WO-110: 'inspector' registration moved to builtin/agent.ts (category

package/src/panels/cockpit-read-model.ts

@@ -20,11 +20,12 @@
 
 import type { AgentRecord } from '@pellux/goodvibes-sdk/platform/tools';
 import { truncateDisplay } from '../utils/terminal-width.ts';
-import { calcSessionCost } from '../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
 import {
   AGENT_TERMINAL_STATUSES,
   AGENT_STALL_THRESHOLD_MS,
   countStalledAgents,
+  hasReportedUsage,
 } from './agent-inspector-shared.ts';
 
 // ---------------------------------------------------------------------------
@@ -114,24 +115,28 @@ export function buildCockpitRosterSnapshot(
     let outputTokens: number | null = null;
     let cost: number | null = null;
 
-    if (rec.usage) {
+    if (hasReportedUsage(rec.usage)) {
       hasUsage = true;
+      const usage = rec.usage;
       const inp =
-        rec.usage.inputTokens +
-        (rec.usage.cacheReadTokens ?? 0) +
-        (rec.usage.cacheWriteTokens ?? 0);
-      const out = rec.usage.outputTokens;
+        usage.inputTokens +
+        (usage.cacheReadTokens ?? 0) +
+        (usage.cacheWriteTokens ?? 0);
+      const out = usage.outputTokens;
       const agentCost = calcSessionCost(
-        rec.usage.inputTokens,
-        rec.usage.outputTokens,
-        rec.usage.cacheReadTokens ?? 0,
-        rec.usage.cacheWriteTokens ?? 0,
+        usage.inputTokens,
+        usage.outputTokens,
+        usage.cacheReadTokens ?? 0,
+        usage.cacheWriteTokens ?? 0,
         rec.model ?? 'unknown',
       );
 
       inputTokens = inp;
       outputTokens = out;
-      cost = agentCost;
+      // Usage exists but the model never resolved to a real price — reuse the
+      // existing "usage absent" null/n-a convention rather than showing a
+      // fabricated $0.00 (WO-315).
+      cost = isModelPriced(rec.model ?? 'unknown') ? agentCost : null;
 
       totalInputTokens += inp;
       totalOutputTokens += out;

package/src/panels/cost-tracker-panel.ts

@@ -22,13 +22,15 @@ import {
   DEFAULT_PANEL_PALETTE,
   type PanelWorkspaceSection,
 } from './polish.ts';
-import { calcSessionCost } from '../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
 import { abbreviateCount } from '../utils/format-number.ts';
 import { isTextBackspace } from '../input/delete-key-policy.ts';
 
 // Pricing lookups are provided by ../export/cost-utils.ts (single source of truth).
 
-function formatCost(usd: number): string {
+/** unpriced=true renders an honest "unpriced" marker instead of a $0.00 that could be mistaken for a real zero cost. */
+function formatCost(usd: number, unpriced = false): string {
+  if (unpriced) return 'unpriced';
   if (usd === 0) return '$0.00';
   if (usd < 0.0001) return '<$0.0001';
   if (usd < 0.01) return `$${usd.toFixed(4)}`;
@@ -314,6 +316,16 @@ export class CostTrackerPanel extends BasePanel {
   // Input
   // -------------------------------------------------------------------------
 
+  /**
+   * The budget-threshold entry field wants every character of a burst
+   * (paste, or fast typing landing in one input.feed() call) delivered one
+   * at a time, same as it always has — see the interface doc on
+   * `Panel.isCapturingTextBurst`.
+   */
+  isCapturingTextBurst(): boolean {
+    return this.budgetEntry !== null;
+  }
+
   handleInput(key: string): boolean {
     if (this.budgetEntry !== null) return this.handleBudgetEntryInput(key);
 
@@ -395,7 +407,7 @@ export class CostTrackerPanel extends BasePanel {
     const sessionCost = calcSessionCost(this.sessionUsage.input, this.sessionUsage.output, this.sessionUsage.cacheRead, this.sessionUsage.cacheWrite, this.sessionModel);
     const overBudget = this.budgetThreshold > 0 && sessionCost > this.budgetThreshold;
     const sparkline = buildSparkline(this.costHistory);
-    const costStr = formatCost(sessionCost);
+    const costStr = formatCost(sessionCost, !isModelPriced(this.sessionModel));
     const costFg = overBudget ? C.bad : C.cost;
     const budgetStr = this.budgetThreshold > 0
       ? ` / ${formatCost(this.budgetThreshold)}`
@@ -451,10 +463,14 @@ export class CostTrackerPanel extends BasePanel {
       const planCost = agentList.reduce((sum, a) => sum + a.cost, 0);
       const running = agentList.filter((a) => a.status === 'running').length;
       const failed = agentList.filter((a) => a.status === 'failed').length;
+      // Plan total mixes the session model with every agent's model — flag it
+      // as unpriced (rather than showing a sum that silently omits unpriced
+      // agents' contribution) if any one of them has no real pricing.
+      const planHasUnpriced = !isModelPriced(this.sessionModel) || agentList.some((a) => !isModelPriced(a.model));
       const agentRows: Line[] = [
         buildStyledPanelLine(width, [
           { text: ' Plan total ', fg: C.label },
-          { text: formatCost(planCost + sessionCost), fg: C.cost, bold: true },
+          { text: formatCost(planCost + sessionCost, planHasUnpriced), fg: C.cost, bold: true },
           { text: `  ${agentList.length} agent${agentList.length === 1 ? '' : 's'}`, fg: C.dim },
           ...(running > 0 ? [{ text: `  ${running} running`, fg: C.running }] : []),
           ...(failed > 0 ? [{ text: `  ${failed} failed`, fg: C.bad }] : []),
@@ -483,7 +499,14 @@ export class CostTrackerPanel extends BasePanel {
                 { text: agent.model, fg: C.model },
                 { text: agent.inputTokens > 0 ? formatTokens(agent.inputTokens) : '-', fg: C.dim },
                 { text: agent.outputTokens > 0 ? formatTokens(agent.outputTokens) : '-', fg: C.dim },
-                { text: agent.cost > 0 ? formatCost(agent.cost) : '-', fg: agent.cost > 0 ? C.cost : C.dim },
+                {
+                  // '-' means no usage reported yet; 'unpriced' means usage
+                  // exists but the model has no real price; otherwise the cost.
+                  text: agent.inputTokens > 0 && !isModelPriced(agent.model)
+                    ? 'unpriced'
+                    : agent.cost > 0 ? formatCost(agent.cost) : '-',
+                  fg: agent.cost > 0 ? C.cost : C.dim,
+                },
               ],
             };
           }),