@pellux/goodvibes-tui 1.0.0 → 1.1.0

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/main.ts

@@ -130,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;
@@ -180,6 +176,8 @@ async function main() {
     ttftRecorded: false,
     activeToolStartedAtMs: undefined,
     activeToolName: undefined,
+    lastDeltaAtMs: undefined, stallEpisode: 0,
+    reconnectAttempt: undefined, reconnectMaxAttempts: undefined,
   };
 
   const getPromptContentWidth = () => computePromptContentWidth(stdout.columns);
@@ -190,10 +188,8 @@ async function main() {
     const currentModel = providerRegistry.getCurrentModel();
     const contextWindow = providerRegistry.getContextWindowForModel(currentModel);
     const rows = stdout.rows || 24;
-    // Compact threshold must match buildShellFooter's `compact: height < 30`
-    // posture below — otherwise the cached-height fast path in
-    // estimateShellFooterHeight can answer a compact-vs-non-compact query
-    // with the wrong cached mode and throw the viewport math off by several rows.
+    // 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);
   };
 
@@ -348,6 +344,7 @@ async function main() {
     allowTerminalWrite(() => stdout.write(CLEAR_SCREEN));
     render();
   };
+  commandContext.requestFullRepaint = () => { compositor.resetDiff(); render(); };
   permissionPromptRef.requestPermission = (request) =>
     new Promise((resolve) => {
       pendingPermission = {
@@ -514,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,
@@ -584,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(),
@@ -594,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.
@@ -698,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;
@@ -724,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/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,
+                },
               ],
             };
           }),

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,6 +5,7 @@
 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, DIFF_TONES } from '../renderer/ui-primitives.ts';
 import { FilePreviewPanel } from './file-preview-panel.ts';
@@ -166,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),
     });
@@ -235,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;
   }
@@ -271,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 }); });
   }
@@ -287,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([
@@ -325,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(),
@@ -353,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(
@@ -418,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;
@@ -433,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;
@@ -623,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);
@@ -650,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 },
@@ -666,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;