mixdog 0.9.95 → 0.9.97

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,7 +116,6 @@ 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
@@ -122,6 +125,7 @@ export function PromptInput({
   // 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
@@ -141,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
@@ -174,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,
     });
   };
@@ -191,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) {
@@ -449,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 = {}) => {
@@ -552,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'
@@ -628,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
@@ -646,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;
     }
 
@@ -676,7 +680,7 @@ export function PromptInput({
       return;
     }
 
-    if (rawCtrlEnter) {
+    if (rawModifiedEnter) {
       updateDraft((d) => replaceSelection(d, '\n'));
       return;
     }
@@ -745,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 });
           }
         }
       }
@@ -768,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;
@@ -806,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)) {
@@ -819,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

@@ -22,7 +22,7 @@ import { Box, Text } from 'ink';
 import { useSharedTick } from '../hooks/useSharedTick.mjs';
 import { theme } from '../theme.mjs';
 import { SPINNER_FRAMES, SPINNER_MODE_OVERRIDE_VERBS, spinnerVerbFor } from '../spinner-verbs.mjs';
-import { SHOW_TOKENS_AFTER_MS, buildSpinnerMeta, isReducedMotion } from '../spinner-meta.mjs';
+import { buildSpinnerMeta, isReducedMotion } from '../spinner-meta.mjs';
 import { DOWN_ARROW, UP_ARROW } from '../figures.mjs';
 import { formatDuration } from '../time-format.mjs';
 

package/src/tui/components/ToolExecution.jsx

@@ -96,7 +96,7 @@ export function ToolExecution({ name, args, result, rawResult, isError, errorCou
   const elapsedMs = startedAtMs ? Math.max(0, (pending ? nowMs : (completedAtMs || nowMs)) - startedAtMs) : 0;
   const elapsed = elapsedMs >= 1000 ? formatElapsed(elapsedMs) : '';
   const failedCount = clampFailureCount(errorCount, groupCount, isError);
-  // Real tool-call failures only (backend isError / error toolKind). Drives the
+  // Real tool-call failures only (provider isError / error toolKind). Drives the
   // ● dot color; command/result failures (shell exit, failed status) are counted
   // in `failedCount`/L2 detail but never in `callFailedCount`, so they never
   // paint the dot red. Fall back to 0 (never `isError`) when the engine did not

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) : '';

package/src/tui/components/prompt-input/escape-policy.mjs

@@ -0,0 +1,42 @@
+export const PROMPT_ESCAPE_CLEAR_WINDOW_MS = 800;
+
+/**
+ * Claude Code-compatible chat Escape priority after overlays/selections have
+ * already had a chance to consume the key:
+ * active turn -> interrupt, idle queue -> restore for editing,
+ * idle non-empty draft -> double-press clear, idle empty draft with history ->
+ * double-press message selector, otherwise fallback.
+ */
+export function classifyPromptEscape({
+  interruptActive = false,
+  hasQueuedMessages = false,
+  hasMessages = false,
+  value = '',
+  lastClearPressAt = 0,
+  now = Date.now(),
+} = {}) {
+  if (interruptActive) return { action: 'interrupt', nextClearPressAt: 0 };
+  if (hasQueuedMessages) return { action: 'restore-queue', nextClearPressAt: 0 };
+
+  const current = Number(now);
+  const previous = Number(lastClearPressAt);
+  const repeated = Number.isFinite(current)
+    && Number.isFinite(previous)
+    && previous > 0
+    && current >= previous
+    && current - previous <= PROMPT_ESCAPE_CLEAR_WINDOW_MS;
+  const armed = Number.isFinite(current) && current > 0 ? current : 1;
+
+  // Empty draft: Claude Code's double-press opens the message selector so a
+  // previous prompt can be pulled back into the box (nothing to clear here).
+  if (String(value ?? '') === '') {
+    if (!hasMessages) return { action: 'idle', nextClearPressAt: 0 };
+    return repeated
+      ? { action: 'message-selector', nextClearPressAt: 0 }
+      : { action: 'arm-select', nextClearPressAt: armed };
+  }
+
+  return repeated
+    ? { action: 'clear', nextClearPressAt: 0 }
+    : { action: 'arm-clear', nextClearPressAt: armed };
+}

package/src/tui/components/prompt-input/immediate-render.mjs

@@ -1,7 +1,3 @@
-function suppressed(value) {
-  return typeof value === 'function' ? value() === true : value === true;
-}
-
 export function cancelPromptImmediateFlush(throttle, clearTimer = clearTimeout) {
   if (!throttle || throttle.timer === null) return false;
   clearTimer(throttle.timer);
@@ -11,7 +7,6 @@ export function cancelPromptImmediateFlush(throttle, clearTimer = clearTimeout)
 
 export function schedulePromptImmediateFlush({
   throttle,
-  isSuppressed = false,
   flush,
   intervalMs = 16,
   now = Date.now,
@@ -22,10 +17,6 @@ export function schedulePromptImmediateFlush({
   if (!throttle || typeof flush !== 'function') {
     throw new TypeError('schedulePromptImmediateFlush requires throttle state and a flush function');
   }
-  if (suppressed(isSuppressed)) {
-    cancelPromptImmediateFlush(throttle, clearTimer);
-    return false;
-  }
 
   const current = now();
   const elapsed = current - throttle.lastAt;
@@ -39,7 +30,6 @@ export function schedulePromptImmediateFlush({
 
   throttle.timer = setTimer(() => {
     throttle.timer = null;
-    if (suppressed(isSuppressed)) return;
     throttle.lastAt = now();
     flush();
   }, intervalMs - elapsed);

package/src/tui/components/prompt-input/interrupt-policy.mjs

@@ -0,0 +1,10 @@
+/**
+ * Claude Code restores the submitted prompt only when Esc cancelled before a
+ * meaningful response and the user has not typed a replacement meanwhile.
+ * The engine owns the response-progress guard; the prompt owns the draft guard.
+ */
+export function promptInterruptRestoreText(result, currentText = '') {
+  if (!result || result?.aborted === false) return '';
+  if (String(currentText ?? '') !== '') return '';
+  return String(result?.restoreText || '').trim();
+}

package/src/tui/components/prompt-input/restore-policy.mjs

@@ -0,0 +1,10 @@
+/**
+ * Queue restore RPCs may settle after the user has continued editing. The
+ * session service is asked for queued text only; prepend it to the latest local draft
+ * so a delayed response can never replace newer typing.
+ */
+export function mergeQueuedRestoreText(queuedText = '', currentText = '') {
+  return [String(queuedText ?? ''), String(currentText ?? '')]
+    .filter((text) => text.trim())
+    .join('\n');
+}

package/src/tui/components/tool-execution/surface-detail.mjs

@@ -44,7 +44,7 @@ export {
 //   all failed       -> theme.error
 //   cancelled        -> theme.warning
 // The RED/orange failure color is driven ONLY by real tool-call errors
-// (`callFailedCount` — backend isError / error toolKind), NOT by command/result
+// (`callFailedCount` — provider isError / error toolKind), NOT by command/result
 // failures like a `[status: failed]` result. A shell command-exit
 // (`exitFailedCount`) is its own distinct neutral state: warning color, never
 // red. `terminalStatus` is still consulted so a cancelled card stays warning.