mixdog 0.9.94 → 0.9.96

package/src/tui/components/PromptInput.jsx

@@ -53,6 +53,7 @@ import {
   cancelPromptImmediateFlush,
   schedulePromptImmediateFlush,
 } from './prompt-input/immediate-render.mjs';
+import { classifyPromptEscape } from './prompt-input/escape-policy.mjs';
 
 // Windows Terminal IME composition can clip a glyph that starts exactly at the
 // left edge of the editable text node. The rounded prompt box already adds a
@@ -86,6 +87,7 @@ export function PromptInput({
   interruptActive = false,
   onInterrupt,
   commandPaletteActive = false,
+  commandPaletteOpen = commandPaletteActive,
   mask = false,
   hint = '',
   hintTone = 'info',
@@ -98,6 +100,8 @@ export function PromptInput({
   onCommandPaletteCancel,
   onCommandPaletteComplete,
   onRestoreQueued,
+  hasQueuedMessages = false,
+  hasMessages = false,
   onHistoryNavigate,
   onPasteText,
   selectionRef,
@@ -112,13 +116,16 @@ export function PromptInput({
   });
   const [, bumpCursorAnchorEpoch] = useState(0);
   const draftRef = useRef(draft);
-  const interruptActiveRef = useRef(interruptActive);
   const lastReportedValueRef = useRef(draft.value);
   // Bumped on every submit/draftOverride replace/unmount so an async paste
   // (clipboard read or onPasteText promise) that resolves after the draft
   // moved on can detect staleness and drop its result instead of mutating
   // whatever prompt is now in the box.
   const pasteGenerationRef = useRef(0);
+  // One physical Enter must not enqueue twice when the terminal delivers the
+  // chord as multiple input events before the draft clears (Windows CR/LF).
+  const submitGateRef = useRef(false);
+  const escapeClearAtRef = useRef(0);
   if (valueRef) valueRef.current = draftRef.current.value;
   const { isRawModeSupported } = useStdin();
   // The text box's ink DOM node. We mark it as the cursor anchor (forked ink
@@ -138,7 +145,6 @@ export function PromptInput({
   const undoRef = useRef({ past: [], future: [], lastPushAt: 0, lastValue: null });
   const { value, cursor } = draft;
   draftRef.current = draft;
-  interruptActiveRef.current = interruptActive;
   if (selectionRef) {
     const range = selectionRange(draft);
     selectionRef.current = range
@@ -171,14 +177,12 @@ export function PromptInput({
     }
   };
 
-  // During an active turn, ink is already painting streaming updates at its
-  // 60fps budget. A second unthrottled input render competes with those frames
-  // and makes key echo slower, so busy input stays on ink's normal render path.
-  // Idle input keeps the leading+trailing immediate flush for crisp caret echo.
+  // Keep prompt echo on the same leading+trailing immediate cadence while a
+  // turn is active. Claude Code keeps mid-turn typing responsive; suppressing
+  // this path made the draft visibly trail the keyboard under streaming load.
   const scheduleImmediateFlush = () => {
     schedulePromptImmediateFlush({
       throttle: flushThrottleRef.current,
-      isSuppressed: () => interruptActiveRef.current,
       flush: flushImmediate,
     });
   };
@@ -188,6 +192,7 @@ export function PromptInput({
   }, []);
 
   const commitDraft = (next, options = {}) => {
+    escapeClearAtRef.current = 0;
     const sameDraft = draftStateEqual(draftRef.current, next);
     if (!options.keepPreferredColumn) preferredColumnRef.current = null;
     if (sameDraft) {
@@ -446,8 +451,12 @@ export function PromptInput({
     return true;
   };
 
-  const restoreQueuedToDraft = () => {
-    return onRestoreQueued?.(draftRef.current.value) === true;
+  const restoreQueuedToDraft = ({ showHint = false } = {}) => {
+    return onRestoreQueued?.({
+      restoreDraft: true,
+      showHint,
+      currentText: draftRef.current.value,
+    }) === true;
   };
 
   const applyHistoryNavigation = (direction, meta = {}) => {
@@ -504,15 +513,22 @@ export function PromptInput({
   }, [selectionRef]);
 
   const submitDraft = (next) => {
+    if (submitGateRef.current) return;
     const text = next.value;
+    if (!String(text || '').trim()) return;
+    submitGateRef.current = true;
     const accepted = onSubmit?.(text) !== false;
     if (!accepted) {
+      submitGateRef.current = false;
       commitDraft(next);
       return;
     }
     pasteGenerationRef.current += 1;
     commitDraft({ value: '', cursor: 0, selectionAnchor: null }, { skipHistory: true });
     resetUndo();
+    // Unlock after this input batch drains so a second return event in the
+    // same chord cannot re-submit the pre-clear draft.
+    queueMicrotask(() => { submitGateRef.current = false; });
   };
 
   const submitEnterChunk = (prefix = '') => {
@@ -542,6 +558,7 @@ export function PromptInput({
 
     const rawInput = String(input ?? '');
     const inputKey = rawInput.toLowerCase();
+    if (!key.escape) escapeClearAtRef.current = 0;
     const rawShiftArrowForGrid =
       rawInput === '\x1b[1;2A' || rawInput === '\x1b[a' || rawInput === '[1;2A'
       || rawInput === '\x1b[1;2B' || rawInput === '\x1b[b' || rawInput === '[1;2B'
@@ -618,8 +635,8 @@ export function PromptInput({
     const lineBreakIndex = rawInput.search(/[\r\n]/);
     const rawEnter = rawInput === '\r' || rawInput === '\n' || rawInput === '\r\n';
     const trailingEnterPrefix = singleTrailingLineBreakPrefix(rawInput);
-    const rawCtrlEnter = isModifiedEnterSequence(rawInput);
-    const modifiedLineBreak = key.shift || key.meta || key.ctrl || rawCtrlEnter;
+    const rawModifiedEnter = isModifiedEnterSequence(rawInput);
+    const modifiedLineBreak = key.shift || key.meta || key.ctrl || rawModifiedEnter;
 
     // Ctrl+J is the protocol-INDEPENDENT newline that works on every terminal.
     //  • Legacy / modifyOtherKeys terminals: Ctrl+J is a lone '\n' (0x0A). A real
@@ -636,12 +653,9 @@ export function PromptInput({
       return;
     }
 
-    // A modified Enter that is NOT a newline chord (e.g. Alt+Enter \x1b[13;3u or
-    // \x1b[27;3;13~). isModifiedEnterSequence already handled shift/ctrl above
-    // (→ newline); here we CONSUME any other modified Enter so its raw CSI bytes
-    // never type into the prompt under modifyOtherKeys. Plain Enter (mod=1) is
-    // not matched and still submits below.
-    if (!rawCtrlEnter && isAnyModifiedEnterSequence(rawInput)) {
+    // Consume uncommon modified-Enter combinations outside the normal
+    // Shift/Alt/Ctrl newline set so raw CSI bytes never enter the prompt.
+    if (!rawModifiedEnter && isAnyModifiedEnterSequence(rawInput)) {
       return;
     }
 
@@ -666,7 +680,7 @@ export function PromptInput({
       return;
     }
 
-    if (rawCtrlEnter) {
+    if (rawModifiedEnter) {
       updateDraft((d) => replaceSelection(d, '\n'));
       return;
     }
@@ -735,12 +749,10 @@ export function PromptInput({
           if (!moveDraftVertically(-1, { extend: true })) {
             updateDraft((d) => moveCursor(d, 0, { extend: true }));
           }
-        } else {
-          const hasDraftText = String(draftRef.current.value || '').trim().length > 0;
-          if (!hasDraftText) {
-            if (!restoreQueuedToDraft()) applyHistoryNavigation('up', { emptyDraft: true });
-          } else if (!moveDraftVertically(-1, { extend: false })) {
-            applyHistoryNavigation('up', { emptyDraft: false });
+        } else if (!moveDraftVertically(-1, { extend: false })) {
+          const emptyDraft = String(draftRef.current.value || '').length === 0;
+          if (!hasQueuedMessages || !restoreQueuedToDraft()) {
+            applyHistoryNavigation('up', { emptyDraft });
           }
         }
       }
@@ -758,7 +770,7 @@ export function PromptInput({
             updateDraft((d) => moveCursor(d, d.value.length, { extend: true }));
           }
         } else if (!moveDraftVertically(1, { extend: false })) {
-          applyHistoryNavigation('down', { emptyDraft: String(draftRef.current.value || '').trim().length === 0 });
+          applyHistoryNavigation('down', { emptyDraft: String(draftRef.current.value || '').length === 0 });
         }
       }
       return;
@@ -796,9 +808,8 @@ export function PromptInput({
     }
 
     if (key.escape) {
-      if (commandPaletteActive) {
+      if (commandPaletteOpen) {
         onCommandPaletteCancel?.(draftRef.current.value);
-        commitDraft({ value: '', cursor: 0, selectionAnchor: null });
         return;
       }
       if (selectionRange(draftRef.current)) {
@@ -809,23 +820,55 @@ export function PromptInput({
       if (onEscape?.(currentValue, { phase: 'before' }) === true) {
         return;
       }
-      if (currentValue) {
+      let escape = classifyPromptEscape({
+        interruptActive,
+        hasQueuedMessages,
+        hasMessages,
+        value: currentValue,
+        lastClearPressAt: escapeClearAtRef.current,
+      });
+      if (escape.action === 'restore-queue') {
+        if (restoreQueuedToDraft()) {
+          escapeClearAtRef.current = 0;
+          return;
+        }
+        // A stale projected queue can empty between render and key handling.
+        // Fall through to the normal draft/idle action in that case.
+        escape = classifyPromptEscape({
+          interruptActive,
+          hasMessages,
+          value: currentValue,
+          lastClearPressAt: escapeClearAtRef.current,
+        });
+      }
+      escapeClearAtRef.current = escape.nextClearPressAt;
+      // Active work always wins, even if the user has already typed a steering
+      // draft. The draft is preserved; the old submitted prompt is restored only
+      // when this box is still empty after cancellation.
+      if (escape.action === 'interrupt') {
+        const restoredText = onInterrupt?.(currentValue);
+        if (!currentValue && typeof restoredText === 'string') {
+          commitDraft({ value: restoredText, cursor: restoredText.length, selectionAnchor: null });
+        }
+        return;
+      }
+      if (escape.action === 'arm-clear') {
+        onEscape?.(currentValue, { phase: 'clear-arm' });
+        return;
+      }
+      if (escape.action === 'clear') {
         onEscape?.(currentValue, { phase: 'clear' });
         commitDraft({ value: '', cursor: 0, selectionAnchor: null });
         return;
       }
-      // Active turn takes precedence over queue restore: Esc during a
-      // running turn interrupts the
-      // turn and leaves queued steering prompts intact to run afterward. Queued
-      // messages only pop back into the draft when the turn is idle.
-      if (interruptActive) {
-        const restoredText = onInterrupt?.('');
-        if (typeof restoredText === 'string') {
-          commitDraft({ value: restoredText, cursor: restoredText.length, selectionAnchor: null });
-        }
+      // Empty draft + conversation history: first press arms, the second
+      // opens the message selector (Claude Code's jump-back list).
+      if (escape.action === 'arm-select') {
+        onEscape?.('', { phase: 'select-arm' });
         return;
       }
-      if (restoreQueuedToDraft()) {
+      if (escape.action === 'message-selector') {
+        onEscape?.('', { phase: 'select' });
         return;
       }
       onEscape?.('', { phase: 'empty' });

package/src/tui/components/Spinner.jsx

@@ -21,7 +21,8 @@ import React, { useRef } from 'react';
 import { Box, Text } from 'ink';
 import { useSharedTick } from '../hooks/useSharedTick.mjs';
 import { theme } from '../theme.mjs';
-import { SPINNER_FRAMES } from '../spinner-verbs.mjs';
+import { SPINNER_FRAMES, SPINNER_MODE_OVERRIDE_VERBS, spinnerVerbFor } from '../spinner-verbs.mjs';
+import { buildSpinnerMeta, isReducedMotion } from '../spinner-meta.mjs';
 import { DOWN_ARROW, UP_ARROW } from '../figures.mjs';
 import { formatDuration } from '../time-format.mjs';
 
@@ -32,38 +33,23 @@ const FRAMES = [...SPINNER_FRAMES, ...[...SPINNER_FRAMES].reverse()];
 // Stall: response must grow within this window or the glyph reddens.
 const STALL_TIMEOUT_MS = 3000;
 const STALL_FADE_MS = 2000; // fade red over 2s
-// Hide elapsed/token meta on short turns unless verbose/teammates
-// are active. Mixdog has no spinner verbose/teammate row here, so mirror the
-// default 30s threshold.
-const SHOW_TOKENS_AFTER_MS = 30_000;
+// Reduced motion: the glyph freezes, the shimmer stops and the tick drops to
+// one second so only the timer keeps moving.
+const REDUCED_MOTION_TICK_MS = 1000;
+// A running turn always states how to stop it.
+const INTERRUPT_HINT = 'esc to interrupt';
 // Thinking shimmer starts after this delay.
 const THINKING_DELAY_MS = 3000;
 
 // One-way shimmer. The tail runs past the final character before restarting.
 const GLIMMER_SPEED_MS = { requesting: 70, reconnecting: 70, compacting: 120, 'auto-clear': 120, resuming: 120, 'tool-use': 120, responding: 120, thinking: 120, 'tool-input': 120 };
-const GLIMMER_TRAIL = 4;
+// A wider trail turns the highlight into a wipe travelling across the phrase
+// instead of a single bright character hopping along it.
+const GLIMMER_TRAIL = 6;
 const THINKING_GLIMMER_SPEED_MS = 120;
 const THINKING_GLIMMER_TRAIL = 4;
-// Fixed 30s cadence (user decision): the verb rotates deterministically every
-// 30 seconds instead of the earlier randomized 10–20s / 65% coin flip that
-// often never visibly fired.
-const VERB_ROTATE_MIN_MS = 30000;
-const VERB_ROTATE_SPREAD_MS = 0;
-const VERB_CHANGE_PROBABILITY = 1;
-
-const MODE_VERBS = {
-  requesting: ['Requesting'],
-  compacting: ['Compacting conversation'],
-  'auto-clear': ['Auto-clearing conversation'],
-  resuming: ['Resuming conversation'],
-  // Conservative phrasing (user decision): each pool only rotates through
-  // synonyms of what the mode ACTUALLY means — never a concrete action the
-  // engine may not be doing (no "Checking files" during a web search).
-  thinking: ['Thinking', 'Considering', 'Organizing'],
-  'tool-use': ['Working', 'Running tools', 'Reviewing output'],
-  'tool-input': ['Working', 'Running tools', 'Reviewing output'],
-  responding: ['Writing', 'Wrapping up'],
-};
+// The phrase itself comes from the shared pool in spinner-verbs.mjs — see
+// spinnerVerbFor(). Mode only drives shimmer speed, token glyph and stall tint.
 
 function interpolateColor(a, b, t) {
   return {
@@ -126,38 +112,9 @@ function spinnerRgb() {
   };
 }
 
-const compactNumberFormatter = new Intl.NumberFormat('en-US', {
-  notation: 'compact',
-  maximumFractionDigits: 1,
-  minimumFractionDigits: 0,
-});
-
-function formatNumber(n) {
-  const value = Math.max(0, Number(n || 0));
-  if (value >= 1000) return compactNumberFormatter.format(value).toLowerCase();
-  return String(Math.round(value));
-}
-
 const STATUS_SEP = ' · ';
 const SEP_WIDTH = STATUS_SEP.length;
 
-function stableModeVerb(mode, fallback) {
-  const phrases = MODE_VERBS[mode] || [fallback || 'Working'];
-  return phrases[0] || fallback || 'Working';
-}
-
-function nextVerbCheckAt(now) {
-  return now + VERB_ROTATE_MIN_MS + Math.floor(Math.random() * VERB_ROTATE_SPREAD_MS);
-}
-
-function chooseNextVerb(mode, fallback, current) {
-  const phrases = MODE_VERBS[mode] || [fallback || 'Working'];
-  if (phrases.length <= 1 || Math.random() > VERB_CHANGE_PROBABILITY) return current || phrases[0];
-  const candidates = phrases.filter((phrase) => phrase && phrase !== current);
-  if (!candidates.length) return current || phrases[0];
-  return candidates[Math.floor(Math.random() * candidates.length)];
-}
-
 // Token-direction glyph by mode:
 // up while uploading the request, down while receiving a response, and no
 // glyph at all for non-streaming modes (compacting/resuming/auto-clear) where
@@ -176,24 +133,44 @@ function tokenModeGlyph(mode) {
   }
 }
 
-export function Spinner({ verb = 'Working', startedAt, outputTokens = 0, tokens = 0, thinking = false, thinkingActiveSince = 0, mode = 'responding', columns = 80, marginTop = 1 }) {
+export function Spinner({ verb = 'Working', startedAt, outputTokens = 0, tokens = 0, thinking = false, thinkingActiveSince = 0, thinkingMs = 0, effort = '', hasActiveTools = false, paused = false, interruptible = false, mode = 'responding', columns = 80, marginTop = 1 }) {
+  const reducedMotion = isReducedMotion();
   // Re-render at the frame cadence off the shared tick (no dedicated timer).
   // Glyph/shimmer/token/elapsed values are all derived from Date.now() below.
-  useSharedTick(FRAME_MS);
+  useSharedTick(reducedMotion ? REDUCED_MOTION_TICK_MS : FRAME_MS);
   const { TEXT_RGB, SHIMMER_RGB, SPINNER_GLYPH_RGB, THINKING_INACTIVE, THINKING_SHIMMER, STALL_RGB } = spinnerRgb();
   const now = Date.now();
-  const elapsedMs = startedAt ? Math.max(0, now - startedAt) : 0;
-  const frame = Math.floor(elapsedMs / FRAME_MS);
+  // Animation clock: raw wall time since the turn began. It never pauses, so a
+  // frozen timer (below) still animates instead of looking hung.
+  const rawElapsedMs = startedAt ? Math.max(0, now - startedAt) : 0;
+  const frame = reducedMotion ? 0 : Math.floor(rawElapsedMs / FRAME_MS);
   const lastGrowRef = useRef(now);
   const lastTokensRef = useRef(0);
   const displayedOutputRef = useRef(0);
-  const displayVerbRef = useRef('');
-  const displayVerbModeRef = useRef('');
-  const nextVerbCheckRef = useRef(0);
+  // Pause accounting: time spent waiting on the USER (a tool approval prompt)
+  // is not turn time. Without this the reported duration counts however long
+  // the prompt sat unanswered and the short-turn token gate opens on it.
+  const turnAnchorRef = useRef(startedAt);
+  const pausedTotalRef = useRef(0);
+  const pauseStartRef = useRef(0);
   // Stall smoothing refs (exponential fade)
   const stallSmoothRef = useRef(0);
   const lastStallTickRef = useRef(0);
 
+  if (turnAnchorRef.current !== startedAt) {
+    turnAnchorRef.current = startedAt;
+    pausedTotalRef.current = 0;
+    pauseStartRef.current = 0;
+  }
+  if (paused && !pauseStartRef.current) {
+    pauseStartRef.current = now;
+  } else if (!paused && pauseStartRef.current) {
+    pausedTotalRef.current += Math.max(0, now - pauseStartRef.current);
+    pauseStartRef.current = 0;
+  }
+  const pausedMs = pausedTotalRef.current + (pauseStartRef.current ? Math.max(0, now - pauseStartRef.current) : 0);
+  const elapsedMs = Math.max(0, rawElapsedMs - pausedMs);
+
   const targetOutputTokens = Math.max(0, Number(outputTokens || tokens || 0));
 
   // Stall detection — track output growth, because input usually arrives as one
@@ -203,8 +180,14 @@ export function Spinner({ verb = 'Working', startedAt, outputTokens = 0, tokens
     lastGrowRef.current = now;
   }
 
+  // Waiting is not stalling: while a tool runs (no tokens can arrive) or while
+  // the user owns an approval prompt, hold the stall clock at zero. Otherwise a
+  // 30s shell command or a slow approval reddens a perfectly healthy turn.
+  const workBlocked = paused || hasActiveTools || mode === 'tool-use' || mode === 'tool-input';
+  if (workBlocked) lastGrowRef.current = now;
+
   const stallMs = now - lastGrowRef.current;
-  const isStalled = targetOutputTokens > 0 && stallMs > STALL_TIMEOUT_MS;
+  const isStalled = !reducedMotion && targetOutputTokens > 0 && stallMs > STALL_TIMEOUT_MS;
   // Stall smoothing: exponential fade toward target
   const rawIntensity = isStalled
     ? Math.min(1, (stallMs - STALL_TIMEOUT_MS) / STALL_FADE_MS)
@@ -235,36 +218,31 @@ export function Spinner({ verb = 'Working', startedAt, outputTokens = 0, tokens
       ))
     : theme.spinnerGlyph;
 
-  // --- Verb shimmer (traveling highlight) ---
-  if (!displayVerbRef.current || displayVerbModeRef.current !== mode) {
-    displayVerbRef.current = stableModeVerb(mode, verb);
-    // Mode flips (thinking→tool-use→responding…) must NOT re-arm the timer:
-    // frequent flips otherwise reset the countdown forever and the rotation
-    // never fires. The cadence holds from the first mount of the turn.
-    if (!nextVerbCheckRef.current) nextVerbCheckRef.current = nextVerbCheckAt(now);
-  }
-  displayVerbModeRef.current = mode;
-  if (now >= nextVerbCheckRef.current) {
-    displayVerbRef.current = chooseNextVerb(mode, verb, displayVerbRef.current);
-    nextVerbCheckRef.current = nextVerbCheckAt(now);
-  }
-  const displayVerb = displayVerbRef.current;
+  // --- Verb (one common pool, one phrase per 30s window) ---
+  // Anchored to `startedAt`, so a mode flip cannot rewrite the label and the
+  // desktop shows the same word at the same second.
+  const displayVerb = SPINNER_MODE_OVERRIDE_VERBS[mode]
+    || (mode === 'reconnecting' ? (String(verb || '').trim() || 'Reconnecting') : spinnerVerbFor(startedAt, now));
   const messageText = mode === 'reconnecting' ? displayVerb : `${displayVerb}…`;
   const messageLen = messageText.length;
 
   // Glimmer speed per mode.
   const glimmerSpeed = GLIMMER_SPEED_MS[mode] ?? 200;
   const shimmerSpan = Math.max(1, messageLen + GLIMMER_TRAIL);
-  const shimmerHead = Math.floor(elapsedMs / glimmerSpeed) % shimmerSpan;
+  const shimmerHead = Math.floor(rawElapsedMs / glimmerSpeed) % shimmerSpan;
 
   // Keep the verb shimmer moving even during stalls/tool waits. Stall tinting is
   // limited to the glyph; tinting the whole verb made the sweep disappear after
   // a few seconds and read as a stuck dark label.
-  const verbContent = messageLen > 0 && TEXT_RGB && SHIMMER_RGB
+  const verbContent = messageLen > 0 && !reducedMotion && TEXT_RGB && SHIMMER_RGB
     ? renderShimmerText(messageText, shimmerHead, GLIMMER_TRAIL, TEXT_RGB, SHIMMER_RGB, theme.spinnerText, 'verb', shimmerSpan)
-    : null;
+    : (messageLen > 0 ? <Text color={theme.spinnerText}>{messageText}</Text> : null);
 
   const advanceCounter = (ref, target) => {
+    if (reducedMotion) {
+      ref.current = target;
+      return Math.round(target);
+    }
     if (ref.current > target) {
       ref.current = target;
     } else if (ref.current < target) {
@@ -284,10 +262,19 @@ export function Spinner({ verb = 'Working', startedAt, outputTokens = 0, tokens
   // thinking, tool-use, tool-input). Input token totals are not shown.
   const displayedOutputTokens = advanceCounter(displayedOutputRef, targetOutputTokens);
 
+  // Byline text comes from the shared builder so the desktop band reads the
+  // same way (token gate, thinking vs "thought for Ns").
+  const meta = buildSpinnerMeta({
+    elapsedMs,
+    outputTokens: displayedOutputTokens,
+    thinking,
+    thinkingSince: thinkingActiveSince,
+    thinkingMs,
+    effort,
+  });
   const tokenGlyph = tokenModeGlyph(mode);
-  const tokenCountText = formatNumber(displayedOutputTokens);
-  const tokenText = displayedOutputTokens > 0
-    ? (tokenGlyph ? `${tokenGlyph} ${tokenCountText} tokens` : `${tokenCountText} tokens`)
+  const tokenText = meta.tokensText
+    ? (tokenGlyph ? `${tokenGlyph} ${meta.tokensText}` : meta.tokensText)
     : '';
   const tokenW = tokenText.length;
 
@@ -299,20 +286,22 @@ export function Spinner({ verb = 'Working', startedAt, outputTokens = 0, tokens
   const timerText = formatDuration(elapsedMs);
   const timerLabel = timerText;
   const timerW = timerLabel.length;
-  const thinkingActive = Boolean(thinking || thinkingActiveSince);
-  const thinkingStatusText = thinkingActive
-    ? 'thinking'
-    : '';
+  const thinkingActive = meta.thinkingActive;
+  const thinkingStatusText = meta.thinkingText;
   const thinkingStatusW = thinkingStatusText.length;
   // Turn elapsed time is the headline metric here, not a thinking sub-stat, so
   // it shows from 1s onward (formatDuration returns '' below 1s). Tokens keep
   // Short-turn gate: tokens only appear once the turn runs long.
-  const wantsTokens = elapsedMs > SHOW_TOKENS_AFTER_MS;
-
-  // Thinking display priority for narrow widths, but renders
-  // it after timer/tokens in the final byline.
-  const showThinkingStatus = Boolean(thinkingStatusText) && avail > thinkingStatusW;
-  const usedAfterThinking = showThinkingStatus ? thinkingStatusW + SEP_WIDTH : 0;
+  const wantsTokens = meta.showTokens;
+
+  // Interrupt hint and thinking status win the width race (they render LAST in
+  // the byline but are gated FIRST), then timer, then tokens.
+  const interruptText = interruptible ? INTERRUPT_HINT : '';
+  const interruptW = interruptText.length;
+  const showInterrupt = Boolean(interruptText) && avail > interruptW;
+  const usedAfterInterrupt = showInterrupt ? interruptW + SEP_WIDTH : 0;
+  const showThinkingStatus = Boolean(thinkingStatusText) && avail > usedAfterInterrupt + thinkingStatusW;
+  const usedAfterThinking = usedAfterInterrupt + (showThinkingStatus ? thinkingStatusW + SEP_WIDTH : 0);
   const showTimer = Boolean(timerLabel) && avail > usedAfterThinking + timerW;
   const usedAfterTimer = usedAfterThinking + (showTimer ? timerW + SEP_WIDTH : 0);
   const showTokens = wantsTokens && tokenText && avail > usedAfterTimer + tokenW;
@@ -331,13 +320,18 @@ export function Spinner({ verb = 'Working', startedAt, outputTokens = 0, tokens
   }
   if (showThinkingStatus) {
     const thinkingSpan = Math.max(1, thinkingStatusText.length + THINKING_GLIMMER_TRAIL);
-    const thinkingHead = Math.floor(Math.max(0, elapsedMs - THINKING_DELAY_MS) / THINKING_GLIMMER_SPEED_MS) % thinkingSpan;
+    const thinkingHead = Math.floor(Math.max(0, rawElapsedMs - THINKING_DELAY_MS) / THINKING_GLIMMER_SPEED_MS) % thinkingSpan;
     segments.push(
-      thinkingActive
+      thinkingActive && !reducedMotion
         ? <Text key="thinking-status">{renderShimmerText(thinkingStatusText, thinkingHead, THINKING_GLIMMER_TRAIL, THINKING_INACTIVE, THINKING_SHIMMER, theme.thinkingBase, 'thinking-status', thinkingSpan)}</Text>
         : <Text key="thinking-status" color={theme.statusSubtle}>{thinkingStatusText}</Text>
     );
   }
+  if (showInterrupt) {
+    segments.push(
+      <Text key="interrupt" color={theme.statusSubtle}>{interruptText}</Text>
+    );
+  }
   return (
     <Box marginTop={marginTop} flexDirection="row">
       <Box flexWrap="wrap" height={1} width={2}>

package/src/tui/components/TextEntryPanel.jsx

@@ -180,6 +180,7 @@ export function TextEntryPanel({
   const [draft, setDraft] = useState(() => ({ value: String(initialValue || ''), cursor: String(initialValue || '').length, selectionAnchor: null }));
   const [, bumpCursorAnchorEpoch] = useState(0);
   const draftRef = useRef(draft);
+  const submitGateRef = useRef(false);
   const boxRef = useRef(null);
   const cursorEnabledRef = useRef(false);
   const contentWidthRef = useRef(80);
@@ -244,20 +245,33 @@ export function TextEntryPanel({
   }, [multiline, draft.value, mask, contentCells, maxContentRows, onContentRowsChange]);
 
   const submit = () => {
+    if (submitGateRef.current) return;
+    if (!String(draftRef.current.value || '').trim()) return;
+    submitGateRef.current = true;
     const accepted = onSubmit?.(draftRef.current.value) !== false;
     if (accepted) {
       commitDraft({ value: '', cursor: 0, selectionAnchor: null });
+      queueMicrotask(() => { submitGateRef.current = false; });
+    } else {
+      submitGateRef.current = false;
     }
   };
 
   const submitEnterChunk = (prefix = '') => {
+    if (submitGateRef.current) return;
     const current = draftRef.current;
     const next = prefix ? insertText(current, prefix) : current;
+    if (!String(next.value || '').trim()) return;
+    submitGateRef.current = true;
     const accepted = onSubmit?.(next.value) !== false;
     if (accepted) {
       commitDraft({ value: '', cursor: 0, selectionAnchor: null });
+      queueMicrotask(() => { submitGateRef.current = false; });
     } else if (next !== current) {
+      submitGateRef.current = false;
       commitDraft(next);
+    } else {
+      submitGateRef.current = false;
     }
   };
 

package/src/tui/components/ToolExecution.jsx

@@ -369,8 +369,8 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   let labelOut;
   let summaryOut;
   // Shell headers stay label-only ("Ran 1 command") on every surface —
-  // opencode parity and the desktop card contract: the raw command line never
-  // rides inline in the header; it stays in the expanded detail body.
+  // the desktop card contract: the raw command line never rides inline in
+  // the header; it stays in the expanded detail body.
   const headerSummaryText = isShellSurface ? '' : summaryText;
   if (stringWidth(labelText) >= avail) {
     labelOut = truncateToWidth(labelText, avail);

package/src/tui/components/prompt-input/edit-helpers.mjs

@@ -41,26 +41,24 @@ export function draftStateEqual(a, b) {
 // Recognize a MODIFIED Enter delivered via the kitty keyboard protocol
 // (\x1b[13;<mod>u) or modifyOtherKeys (\x1b[27;<mod>;13~). The xterm modifier
 // param is (1 + bitmask) where the bitmask bits are shift=1, alt=2, ctrl=4. We
-// treat Ctrl+Enter AND Shift+Enter (the two common "insert newline" chords) as a
-// newline, so we match when the shift OR ctrl bit is set. Ctrl+J is handled
-// separately as the protocol-independent fallback.
-const MODIFIED_ENTER_SHIFT_OR_CTRL = 1 | 4;
+// treat Shift+Enter, Alt/Meta+Enter, and Ctrl+Enter as newline chords. Claude
+// Code maps Shift/Meta+Enter to newline; Ctrl+Enter remains a compatible Mixdog
+// extension. Ctrl+J is handled separately as the protocol-independent fallback.
+const MODIFIED_ENTER_NEWLINE = 1 | 2 | 4;
 
 export function isModifiedEnterSequence(input) {
   const text = String(input ?? '');
   const body = text.startsWith('\x1b[') ? text.slice(2) : text.startsWith('[') ? text.slice(1) : '';
   if (!body) return false;
   const kitty = /^13;(\d+)(?::\d+)?(?:;[\d:]+)?u$/.exec(body);
-  if (kitty) return ((Number(kitty[1]) - 1) & MODIFIED_ENTER_SHIFT_OR_CTRL) !== 0;
+  if (kitty) return ((Number(kitty[1]) - 1) & MODIFIED_ENTER_NEWLINE) !== 0;
   const modifyOtherKeys = /^27;(\d+);13~$/.exec(body);
-  return Boolean(modifyOtherKeys && (((Number(modifyOtherKeys[1]) - 1) & MODIFIED_ENTER_SHIFT_OR_CTRL) !== 0));
+  return Boolean(modifyOtherKeys && (((Number(modifyOtherKeys[1]) - 1) & MODIFIED_ENTER_NEWLINE) !== 0));
 }
 
-// Recognize ANY modified Enter (any modifier bitmask, e.g. Alt+Enter \x1b[13;3u
-// / \x1b[27;3;13~). Used to CONSUME modified-Enter sequences we don't map to a
-// newline (Alt-only, etc.) so they aren't typed into the prompt as raw CSI text
-// under modifyOtherKeys. Plain Enter (mod param = 1, bitmask 0) is intentionally
-// NOT matched, so it still submits.
+// Recognize ANY modified Enter. Used to consume uncommon modifier combinations
+// outside the Shift/Alt/Ctrl newline set so raw CSI bytes never reach the draft.
+// Plain Enter (mod param = 1, bitmask 0) intentionally remains a submit.
 export function isAnyModifiedEnterSequence(input) {
   const text = String(input ?? '');
   const body = text.startsWith('\x1b[') ? text.slice(2) : text.startsWith('[') ? text.slice(1) : '';