@pellux/goodvibes-tui 0.29.0 → 1.1.0

package/src/panels/debug-panel.ts

@@ -22,7 +22,7 @@ import {
 import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import { abbreviateCount } from '../utils/format-number.ts';
 import { formatLatencyMs } from '../utils/format-duration.ts';
-import { calcSessionCost } from '../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
 
 // ---------------------------------------------------------------------------
 // Types
@@ -97,7 +97,9 @@ function fmtAgo(ts: number): string {
   return `${Math.floor(sec / 3600)}h ago`;
 }
 
-function fmtUsd(value: number): string {
+/** unpriced=true renders an honest "unpriced" marker instead of a $0 that could be mistaken for a real zero cost. */
+function fmtUsd(value: number, unpriced = false): string {
+  if (unpriced) return 'unpriced';
   if (value <= 0) return '$0';
   return value >= 1 ? `$${value.toFixed(2)}` : `$${value.toFixed(4)}`;
 }
@@ -394,7 +396,7 @@ export class DebugPanel extends ScrollableListPanel<ApiCallEntry> {
         { text: fmtTok(entry.inputTokens), fg: C.input },
         { text: fmtTok(entry.outputTokens), fg: C.output },
         { text: fmtMs(entry.latencyMs), fg: latColor(entry.latencyMs) },
-        { text: fmtUsd(callCost(entry)), fg: C.value },
+        { text: fmtUsd(callCost(entry), !isModelPriced(entry.model)), fg: C.value },
       ],
       CALL_COLUMNS,
       { selected, selectedBg: C.selectBg },
@@ -498,7 +500,7 @@ export class DebugPanel extends ScrollableListPanel<ApiCallEntry> {
               { label: 'in', value: String(selected.inputTokens), valueColor: C.input },
               { label: 'out', value: String(selected.outputTokens), valueColor: C.output },
               { label: 'latency', value: fmtMs(selected.latencyMs), valueColor: latColor(selected.latencyMs) },
-              { label: 'cost', value: fmtUsd(callCost(selected)), valueColor: C.value },
+              { label: 'cost', value: fmtUsd(callCost(selected), !isModelPriced(selected.model)), valueColor: C.value },
             ], C),
             ...(selected.errorMessage
               ? buildBodyText(width, selected.errorMessage, C, C.bad)
@@ -573,6 +575,10 @@ export class DebugPanel extends ScrollableListPanel<ApiCallEntry> {
       : 0;
     const sessionTokens = this._calls.reduce((s, c) => s + c.inputTokens + c.outputTokens, 0);
     const sessionCost = this._calls.reduce((s, c) => s + callCost(c), 0);
+    // Only flag the aggregate as unpriced when every call is — a partial mix
+    // still sums the priced calls honestly; only the fully-unpriced case
+    // would otherwise render as a misleading $0.
+    const sessionAllUnpriced = this._calls.length > 0 && this._calls.every((c) => !isModelPriced(c.model));
 
     const lines: Line[] = [
       buildStyledPanelLine(width, [
@@ -587,7 +593,7 @@ export class DebugPanel extends ScrollableListPanel<ApiCallEntry> {
         { text: '   Tokens ', fg: C.label },
         { text: fmtTok(sessionTokens), fg: C.value },
         { text: '   Cost ', fg: C.label },
-        { text: fmtUsd(sessionCost), fg: C.value },
+        { text: fmtUsd(sessionCost, sessionAllUnpriced), fg: C.value },
       ]),
     ];
     // Live status: most recent call (latency / age) or wiring hint.

package/src/panels/diff-panel.ts

@@ -5,8 +5,9 @@
 import type { Line } from '../types/grid.ts';
 import { createStyledCell, createEmptyLine } from '../types/grid.ts';
 import { truncateDisplay, getDisplayWidth } from '../utils/terminal-width.ts';
+import { GitService } from '@pellux/goodvibes-sdk/platform/git';
 import { BasePanel } from './base-panel.ts';
-import { UI_TONES } from '../renderer/ui-primitives.ts';
+import { UI_TONES, DIFF_TONES } from '../renderer/ui-primitives.ts';
 import { FilePreviewPanel } from './file-preview-panel.ts';
 import type { PanelIntegrationContext } from './types.ts';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
@@ -30,14 +31,20 @@ import {
 // DEFAULT_PANEL_PALETTE.headerBg (WO-002: one title band everywhere).
 // ---------------------------------------------------------------------------
 
-const HUNK_BLUE = '#88aaff';
+// Hunk blue is the shared DIFF_TONES token (WO-204) — diff-view.ts (conversation)
+// and git-panel.ts's inline diff converge onto this file's pre-existing value.
+const HUNK_BLUE: string = DIFF_TONES.hunk;
 // Context rows and line-number gutter use the shared theme's muted/dim
 // foreground tones rather than dedicated gray hex literals.
 const CONTEXT_GRAY = UI_TONES.fg.muted;
 const FILENAME_WHITE = '#ffffff';
-const ADD_GREEN = '#00ff88';
+// Add/del text colors are the shared DIFF_TONES tokens, whose values ARE this
+// panel's shipped colors — this panel is the reference diff look (diff-view
+// was unwired dead code until WO-204, so "majority of surfaces" was a mirage);
+// the conversation surface converges onto these, not the reverse.
+const ADD_GREEN: string = DIFF_TONES.add;
 const ADD_BG = '#001a0d';
-const DEL_RED = '#ff4444';
+const DEL_RED: string = DIFF_TONES.del;
 const DEL_BG = '#1a0000';
 const HUNK_BG = '#0a0a1a';
 const MARKER_GRAY = '#aaaaaa';
@@ -160,20 +167,49 @@ function parseDiff(raw: string): ParsedLine[] {
 // Split a full `git diff` output into per-file entries
 // ---------------------------------------------------------------------------
 
+/**
+ * Synthetic placeholder entries ('(error)', '(no changes)', '(no staged
+ * changes)', '(not a git repo)') are not real diffs — parenthesized so they
+ * can be styled distinctly in the tab/status bar instead of reading as a fake
+ * diff of a real file.
+ */
+function isPlaceholderPath(filePath: string): boolean {
+  return filePath.startsWith('(') && filePath.endsWith(')');
+}
+
+/**
+ * Extract the file path from one `diff --git`-delimited chunk. Tries, in
+ * order: the standard two-sided header (`diff --git a/x b/y`, bare or
+ * quoted), the combined/merge-conflict header (`diff --cc <path>` /
+ * `diff --combined <path>`, which carries no a/b prefixes), then falls back
+ * to the `+++`/`---` file lines (present across every variant, uniformly) —
+ * skipping a `/dev/null` side (deleted/new file). 'unknown' is reserved for
+ * genuinely unparseable input.
+ */
+function extractDiffFilePath(trimmed: string): string {
+  const quotedGit = trimmed.match(/^diff --git "a\/(.+)" "b\/(.+)"$/m);
+  if (quotedGit) return quotedGit[2]!;
+  const plainGit = trimmed.match(/^diff --git a\/.+? b\/(.+)$/m);
+  if (plainGit) return plainGit[1]!;
+  const combined = trimmed.match(/^diff --(?:cc|combined) "?([^"\n]+?)"?$/m);
+  if (combined) return combined[1]!;
+  const plus = trimmed.match(/^\+\+\+ (?:b\/)?"?([^"\n]+?)"?\s*$/m);
+  if (plus && plus[1] !== '/dev/null') return plus[1]!;
+  const minus = trimmed.match(/^--- (?:a\/)?"?([^"\n]+?)"?\s*$/m);
+  if (minus && minus[1] !== '/dev/null') return minus[1]!;
+  return 'unknown';
+}
+
 function splitIntoDiffEntries(raw: string): DiffEntry[] {
   const entries: DiffEntry[] = [];
-  // Split on "diff --git" lines
-  const chunks = raw.split(/(?=^diff --git )/m);
+  // Split on "diff --git" / "diff --cc" / "diff --combined" lines
+  const chunks = raw.split(/(?=^diff --git |^diff --cc |^diff --combined )/m);
   for (const chunk of chunks) {
     const trimmed = chunk.trim();
     if (!trimmed) continue;
 
-    // Extract file path from "diff --git a/foo b/foo"
-    const match = trimmed.match(/^diff --git a\/.+? b\/(.+)$/m);
-    const filePath = match ? match[1]! : 'unknown';
-
     entries.push({
-      filePath,
+      filePath: extractDiffFilePath(trimmed),
       raw: chunk,
       lines: parseDiff(chunk),
     });
@@ -229,7 +265,15 @@ export class DiffPanel extends BasePanel {
   /** Set by the 'o' key; consumed by handlePanelIntegrationAction on the next dispatch. */
   private pendingOpenPreview = false;
 
-  constructor(workingDirectory: string) {
+  /** One-line confirmation for the 'w'/'h'/'s' self-load hotkeys — otherwise a
+   * reload that produces identical content is visually indistinguishable
+   * from the keypress doing nothing at all. */
+  private hotkeyStatus: string | null = null;
+
+  constructor(
+    workingDirectory: string,
+    private readonly requestRender: () => void = () => {},
+  ) {
     super('diff', 'Diff', 'D', 'development');
     this.workingDirectory = workingDirectory;
   }
@@ -265,12 +309,33 @@ export class DiffPanel extends BasePanel {
     this.markDirty();
   }
 
+  /**
+   * Defensive gate mirroring GitPanel's own notGitRepo messaging — short-
+   * circuits before any of this panel's self-load git spawns run, instead of
+   * letting git fail per-subcommand with an inconsistent error shape.
+   */
+  private showNotGitRepo(): void {
+    this.showDiff('(not a git repo)', '@@ -0,0 +0,0 @@\n Not a git repository here.');
+  }
+
   /** Run `git diff` against specific files and populate entries. */
   async showFileDiffs(files: string[], ref?: string): Promise<void> {
+    if (!GitService.isGitRepo(this.workingDirectory)) {
+      this.showNotGitRepo();
+      return;
+    }
     const args = ['diff', ...(ref ? [ref] : []), '--', ...files];
-    const proc = Bun.spawn(['git', ...args], { stdout: 'pipe', cwd: this.workingDirectory });
-    const raw = await new Response(proc.stdout).text();
-    await proc.exited;
+    const proc = Bun.spawn(['git', ...args], { stdout: 'pipe', stderr: 'pipe', cwd: this.workingDirectory });
+    const [raw, errText] = await Promise.all([
+      new Response(proc.stdout).text(),
+      new Response(proc.stderr).text(),
+    ]);
+    const exitCode = await proc.exited;
+    if (exitCode !== 0) {
+      const errorText = errText.trim() || 'git diff failed';
+      this.showDiff('(error)', `--- error\n+++ error\n@@ -0,0 +1,1 @@\n+${errorText}`);
+      return;
+    }
     this.loadRawDiff(raw);
     this.enrichSemanticDiffs(files, ref ?? 'HEAD').catch((err) => { logger.debug('DiffPanel: semantic diff enrichment failed', { err }); });
   }
@@ -281,6 +346,10 @@ export class DiffPanel extends BasePanel {
    * enriches every loaded file with a semantic-diff summary in the background.
    */
   async showGitDiff(ref?: string): Promise<void> {
+    if (!GitService.isGitRepo(this.workingDirectory)) {
+      this.showNotGitRepo();
+      return;
+    }
     const args = ['diff', ...(ref ? [ref] : [])];
     const proc = Bun.spawn(['git', ...args], { stdout: 'pipe', stderr: 'pipe', cwd: this.workingDirectory });
     const [raw, errText] = await Promise.all([
@@ -319,6 +388,10 @@ export class DiffPanel extends BasePanel {
    * `/diff staged` command handler.
    */
   async showStagedDiff(): Promise<void> {
+    if (!GitService.isGitRepo(this.workingDirectory)) {
+      this.showNotGitRepo();
+      return;
+    }
     const proc = Bun.spawn(['/bin/sh', '-c', 'git diff --cached'], { stdout: 'pipe', stderr: 'pipe', cwd: this.workingDirectory });
     const [raw, errText] = await Promise.all([
       new Response(proc.stdout).text(),
@@ -347,7 +420,7 @@ export class DiffPanel extends BasePanel {
     if (files.length === 0) return;
     const { computeSemanticDiff, formatSemanticDiffSummary } = await import('../renderer/semantic-diff.ts');
     const { join, relative: pathRelative } = await import('path');
-    const repoRootProc = Bun.spawn(['git', 'rev-parse', '--show-toplevel'], { stdout: 'pipe', cwd: this.workingDirectory });
+    const repoRootProc = Bun.spawn(['git', 'rev-parse', '--show-toplevel'], { stdout: 'pipe', stderr: 'pipe', cwd: this.workingDirectory });
     await repoRootProc.exited;
     const repoRoot = (await new Response(repoRootProc.stdout).text()).trim() || this.workingDirectory;
     await Promise.allSettled(
@@ -412,6 +485,22 @@ export class DiffPanel extends BasePanel {
   // Input
   // -------------------------------------------------------------------------
 
+  /**
+   * Wraps a self-load hotkey ('w'/'h'/'s') with visible before/after status
+   * text in the status bar — otherwise a reload whose content is unchanged
+   * from what's already shown is indistinguishable from the keypress having
+   * done nothing at all (contrast with `/diff working`'s ctx.print() calls).
+   */
+  private runHotkeyReload(label: string, load: () => Promise<void>): void {
+    this.hotkeyStatus = `Loading ${label} diff…`;
+    this.markDirty();
+    void load().then(() => {
+      this.hotkeyStatus = `Reloaded ${label} diff.`;
+      this.markDirty();
+      this.requestRender();
+    });
+  }
+
   handleInput(key: string): boolean {
     switch (key) {
       case 'up':    this.scrollUp();   return true;
@@ -427,9 +516,9 @@ export class DiffPanel extends BasePanel {
       case 'backtab': this.prevFile(); return true;
       case 'pageup':   this.scrollPageUp();   return true;
       case 'pagedown': this.scrollPageDown(); return true;
-      case 'w': void this.showGitDiff();       return true;
-      case 'h': void this.showGitDiff('HEAD'); return true;
-      case 's': void this.showStagedDiff();    return true;
+      case 'w': this.runHotkeyReload('working tree', () => this.showGitDiff());       return true;
+      case 'h': this.runHotkeyReload('HEAD',         () => this.showGitDiff('HEAD')); return true;
+      case 's': this.runHotkeyReload('staged',       () => this.showStagedDiff());    return true;
       case 'o': {
         if (!this.currentEntry()) return false;
         this.pendingOpenPreview = true;
@@ -617,11 +706,15 @@ export class DiffPanel extends BasePanel {
     for (let i = 0; i < this.entries.length; i++) {
       const entry = this.entries[i]!;
       const active = i === this.selectedFile;
+      const placeholder = isPlaceholderPath(entry.filePath);
       const stat = diffStat(entry);
-      const fg = active ? COLOR.tabActive : COLOR.tabInactive;
+      // Placeholder entries ('(error)', '(no changes)', ...) get a distinct
+      // warn color regardless of active/inactive — they are not a real diff
+      // of a real file and must not read as one.
+      const fg = placeholder ? COLOR.warn : (active ? COLOR.tabActive : COLOR.tabInactive);
       const bg = active ? COLOR.tabActiveBg : COLOR.tabBg;
       // Active file gets a leading marker; every tab shows +adds/-dels at a glance.
-      const marker = active ? '▸ ' : '  ';
+      const marker = active ? '▸ ' : (placeholder ? '⚠ ' : '  ');
       const label = `${marker}${basename(entry.filePath)} `;
       for (const ch of label) push(ch, fg, bg, active);
       if (stat.added > 0) for (const ch of `+${stat.added}`) push(ch, COLOR.addition, bg, active);
@@ -644,11 +737,15 @@ export class DiffPanel extends BasePanel {
       return buildStyledPanelLine(width, [{ text: ' No file', fg: COLOR.tabInactive, bg: COLOR.statusBar }], { fillBg: COLOR.statusBar });
     }
     const stat = diffStat(entry);
+    const placeholder = isPlaceholderPath(entry.filePath);
     // Keep the file path display-width-aware so a long/wide path can't overflow.
     const pathBudget = Math.max(8, Math.floor(width / 2));
     const fileInfo = truncateDisplay(entry.filePath, pathBudget);
     const segments: Array<{ text: string; fg: string; bg?: string; bold?: boolean }> = [
-      { text: ` ${fileInfo} `, fg: COLOR.filename, bg: COLOR.statusBar, bold: true },
+      // Placeholder states ('(error)', '(no changes)', ...) are not a real
+      // diff of a real file — a distinct warn color keeps them from being
+      // mistaken for one.
+      { text: ` ${fileInfo} `, fg: placeholder ? COLOR.warn : COLOR.filename, bg: COLOR.statusBar, bold: true },
       { text: `[${this.selectedFile + 1}/${this.entries.length}]`, fg: COLOR.tabInactive, bg: COLOR.statusBar },
       { text: '  +', fg: COLOR.tabInactive, bg: COLOR.statusBar },
       { text: String(stat.added), fg: COLOR.addition, bg: COLOR.statusBar },
@@ -660,6 +757,9 @@ export class DiffPanel extends BasePanel {
     if (entry.semanticSummary) {
       segments.push({ text: `  ◈ ${entry.semanticSummary}`, fg: COLOR.hunk, bg: COLOR.statusBar });
     }
+    if (this.hotkeyStatus) {
+      segments.push({ text: `  ${this.hotkeyStatus}`, fg: COLOR.info, bg: COLOR.statusBar, bold: true });
+    }
     return buildStyledPanelLine(width, segments, { fillBg: COLOR.statusBar });
   }
 

package/src/panels/docs-panel.ts

@@ -122,6 +122,15 @@ export class DocsPanel extends BasePanel {
     return null;
   }
 
+  /**
+   * The `/`-to-search buffer wants every character of a burst (paste, or a
+   * fast-typed query landing in one input.feed() call), same as it always
+   * has — see the interface doc on `Panel.isCapturingTextBurst`.
+   */
+  isCapturingTextBurst(): boolean {
+    return this.searching;
+  }
+
   handleInput(key: string): boolean {
     const searchResult = this._handleSearchKey(key);
     if (searchResult !== null) return searchResult;

package/src/panels/file-explorer-panel.ts

@@ -215,6 +215,15 @@ export class FileExplorerPanel extends BasePanel {
     return null;
   }
 
+  /**
+   * The `/`-to-search buffer wants every character of a burst (paste, or a
+   * fast-typed query landing in one input.feed() call), same as it always
+   * has — see the interface doc on `Panel.isCapturingTextBurst`.
+   */
+  isCapturingTextBurst(): boolean {
+    return this.searchMode;
+  }
+
   handleInput(key: string): boolean {
     const filterResult = this._handleFilterKey(key);
     if (filterResult !== null) return filterResult;

package/src/panels/git-panel.ts

@@ -4,7 +4,7 @@ import { truncateDisplay, getDisplayWidth } from '../utils/terminal-width.ts';
 import { GitService } from '@pellux/goodvibes-sdk/platform/git';
 import { logger } from '@pellux/goodvibes-sdk/platform/utils';
 import { summarizeError } from '@pellux/goodvibes-sdk/platform/utils';
-import { UI_TONES } from '../renderer/ui-primitives.ts';
+import { UI_TONES, DIFF_TONES } from '../renderer/ui-primitives.ts';
 import {
   buildEmptyState,
   buildKeyboardHints,
@@ -77,7 +77,7 @@ const C = extendPalette(DEFAULT_PANEL_PALETTE, {
   commitAuthor: '244',
   selected: '#1c1c1c',
   selectedFg: '#ffffff',
-  diffMeta: '#5f87ff',
+  diffMeta: DIFF_TONES.hunk, // WO-204: shared diff-hunk token, was a local literal
   diffNeutral: '250',
   // Reuses the existing workflow accent token rather than adding a new hex
   // literal (architecture gate ratchets the raw-hex-literal count).
@@ -178,11 +178,9 @@ export class GitPanel extends BasePanel {
       const changed = this.getChangedFiles ? new Set(this.getChangedFiles()) : null;
       const markChanged = (path: string): boolean | undefined => (changed ? changed.has(path) : undefined);
 
-      // Classify from the raw per-file porcelain columns (index/working_dir)
-      // rather than simple-git's `modified`/`staged` convenience arrays: those
-      // arrays both include a file that is staged with no further edits (index
-      // 'M', working_dir ' '), which would otherwise show it as both staged
-      // AND unstaged and make 's'/'u' land on the wrong (phantom) row.
+      // Classify from the raw per-file porcelain columns (index/working_dir), not simple-git's
+      // modified/staged arrays: those double-count a staged-with-no-further-edits file (index 'M',
+      // working_dir ' ') as both staged AND unstaged, landing 's'/'u' on a phantom row.
       const stagedFiles: GitFileEntry[] = [];
       const unstagedFiles: GitFileEntry[] = [];
       for (const f of statusResult.files) {
@@ -278,6 +276,11 @@ export class GitPanel extends BasePanel {
 
   // Input handling
 
+  /** Commit-message entry wants every char of a burst delivered one at a time — see Panel.isCapturingTextBurst. */
+  isCapturingTextBurst(): boolean {
+    return this.commitMessage !== null;
+  }
+
   handleInput(key: string): boolean {
     // Confirm (init repo / commit) takes priority over everything else.
     const confirmResult = handleConfirmInput(this.confirm, key);
@@ -728,10 +731,7 @@ export class GitPanel extends BasePanel {
     });
   }
 
-  /**
-   * Map an item index in `this.items` to the row index in the rendered row list.
-   * Header items expand to 2 rows (branch + spacer).
-   */
+  /** Map an item index in `this.items` to its rendered row index (header items expand to 2 rows: branch + spacer). */
   private getRowIndexForItem(itemIndex: number): number {
     let row = 0;
     for (let i = 0; i < itemIndex && i < this.items.length; i++) {

package/src/panels/knowledge-graph-panel.ts

@@ -266,6 +266,15 @@ export class KnowledgeGraphPanel extends ScrollableListPanel<BrowseRow> {
   // Input
   // ---------------------------------------------------------------------------
 
+  /**
+   * The `/`-to-search buffer wants every character of a burst (paste, or a
+   * fast-typed query landing in one input.feed() call), same as it always
+   * has — see the interface doc on `Panel.isCapturingTextBurst`.
+   */
+  override isCapturingTextBurst(): boolean {
+    return this.searchFocused;
+  }
+
   handleInput(key: string): boolean {
     if (this.lastError !== null) this.clearError();
 

package/src/panels/local-auth-panel.ts

@@ -96,6 +96,16 @@ export class LocalAuthPanel extends ScrollableListPanel<LocalAuthUser> {
     return this.maskedState !== null;
   }
 
+  /**
+   * Masked password/username entry 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`.
+   */
+  public override isCapturingTextBurst(): boolean {
+    return this.isMaskedEntryActive || this.usernameEntry !== null || super.isCapturingTextBurst();
+  }
+
   public override handleInput(key: KeyName): boolean {
     // Masked entry takes priority when active — it must capture every
     // keystroke (including letters that would otherwise be p/a/d/b actions)

package/src/panels/panel-list-panel.ts

@@ -224,6 +224,15 @@ export class PanelListPanel extends BasePanel {
     });
   }
 
+  /**
+   * The `/`-to-filter buffer wants every character of a burst (paste, or a
+   * fast-typed query landing in one input.feed() call), same as it always
+   * has — see the interface doc on `Panel.isCapturingTextBurst`.
+   */
+  public isCapturingTextBurst(): boolean {
+    return this._filterActive;
+  }
+
   public handleInput(key: string): boolean {
     const filterResult = this._handleFilterKey(key);
     if (filterResult !== null) return filterResult;

package/src/panels/project-planning-panel.ts

@@ -81,6 +81,16 @@ export class ProjectPlanningPanel extends BasePanel {
     this.refresh();
   }
 
+  /**
+   * The draft-answer text 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`.
+   */
+  public isCapturingTextBurst(): boolean {
+    return this.getCurrentQuestion() !== null;
+  }
+
   public handleInput(key: string): boolean {
     if (this.lastError !== null) this.clearError();
 

package/src/panels/provider-health-tracker.ts

@@ -5,7 +5,7 @@ import type {
   ProviderHealthRecord,
   ProviderStatus,
 } from '@/runtime/index.ts';
-import { calcSessionCost } from '../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
 
 export type { ProviderStatus };
 
@@ -40,6 +40,8 @@ export interface ProviderHealth {
   totalTokens: number;
   /** Session USD cost accumulated per call via calcSessionCost. */
   totalCostUsd: number;
+  /** True when at least one call's model resolved to no real price (cost-utils isModelPriced === false) — totalCostUsd may understate the true cost. */
+  hasUnpricedModel: boolean;
   /** Ring buffer of recent request latencies in ms (most-recent last). */
   latencies: number[];
 }
@@ -237,6 +239,7 @@ export class ProviderHealthTracker {
         cacheWriteTokens: 0,
         totalTokens: 0,
         totalCostUsd: 0,
+        hasUnpricedModel: false,
         latencies: [],
       };
       this.records.set(name, record);
@@ -259,6 +262,7 @@ export class ProviderHealthTracker {
     const model = usage.model ?? record.lastModelId;
     if (model) {
       record.totalCostUsd += calcSessionCost(input, output, cacheRead, cacheWrite, model);
+      if (!isModelPriced(model)) record.hasUnpricedModel = true;
     }
   }
 

package/src/panels/provider-health-views.ts

@@ -357,7 +357,14 @@ export function buildProviderRow(width: number, tones: ProviderConsoleTones, inp
       { text: errPct, fg: hasCalls && (entry?.errorRate ?? 0) > 0 ? tones.bad : tones.dim },
       { text: buildSparkline(entry?.timeline.points ?? []), fg: hasCalls ? latencyColor(tones, avgMs) : tones.dim },
       { text: health && health.totalTokens > 0 ? fmtTokens(health.totalTokens) : '-', fg: tones.dim },
-      { text: health && health.totalCostUsd > 0 ? fmtUsd(health.totalCostUsd) : '-', fg: tones.value },
+      {
+        // Tokens flowed but the model never resolved to a real price — say so
+        // instead of collapsing into the same '-' shown for "no calls yet".
+        text: health && health.totalTokens > 0
+          ? (health.hasUnpricedModel ? 'unpriced' : fmtUsd(health.totalCostUsd))
+          : '-',
+        fg: health?.hasUnpricedModel ? tones.dim : tones.value,
+      },
       { text: account ? account.authFreshness : '-', fg: account ? freshnessColor(tones, account.authFreshness) : tones.dim },
     ],
     PROVIDER_TABLE_COLUMNS,

package/src/panels/scrollable-list-panel.ts

@@ -242,6 +242,15 @@ export abstract class ScrollableListPanel<T> extends BasePanel {
    * Returns `true` if the key was consumed, `false` to let the panel manager try another
    * handler.
    */
+  /**
+   * The `/`-to-filter buffer wants every character of a burst (paste, or a
+   * fast-typed query landing in one input.feed() call), same as it always
+   * has — see the interface doc on `Panel.isCapturingTextBurst`.
+   */
+  isCapturingTextBurst(): boolean {
+    return this.filterEnabled && this.filterActive;
+  }
+
   handleInput(key: string): boolean {
     // I2: auto-clear transient errors on the next keystroke so stale errors don't linger.
     // Subclasses that override handleInput should call super.handleInput(key) OR manually

package/src/panels/session-browser-panel.ts

@@ -139,6 +139,15 @@ export class SessionBrowserPanel extends BasePanel {
     super.onDeactivate();
   }
 
+  /**
+   * The `/`-to-search buffer wants every character of a burst (paste, or a
+   * fast-typed query landing in one input.feed() call), same as it always
+   * has — see the interface doc on `Panel.isCapturingTextBurst`.
+   */
+  isCapturingTextBurst(): boolean {
+    return this.searching;
+  }
+
   handleInput(key: string): boolean {
     // Confirmation dialog — use shared handleConfirmInput for y/n/Esc UX
     const confirmResult = handleConfirmInput(this.confirm, key);

package/src/panels/token-budget-panel.ts

@@ -7,7 +7,7 @@ import type { TurnEvent } from '@/runtime/index.ts';
 import type { UiEventFeed } from '../runtime/ui-events.ts';
 import type { UiReadModel, UiSessionSnapshot } from '../runtime/ui-read-models.ts';
 import type { SessionMemoryQuery } from '../runtime/ui-service-queries.ts';
-import { calcSessionCost } from '../export/cost-utils.ts';
+import { calcSessionCost, isModelPriced } from '../export/cost-utils.ts';
 import { type ConfirmState, handleConfirmInput, renderConfirmLines } from './confirm-state.ts';
 import type { PanelIntegrationContext } from './types.ts';
 import {
@@ -615,10 +615,12 @@ export class TokenBudgetPanel extends BasePanel {
     // Inline cost estimate — absorbed pricing wiring (cost-utils.ts), shown
     // whenever the active model id is known.
     if (this.getCurrentModelId) {
-      const cost = calcSessionCost(u.input, u.output, u.cacheRead, u.cacheWrite, this.getCurrentModelId());
+      const modelId = this.getCurrentModelId();
+      const priced = isModelPriced(modelId);
+      const cost = calcSessionCost(u.input, u.output, u.cacheRead, u.cacheWrite, modelId);
       lines.push(buildStyledPanelLine(width, [
         { text: '  Cost:       ', fg: C.label },
-        { text: `$${cost.toFixed(4)}`, fg: C.value, bold: true },
+        { text: priced ? `$${cost.toFixed(4)}` : 'unpriced', fg: C.value, bold: true },
       ]));
     }
 

package/src/panels/types.ts

@@ -100,6 +100,19 @@ export interface Panel {
   // Input (optional)
   handleInput?(key: KeyName): boolean;
 
+  /**
+   * Optional: report `true` while this panel has an active inline text
+   * capture (e.g. a `/`-to-filter or search buffer) that deliberately wants
+   * every character of a burst — paste, or several keystrokes typed fast
+   * enough to land in one `input.feed()` call — delivered to `handleInput`
+   * one at a time, same as it always has. When this returns `false` or is
+   * not implemented, the input router treats a printable burst as never a
+   * deliberate single-key panel hotkey and routes it to the composer
+   * instead of exploding it into per-char `handleInput` calls (see
+   * `handlePanelFocusToken` in `src/input/handler-feed-routes.ts`).
+   */
+  isCapturingTextBurst?(): boolean;
+
   // Scroll input (optional)
   // Positive delta scrolls down; negative delta scrolls up.
   handleScroll?(deltaRows: number): boolean;

package/src/panels/work-plan-panel.ts

@@ -100,6 +100,16 @@ export class WorkPlanPanel extends ScrollableListPanel<WorkPlanItem> {
     });
   }
 
+  /**
+   * The add/edit draft form's title/owner/notes fields want 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.draftMode !== null;
+  }
+
   handleInput(key: string): boolean {
     if (this.lastError !== null) this.clearError();