mixdog 0.9.174 → 1.0.0

package/src/tui/app/text-layout.mjs

@@ -67,7 +67,7 @@ export function wrappedDetailRows(text, width) {
 
 // Rows one queued steering band (QueuedCommands expanded mode) occupies when
 // its full text renders with ink's wrap="wrap" at `width` content columns.
-// Same wrap-ansi call ink uses, so the queuedRows reservation in App.jsx stays
+// Same wrap-ansi call ink uses, so the queuedRows reservation in row-budgets stays
 // in lock-step with the rendered height — a mismatch pushes the input box.
 export function queuedBandRows(text, width) {
   const value = String(text ?? '');

package/src/tui/app/theme-effort-pickers.mjs

@@ -120,7 +120,7 @@ export function createThemeEffortPickers({
     const own = surface.claim();
     setProviderPrompt(null);
     setSettingsPrompt(null);
-    const items = Array.isArray(state.effortOptions) && state.effortOptions.length > 0 ? state.effortOptions : [];
+    const items = Array.isArray(state.effortOptions) ? state.effortOptions : [];
     if (!items.length) {
       store.pushNotice('Current model has no effort levels.', 'warn');
       return;

package/src/tui/app/transcript-window.mjs

@@ -47,7 +47,6 @@ export const SELECTION_PAINT_INTERVAL_MS = positiveIntEnv('MIXDOG_TUI_SELECTION_
 // call per this interval, instead of firing the (expensive: anchor recompute +
 // selection repaint) scrollTranscriptRows on every mousemove/wheel tick.
 export const SCROLL_COALESCE_MS = positiveIntEnv('MIXDOG_TUI_SCROLL_COALESCE_MS', 16);
-export const PROMPT_HISTORY_LIMIT = 50;
 
 // Accumulate same-direction wheel/edge-drag deltas, but never retain movement
 // from the opposite direction. Without this reset a quick wheel reversal could
@@ -356,8 +355,6 @@ function measuredTranscriptRows(item, columns, toolOutputExpanded) {
   return entry.rows;
 }
 
-const STREAMING_ROW_QUANTUM = 1;
-
 function streamingEstimateRows(item, columns, toolOutputExpanded) {
   const id = item?.id;
   const exactText = String(item?.text ?? '');
@@ -376,8 +373,7 @@ function streamingEstimateRows(item, columns, toolOutputExpanded) {
   }
   const trimmedText = streamingLayoutText(item.text);
   const estimateItem = trimmedText === item.text ? item : { ...item, text: trimmedText };
-  const raw = Math.max(1, Math.ceil(estimateTranscriptItemRows(estimateItem, columns, toolOutputExpanded)));
-  const quantized = Math.ceil(raw / STREAMING_ROW_QUANTUM) * STREAMING_ROW_QUANTUM;
+  const quantized = Math.max(1, Math.ceil(estimateTranscriptItemRows(estimateItem, columns, toolOutputExpanded)));
   // High-water clamp: streaming text only grows, so never report fewer rows than
   // this id already reached this run — absorbs the childCount 1↔2 gap flip that
   // otherwise dips the estimate ±1 frame-to-frame. A columns/expanded change

package/src/tui/app/usage-context-panels/context-model.mjs

@@ -5,7 +5,7 @@ import {
   contextMeasurementStats,
   measuredContextUsage,
   contextMeasurementLabel,
-} from '../../../ui/context-measurement.mjs';
+} from '../../../runtime/shared/context-measurement.mjs';
 
 const EMPTY_TOOLS = { activeCount: 0, count: 0, mcpToolCount: 0, activeMcpToolCount: 0, activeTools: [] };
 const EMPTY_MCP = { connectedCount: 0, configuredCount: 0, failedCount: 0 };

package/src/tui/app/use-global-key-input.mjs

@@ -11,7 +11,6 @@ import { copyActiveSelection } from './use-global-key-input/copy-first.mjs';
 import { decodeSelectionMoveChord } from './use-global-key-input/shift-arrow.mjs';
 export function useGlobalKeyInput({
   store,
-  state: _state,
   toolApproval,
   picker,
   usagePanel,

package/src/tui/app/use-interaction-refs.mjs

@@ -0,0 +1,55 @@
+/*
+ * app/use-interaction-refs.mjs — mouse-selection, click and frame-geometry refs
+ * App shares between the mouse handler, scroll engine and layout.
+ */
+import { useRef } from 'react';
+
+export function useInteractionRefs() {
+  // dragRef tracks an in-progress mouse text selection (see the mouse handler):
+  // anchor = where the drag began, last = the latest cell, active = button held.
+  // region: which surface the in-progress (or last) selection belongs to —
+  // 'transcript' | 'status' (both ink-grid) | 'prompt' (PromptInput's own engine)
+  // | null. Press decides it; motion/release stay in that region.
+  // anchorSpan: for word/line multi-click selections, the initial word/line
+  // bounds ({ lo:{x,y}, hi:{x,y}, kind:'word'|'line' }) so a subsequent drag
+  // extends the selection whole-word/whole-line from that span. Null ⇔ an
+  // ordinary char-drag selection.
+  const dragRef = useRef({
+    anchor: null,
+    anchorScroll: 0,
+    last: null,
+    active: false,
+    rect: null,
+    region: null,
+    anchorSpan: null,
+  });
+  const transcriptViewportRef = useRef({ top: 0, bottom: 0 });
+  const panelTransitionRef = useRef({ signature: '', reserve: 0, clearRows: 0, guardRows: 0, epoch: 0 });
+  const panelCloseInkMaskRowsRef = useRef(0);
+  const projectBootInputLatchRef = useRef(false);
+  // [mixdog] Latest terminal row count + the statusline band (bottom rows),
+  // refreshed each render. The mouse handler uses these to (a) clip a status-bar
+  // grid selection to the statusline rows and (b) route a press to the right
+  // region. STATUSLINE_BAND_ROWS (App.jsx) mirrors the layout reserve.
+  const frameRowsRef = useRef(24);
+  const selectionLayoutRef = useRef(null);
+  const selectionTextRef = useRef('');
+  // lastClickRef tracks the previous left-press cell + time so the mouse handler
+  // can detect a double-click (same cell within 500ms) for word selection.
+  // count = consecutive qualifying presses on the same cell (1=single,
+  // 2=double/word, 3=triple/line). A 4th qualifying press restarts the
+  // sequence at 1 (simplest reset: no ratcheting/back-off). Any non-qualifying
+  // press resets to a fresh single.
+  const lastClickRef = useRef({ x: -1, y: -1, t: 0, count: 0 });
+  return {
+    dragRef,
+    transcriptViewportRef,
+    panelTransitionRef,
+    panelCloseInkMaskRowsRef,
+    projectBootInputLatchRef,
+    frameRowsRef,
+    selectionLayoutRef,
+    selectionTextRef,
+    lastClickRef,
+  };
+}

package/src/tui/app/use-onboarding-start.mjs

@@ -0,0 +1,45 @@
+/*
+ * app/use-onboarding-start.mjs — first-run onboarding gate + wizard launch.
+ */
+import { useEffect } from 'react';
+
+// First-run gate. The daemon-backed engine store answers any method it does
+// not implement locally with an async remote call, so a synchronous
+// getOnboardingStatus() probe can hand back a Promise instead of the status
+// object — which read as "not completed" and re-opened a dismissed wizard on
+// every launch. runTui resolves the status before mount and passes the verdict
+// in; only a local store (tests, direct mounts) falls back to the sync probe,
+// and anything unresolvable counts as completed.
+export function resolveOnboardingCompleted(store, onboardingCompleted) {
+  if (typeof onboardingCompleted === 'boolean') return onboardingCompleted;
+  try {
+    const status = store.getOnboardingStatus?.();
+    if (!status || typeof status !== 'object' || typeof status.then === 'function') return true;
+    return status.completed === true;
+  } catch {
+    return true;
+  }
+}
+
+export function useOnboardingStart({
+  store,
+  forceOnboarding,
+  onboardingCompleted,
+  onboardingStartedRef,
+  setOnboardingActive,
+  openOnboardingAuthStep,
+}) {
+  useEffect(() => {
+    if (onboardingStartedRef.current) return undefined;
+    if (resolveOnboardingCompleted(store, onboardingCompleted) && !forceOnboarding) return undefined;
+    let canceled = false;
+    onboardingStartedRef.current = true;
+    setOnboardingActive(true);
+    setTimeout(() => {
+      if (!canceled) openOnboardingAuthStep();
+    }, 0);
+    return () => {
+      canceled = true;
+    };
+  }, [store, forceOnboarding, onboardingCompleted]);
+}

package/src/tui/app/use-panel-transition.mjs

@@ -0,0 +1,40 @@
+// Panel-transition bookkeeping: after every layout commit, records the
+// signature/reserve the NEXT render diffs against, then schedules the follow-up
+// epoch bump that releases the transition clearance (or the ink close mask).
+import { useEffect } from 'react';
+
+export function usePanelTransition({
+  panelTransitionRef,
+  panelCloseInkMaskRowsRef,
+  panelLayoutSignature,
+  bottomClusterRows,
+  panelTransitionClearRows,
+  panelTransitionGuardRows,
+  latestTranscriptItem,
+  setPanelInkMaskEpoch,
+  setPanelTransitionEpoch,
+}) {
+  useEffect(() => {
+    const transition = panelTransitionRef.current;
+    const pendingInkMask = panelCloseInkMaskRowsRef.current;
+    const hadTransitionClearance = panelTransitionClearRows > 0 || panelTransitionGuardRows > 0;
+    transition.signature = panelLayoutSignature;
+    transition.reserve = bottomClusterRows;
+    transition.clearRows = 0;
+    transition.guardRows = 0;
+    if (pendingInkMask > 0) {
+      panelCloseInkMaskRowsRef.current = 0;
+      setPanelInkMaskEpoch((epoch) => epoch + 1);
+      return undefined;
+    }
+    if (!hadTransitionClearance) return undefined;
+    const timer = setTimeout(() => setPanelTransitionEpoch((epoch) => epoch + 1), 0);
+    return () => clearTimeout(timer);
+  }, [panelLayoutSignature, bottomClusterRows, panelTransitionClearRows, panelTransitionGuardRows]);
+  // Record the transcript tail id AFTER every commit so the next render's
+  // spinner-meta-collapse gate (doneTailAppendedThisCommit) can tell a freshly
+  // appended done row from a stale one that was already at the tail.
+  useEffect(() => {
+    panelTransitionRef.current.tailId = latestTranscriptItem?.id ?? null;
+  });
+}

package/src/tui/app/use-prompt-draft-flow.mjs

@@ -8,6 +8,7 @@
 // hooks and their dependencies.
 import { useCallback } from 'react';
 import { slashCommandTokenForPaletteAccept } from './slash-commands.mjs';
+import { withPickerEnterLatch } from './picker-enter-latch.mjs';
 import { applyPromptDraftChange } from './use-prompt-draft-flow/draft-change.mjs';
 import { cancelProviderPromptFlow, cancelSettingsPromptFlow } from './use-prompt-draft-flow/prompt-cancels.mjs';
 
@@ -87,19 +88,9 @@ export function usePromptDraftFlow({
     (draftValue = '') => {
       const command = slashCommands[slashIndex];
       if (!command) return false;
-      pickerOpenedFromEnterRef.current = true;
-      if (pickerOpenedFromEnterTimerRef.current) {
-        clearTimeout(pickerOpenedFromEnterTimerRef.current);
-        pickerOpenedFromEnterTimerRef.current = null;
-      }
-      try {
-        return runSlashCommand(slashCommandTokenForPaletteAccept(command, draftValue), '');
-      } finally {
-        pickerOpenedFromEnterTimerRef.current = setTimeout(() => {
-          pickerOpenedFromEnterRef.current = false;
-          pickerOpenedFromEnterTimerRef.current = null;
-        }, 3000);
-      }
+      return withPickerEnterLatch(pickerOpenedFromEnterRef, pickerOpenedFromEnterTimerRef, () =>
+        runSlashCommand(slashCommandTokenForPaletteAccept(command, draftValue), '')
+      );
     },
     [slashCommands, slashIndex, pickerOpenedFromEnterRef, pickerOpenedFromEnterTimerRef, runSlashCommand]
   );

package/src/tui/app/use-prompt-layout-rows.mjs

@@ -0,0 +1,39 @@
+// Prompt / text-entry layout rows: keeps the row count of the editable prompt
+// (soft-wrapped at the content width) and of multiline core-memory text-entry
+// panels in sync with the reserved layout height.
+import { useCallback, useEffect } from 'react';
+import stringWidth from 'string-width';
+import { promptContentRows, textEntryReservedRows } from './text-layout.mjs';
+import { CORE_MULTILINE_TEXT_ENTRY_KINDS } from './panel-signature.mjs';
+
+export function usePromptLayoutRows({
+  frameColumns,
+  promptContentColumns,
+  promptLayoutValueRef,
+  setPromptLayoutRows,
+  settingsPrompt,
+  setTextEntryLayoutRows,
+}) {
+  const syncPromptLayoutRows = useCallback(
+    (value) => {
+      const text = String(value ?? '');
+      promptLayoutValueRef.current = text;
+      const nextRows = promptContentRows(text, promptContentColumns);
+      setPromptLayoutRows((prev) => (prev === nextRows ? prev : nextRows));
+    },
+    [promptContentColumns]
+  );
+  useEffect(() => {
+    syncPromptLayoutRows(promptLayoutValueRef.current);
+  }, [syncPromptLayoutRows]);
+  useEffect(() => {
+    const kind = String(settingsPrompt?.kind || '');
+    if (!CORE_MULTILINE_TEXT_ENTRY_KINDS.has(kind)) {
+      setTextEntryLayoutRows(1);
+      return;
+    }
+    const cols = Math.max(1, frameColumns - 4 - stringWidth('Sentence > '));
+    setTextEntryLayoutRows(textEntryReservedRows(settingsPrompt?.initialValue, cols, 8));
+  }, [settingsPrompt?.kind, settingsPrompt?.initialValue, frameColumns]);
+  return syncPromptLayoutRows;
+}

package/src/tui/app/use-prompt-queue-history/prompt-history.mjs

@@ -2,7 +2,7 @@
 // Local fallback for the prompt history: the engine publishes the list
 // incrementally, and only an older snapshot (no promptHistoryList) makes the
 // surface rescan the transcript itself.
-import { PROMPT_HISTORY_LIMIT } from '../transcript-window.mjs';
+import { PROMPT_HISTORY_LIMIT } from '../../prompt-history-store.mjs';
 import { promptHistoryKey } from '../app-format.mjs';
 
 /** Newest-first, de-duplicated user prompts, capped at PROMPT_HISTORY_LIMIT. */

package/src/tui/app/use-prompt-state.mjs

@@ -0,0 +1,40 @@
+/*
+ * app/use-prompt-state.mjs — the prompt draft state and the refs App shares
+ * between the prompt input, its handlers, the mouse handler and layout.
+ */
+import { useRef, useState } from 'react';
+
+export function usePromptState() {
+  const [promptDraft, setPromptDraft] = useState('');
+  const [promptDraftOverride, setPromptDraftOverride] = useState(null);
+  const promptLayoutValueRef = useRef('');
+  const [, setPromptLayoutRows] = useState(1);
+  const [textEntryLayoutRows, setTextEntryLayoutRows] = useState(1);
+  const promptValueRef = useRef('');
+  const promptSelectionRef = useRef(null);
+  // [mixdog] Prompt-box mouse selection wiring. boxRect is the editable text
+  // node's REAL absolute rect (top/left/height/contentWidth), reported by
+  // PromptInput each render; mouseSelection exposes offsetAtCell/anchorAt/
+  // extendTo/clear so the single mouse handler can drive the prompt's OWN
+  // selectionAnchor engine without the ink-grid rect path.
+  const promptBoxRectRef = useRef(null);
+  const promptMouseSelectionRef = useRef(null);
+  const promptHistoryNavRef = useRef({ active: false, index: -1, seed: '', lastValue: '' });
+  const promptHistoryDraftChangeRef = useRef(false);
+  return {
+    promptDraft,
+    setPromptDraft,
+    promptDraftOverride,
+    setPromptDraftOverride,
+    promptLayoutValueRef,
+    setPromptLayoutRows,
+    textEntryLayoutRows,
+    setTextEntryLayoutRows,
+    promptValueRef,
+    promptSelectionRef,
+    promptBoxRectRef,
+    promptMouseSelectionRef,
+    promptHistoryNavRef,
+    promptHistoryDraftChangeRef,
+  };
+}

package/src/tui/app/use-selection-paint.mjs

@@ -45,11 +45,15 @@ export function useSelectionPaint({
     // the maxFps throttle. Read selectedText only after that frame's post-write
     // acknowledgement; a 0ms timer could beat a trailing render and capture the
     // previous rect. The generation guard makes the newest selection win.
-    void yieldToRenderer().then(() => {
-      if (capture !== selectionTextCaptureRef.current) return;
-      const text = store.getRenderSelectionText?.();
-      if (text?.trim()) selectionTextRef.current = text;
-    });
+    void yieldToRenderer()
+      .then(() => {
+        if (capture !== selectionTextCaptureRef.current) return;
+        const text = store.getRenderSelectionText?.();
+        if (text?.trim()) selectionTextRef.current = text;
+      })
+      .catch(() => {
+        /* best-effort capture: Ctrl+C falls back to the render-time text */
+      });
   }, [store]);
 
   // Clip band + theming: use-selection-paint/selection-clip.mjs.

package/src/tui/app/use-transcript-scroll-state.mjs

@@ -0,0 +1,61 @@
+/*
+ * app/use-transcript-scroll-state.mjs — the transcript scroll/follow state and
+ * refs App shares between the scroll engine, the mouse handler and the
+ * transcript window. State + refs only; behavior lives in the consuming hooks.
+ */
+import { useRef, useState } from 'react';
+
+export function useTranscriptScrollState() {
+  // scrollOffset = how many transcript ROWS we've scrolled UP from the bottom
+  // (0 = pinned to the latest, showing the newest content). Mouse wheel adjusts
+  // it; accepted prompts only arm bottom-follow; the snap happens when the
+  // transcript actually grows.
+  const [scrollOffset, setScrollOffset] = useState(0);
+  const scrollPositionRef = useRef(0);
+  const scrollTargetRef = useRef(0);
+  const maxScrollRowsRef = useRef(0);
+  const transcriptBottomSlackRowsRef = useRef(0);
+  // Absolute reading-anchor lock. While the user reads older transcript, we
+  // capture the item id + row offset at the VIEWPORT TOP edge once, then re-
+  // derive scrollOffset from that anchor on every commit. Streaming tail growth
+  // (or any height change BELOW the anchor) only moves the bottom, so the top
+  // item stays pinned — no incremental drift, no jump on newline. `dirty` forces
+  // a re-capture after a manual scroll; cleared to null when we follow/pin the
+  // bottom so a fresh scroll-up starts a new anchor.
+  const transcriptAnchorRef = useRef(null);
+  const transcriptAnchorDirtyRef = useRef(false);
+  // Latest render's prefix-row table + dimensions, so a manual scroll can
+  // capture the reading anchor SYNCHRONOUSLY (in the wheel/key callback) instead
+  // of waiting for the post-commit effect — otherwise each scroll notch leaves
+  // the anchor "dirty" for one frame, and if streaming grows the transcript on
+  // that same frame the lock is not engaged yet and the view lurches.
+  const transcriptGeomRef = useRef({ prefixRows: null, totalRows: 0, viewRows: 1 });
+  // Bumped by the measured-height harvest (useTranscriptWindow) and the mouse
+  // drag-release re-measure (useMouseInput) so the row-index memo recomputes
+  // against corrected heights. Owned here because both hooks consume it.
+  const [measuredRowsVersion, setMeasuredRowsVersion] = useState(0);
+  // Auto-follow is separate from manual scroll. While true, new transcript rows
+  // (new items or streaming text wrapping to another line) are folded into the
+  // same glide back to the bottom.
+  const followingRef = useRef(false);
+  const lastItemsCountRef = useRef(0);
+  // Head item of the last committed transcript: a bulk swap (session load /
+  // clear / compaction trim) changes it, a live append never does.
+  const lastFirstItemIdRef = useRef(null);
+  return {
+    scrollOffset,
+    setScrollOffset,
+    scrollPositionRef,
+    scrollTargetRef,
+    maxScrollRowsRef,
+    transcriptBottomSlackRowsRef,
+    transcriptAnchorRef,
+    transcriptAnchorDirtyRef,
+    transcriptGeomRef,
+    measuredRowsVersion,
+    setMeasuredRowsVersion,
+    followingRef,
+    lastItemsCountRef,
+    lastFirstItemIdRef,
+  };
+}

package/src/tui/app/use-transcript-window.mjs

@@ -34,7 +34,6 @@ export function useTranscriptWindow({
   frameColumns,
   toolOutputExpanded,
   transcriptContentHeight,
-  transcriptBottomSlackRows: _transcriptBottomSlackRows,
   transcriptGuardRows,
   floatingPanelRows,
   overlayHintRequested,

package/src/tui/app/use-ui-open-request.mjs

@@ -0,0 +1,18 @@
+// Setup tool `open`: the session store publishes { command, seq } when the
+// model asks for a settings surface; each new seq runs that slash command
+// exactly as if the user had typed it (own claim, own notices).
+import { useEffect, useRef } from 'react';
+
+export function useUiOpenRequest({ uiOpenRequest, runSlashCommand }) {
+  const seenRef = useRef(0);
+  useEffect(() => {
+    const request = uiOpenRequest;
+    const seq = Number(request?.seq) || 0;
+    if (!request?.command || seq <= seenRef.current) return;
+    seenRef.current = seq;
+    // A re-attached TUI replays the retained snapshot; a request older than a
+    // few seconds is history, not an instruction.
+    if (Number(request.at) > 0 && Date.now() - Number(request.at) > 15_000) return;
+    runSlashCommand(request.command);
+  }, [uiOpenRequest, runSlashCommand]);
+}

package/src/tui/app/use-workflow-tab-cycle.mjs

@@ -0,0 +1,39 @@
+/*
+ * app/use-workflow-tab-cycle.mjs — Tab-to-cycle-workflow handler for the prompt.
+ */
+import { useCallback, useRef } from 'react';
+import { cycleWorkflowFromPrompt as cycleWorkflow } from './workflow-cycle.mjs';
+
+export function useWorkflowTabCycle({
+  store,
+  state,
+  slashPaletteOpen,
+  toolApproval,
+  picker,
+  settingsPrompt,
+  providerPrompt,
+  contextPanel,
+  usagePanel,
+}) {
+  // Holding Tab can generate key-repeat faster than a workflow switch can
+  // settle. Without a prompt-local guard every repeat starts (or rejects) an
+  // async switch and pushes a toast, producing a rapid bottom-layout repaint
+  // storm that can visually tear the prompt box in Windows Terminal.
+  const workflowTabCycleRef = useRef({ pending: false, lastAt: 0 });
+  return useCallback(() => {
+    if (slashPaletteOpen || toolApproval || picker || settingsPrompt || providerPrompt || contextPanel || usagePanel)
+      return true;
+    return cycleWorkflow({ store, state, cycleGuard: workflowTabCycleRef.current });
+  }, [
+    slashPaletteOpen,
+    toolApproval,
+    picker,
+    settingsPrompt,
+    providerPrompt,
+    contextPanel,
+    usagePanel,
+    state.commandBusy,
+    state.workflow,
+    store,
+  ]);
+}

package/src/tui/components/ContextInspector.jsx

@@ -2,7 +2,7 @@ import { useEffect, useRef, useState } from 'react';
 import { Box, Text, useInput } from 'ink';
 import wrapAnsi from 'wrap-ansi';
 import stringWidth from 'string-width';
-import { buildContextMap } from '../../ui/context-inspection.mjs';
+import { buildContextMap } from '../../runtime/shared/context-inspection.mjs';
 import { theme } from '../theme.mjs';
 
 const COLORS = {

package/src/tui/components/ContextPanel.jsx

@@ -4,7 +4,7 @@
 import { Box, Text } from 'ink';
 import stringWidth from 'string-width';
 import { theme } from '../theme.mjs';
-import { contextPercent, contextMeasurementLabel } from '../../ui/context-measurement.mjs';
+import { contextPercent, contextMeasurementLabel } from '../../runtime/shared/context-measurement.mjs';
 import { ContextInspector } from './ContextInspector.jsx';
 import { truncatePanelText as truncateText, padPanelCells as padCells } from './panel-cell-text.mjs';