@xelauvas/xela-cli 0.1.0

package/src/components/Spinner.tsx

@@ -0,0 +1,562 @@
+import { c as _c } from "react/compiler-runtime";
+// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered
+import { Box, Text } from '../ink.js';
+import * as React from 'react';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { computeGlimmerIndex, computeShimmerSegments, SHIMMER_INTERVAL_MS } from '../bridge/bridgeStatusUtil.js';
+import { feature } from 'bun:bundle';
+import { getKairosActive, getUserMsgOptIn } from '../bootstrap/state.js';
+import { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js';
+import { isEnvTruthy } from '../utils/envUtils.js';
+import { count } from '../utils/array.js';
+import sample from 'lodash-es/sample.js';
+import { formatDuration, formatNumber, formatSecondsShort } from '../utils/format.js';
+import type { Theme } from 'src/utils/theme.js';
+import { activityManager } from '../utils/activityManager.js';
+import { getSpinnerVerbs } from '../constants/spinnerVerbs.js';
+import { MessageResponse } from './MessageResponse.js';
+import { TaskListV2 } from './TaskListV2.js';
+import { useTasksV2 } from '../hooks/useTasksV2.js';
+import type { Task } from '../utils/tasks.js';
+import { useAppState } from '../state/AppState.js';
+import { useTerminalSize } from '../hooks/useTerminalSize.js';
+import { stringWidth } from '../ink/stringWidth.js';
+import { getDefaultCharacters, type SpinnerMode } from './Spinner/index.js';
+import { SpinnerAnimationRow } from './Spinner/SpinnerAnimationRow.js';
+import { useSettings } from '../hooks/useSettings.js';
+import { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js';
+import { isBackgroundTask } from '../tasks/types.js';
+import { getAllInProcessTeammateTasks } from '../tasks/InProcessTeammateTask/InProcessTeammateTask.js';
+import { getEffortSuffix } from '../utils/effort.js';
+import { getMainLoopModel } from '../utils/model/model.js';
+import { getViewedTeammateTask } from '../state/selectors.js';
+import { TEARDROP_ASTERISK } from '../constants/figures.js';
+import figures from 'figures';
+import { getCurrentTurnTokenBudget, getTurnOutputTokens } from '../bootstrap/state.js';
+import { TeammateSpinnerTree } from './Spinner/TeammateSpinnerTree.js';
+import { useAnimationFrame } from '../ink.js';
+import { getGlobalConfig } from '../utils/config.js';
+export type { SpinnerMode } from './Spinner/index.js';
+const DEFAULT_CHARACTERS = getDefaultCharacters();
+const SPINNER_FRAMES = [...DEFAULT_CHARACTERS, ...[...DEFAULT_CHARACTERS].reverse()];
+type Props = {
+  mode: SpinnerMode;
+  loadingStartTimeRef: React.RefObject<number>;
+  totalPausedMsRef: React.RefObject<number>;
+  pauseStartTimeRef: React.RefObject<number | null>;
+  spinnerTip?: string;
+  responseLengthRef: React.RefObject<number>;
+  overrideColor?: keyof Theme | null;
+  overrideShimmerColor?: keyof Theme | null;
+  overrideMessage?: string | null;
+  spinnerSuffix?: string | null;
+  verbose: boolean;
+  hasActiveTools?: boolean;
+  /** Leader's turn has completed (no active query). Used to suppress stall-red spinner when only teammates are running. */
+  leaderIsIdle?: boolean;
+};
+
+// Thin wrapper: branches on isBriefOnly so the two variants have independent
+// hook call chains. Without this split, toggling /brief mid-render would
+// violate Rules of Hooks (the inner variant calls ~10 more hooks).
+export function SpinnerWithVerb(props: Props): React.ReactNode {
+  const isBriefOnly = useAppState(s => s.isBriefOnly);
+  // REPL overrides isBriefOnly→false when viewing a teammate transcript
+  // (see isBriefOnly={viewedTeammateTask ? false : isBriefOnly}). That
+  // prop isn't threaded here, so replicate the gate from the store —
+  // teammate view needs the real spinner (which shows teammate status).
+  const viewingAgentTaskId = useAppState(s_0 => s_0.viewingAgentTaskId);
+  // Hoisted to mount-time — this component re-renders at animation framerate.
+  const briefEnvEnabled = feature('KAIROS') || feature('KAIROS_BRIEF') ?
+  // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant
+  useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_BRIEF), []) : false;
+
+  // Runtime gate mirrors isBriefEnabled() but inlined — importing from
+  // BriefTool.ts would leak tool-name strings into external builds. Single
+  // spinner instance → hooks stay unconditional (two subs, negligible).
+  if ((feature('KAIROS') || feature('KAIROS_BRIEF')) && (getKairosActive() || getUserMsgOptIn() && (briefEnvEnabled || getFeatureValue_CACHED_MAY_BE_STALE('tengu_kairos_brief', false))) && isBriefOnly && !viewingAgentTaskId) {
+    return <BriefSpinner mode={props.mode} overrideMessage={props.overrideMessage} />;
+  }
+  return <SpinnerWithVerbInner {...props} />;
+}
+function SpinnerWithVerbInner({
+  mode,
+  loadingStartTimeRef,
+  totalPausedMsRef,
+  pauseStartTimeRef,
+  spinnerTip,
+  responseLengthRef,
+  overrideColor,
+  overrideShimmerColor,
+  overrideMessage,
+  spinnerSuffix,
+  verbose,
+  hasActiveTools = false,
+  leaderIsIdle = false
+}: Props): React.ReactNode {
+  const settings = useSettings();
+  const reducedMotion = settings.prefersReducedMotion ?? false;
+
+  // NOTE: useAnimationFrame(50) lives in SpinnerAnimationRow, not here.
+  // This component only re-renders when props or app state change —
+  // it is no longer on the 50ms clock. All `time`-derived values
+  // (frame, glimmer, stalled intensity, token counter, thinking shimmer,
+  // elapsed-time timer) are computed inside the child.
+
+  const tasks = useAppState(s => s.tasks);
+  const viewingAgentTaskId = useAppState(s_0 => s_0.viewingAgentTaskId);
+  const expandedView = useAppState(s_1 => s_1.expandedView);
+  const showExpandedTodos = expandedView === 'tasks';
+  const showSpinnerTree = expandedView === 'teammates';
+  const selectedIPAgentIndex = useAppState(s_2 => s_2.selectedIPAgentIndex);
+  const viewSelectionMode = useAppState(s_3 => s_3.viewSelectionMode);
+  // Get foregrounded teammate (if viewing a teammate's transcript)
+  const foregroundedTeammate = viewingAgentTaskId ? getViewedTeammateTask({
+    viewingAgentTaskId,
+    tasks
+  }) : undefined;
+  const {
+    columns
+  } = useTerminalSize();
+  const tasksV2 = useTasksV2();
+
+  // Track thinking status: 'thinking' | number (duration in ms) | null
+  // Shows each state for minimum 2s to avoid UI jank
+  const [thinkingStatus, setThinkingStatus] = useState<'thinking' | number | null>(null);
+  const thinkingStartRef = useRef<number | null>(null);
+  useEffect(() => {
+    let showDurationTimer: ReturnType<typeof setTimeout> | null = null;
+    let clearStatusTimer: ReturnType<typeof setTimeout> | null = null;
+    if (mode === 'thinking') {
+      // Started thinking
+      if (thinkingStartRef.current === null) {
+        thinkingStartRef.current = Date.now();
+        setThinkingStatus('thinking');
+      }
+    } else if (thinkingStartRef.current !== null) {
+      // Stopped thinking - calculate duration and ensure 2s minimum display
+      const duration = Date.now() - thinkingStartRef.current;
+      const elapsed = Date.now() - thinkingStartRef.current;
+      const remainingThinkingTime = Math.max(0, 2000 - elapsed);
+      thinkingStartRef.current = null;
+
+      // Show "thinking..." for remaining time if < 2s elapsed, then show duration
+      const showDuration = (): void => {
+        setThinkingStatus(duration);
+        // Clear after 2s
+        clearStatusTimer = setTimeout(setThinkingStatus, 2000, null);
+      };
+      if (remainingThinkingTime > 0) {
+        showDurationTimer = setTimeout(showDuration, remainingThinkingTime);
+      } else {
+        showDuration();
+      }
+    }
+    return () => {
+      if (showDurationTimer) clearTimeout(showDurationTimer);
+      if (clearStatusTimer) clearTimeout(clearStatusTimer);
+    };
+  }, [mode]);
+
+  // Find the current in-progress task and next pending task
+  const currentTodo = tasksV2?.find(task => task.status !== 'pending' && task.status !== 'completed');
+  const nextTask = findNextPendingTask(tasksV2);
+
+  // Use useState with initializer to pick a random verb once on mount
+  const [randomVerb] = useState(() => sample(getSpinnerVerbs()));
+
+  // Leader's own verb (always the leader's, regardless of who is foregrounded)
+  const leaderVerb = overrideMessage ?? currentTodo?.activeForm ?? currentTodo?.subject ?? randomVerb;
+  const effectiveVerb = foregroundedTeammate && !foregroundedTeammate.isIdle ? foregroundedTeammate.spinnerVerb ?? randomVerb : leaderVerb;
+  const message = effectiveVerb + '…';
+
+  // Track CLI activity when spinner is active
+  useEffect(() => {
+    const operationId = 'spinner-' + mode;
+    activityManager.startCLIActivity(operationId);
+    return () => {
+      activityManager.endCLIActivity(operationId);
+    };
+  }, [mode]);
+  const effortValue = useAppState(s_4 => s_4.effortValue);
+  const effortSuffix = getEffortSuffix(getMainLoopModel(), effortValue);
+
+  // Check if any running in-process teammates exist (needed for both modes)
+  const runningTeammates = getAllInProcessTeammateTasks(tasks).filter(t => t.status === 'running');
+  const hasRunningTeammates = runningTeammates.length > 0;
+  const allIdle = hasRunningTeammates && runningTeammates.every(t_0 => t_0.isIdle);
+
+  // Gather aggregate token stats from all running swarm teammates
+  // In spinner-tree mode, skip aggregation (teammates have their own lines in the tree)
+  let teammateTokens = 0;
+  if (!showSpinnerTree) {
+    for (const task_0 of Object.values(tasks)) {
+      if (isInProcessTeammateTask(task_0) && task_0.status === 'running') {
+        if (task_0.progress?.tokenCount) {
+          teammateTokens += task_0.progress.tokenCount;
+        }
+      }
+    }
+  }
+
+  // Stale read of the refs for showBtwTip below — we're off the 50ms clock
+  // so this only updates when props/app state change, which is sufficient for
+  // a coarse 30s threshold.
+  const elapsedSnapshot = pauseStartTimeRef.current !== null ? pauseStartTimeRef.current - loadingStartTimeRef.current - totalPausedMsRef.current : Date.now() - loadingStartTimeRef.current - totalPausedMsRef.current;
+
+  // Leader token count for TeammateSpinnerTree — read raw (non-animated) from
+  // the ref. The tree is only shown when teammates are running; teammate
+  // progress updates to s.tasks trigger re-renders that keep this fresh.
+  const leaderTokenCount = Math.round(responseLengthRef.current / 4);
+  const defaultColor: keyof Theme = 'claude';
+  const defaultShimmerColor = 'claudeShimmer';
+  const messageColor = overrideColor ?? defaultColor;
+  const shimmerColor = overrideShimmerColor ?? defaultShimmerColor;
+
+  // Compute TTFT string here (off the 50ms animation clock) and pass to
+  // SpinnerAnimationRow so it folds into the `(thought for Ns · ...)` status
+  // line instead of taking a separate row. apiMetricsRef is a ref so this
+  // doesn't trigger re-renders; we pick up updates on the parent's ~25x/turn
+  // re-render cadence, same as the old ApiMetricsLine did.
+  let ttftText: string | null = null;
+  if ("external" === 'ant' && apiMetricsRef?.current && apiMetricsRef.current.length > 0) {
+    ttftText = computeTtftText(apiMetricsRef.current);
+  }
+
+  // When leader is idle but teammates are running (and we're viewing the leader),
+  // show a static dim idle display instead of the animated spinner — otherwise
+  // useStalledAnimation detects no new tokens after 3s and turns the spinner red.
+  if (leaderIsIdle && hasRunningTeammates && !foregroundedTeammate) {
+    return <Box flexDirection="column" width="100%" alignItems="flex-start">
+        <Box flexDirection="row" flexWrap="wrap" marginTop={1} width="100%">
+          <Text dimColor>
+            {TEARDROP_ASTERISK} Idle
+            {!allIdle && ' · teammates running'}
+          </Text>
+        </Box>
+        {showSpinnerTree && <TeammateSpinnerTree selectedIndex={selectedIPAgentIndex} isInSelectionMode={viewSelectionMode === 'selecting-agent'} allIdle={allIdle} leaderTokenCount={leaderTokenCount} leaderIdleText="Idle" />}
+      </Box>;
+  }
+
+  // When viewing an idle teammate, show static idle display instead of animated spinner
+  if (foregroundedTeammate?.isIdle) {
+    const idleText = allIdle ? `${TEARDROP_ASTERISK} Worked for ${formatDuration(Date.now() - foregroundedTeammate.startTime)}` : `${TEARDROP_ASTERISK} Idle`;
+    return <Box flexDirection="column" width="100%" alignItems="flex-start">
+        <Box flexDirection="row" flexWrap="wrap" marginTop={1} width="100%">
+          <Text dimColor>{idleText}</Text>
+        </Box>
+        {showSpinnerTree && hasRunningTeammates && <TeammateSpinnerTree selectedIndex={selectedIPAgentIndex} isInSelectionMode={viewSelectionMode === 'selecting-agent'} allIdle={allIdle} leaderVerb={leaderIsIdle ? undefined : leaderVerb} leaderIdleText={leaderIsIdle ? 'Idle' : undefined} leaderTokenCount={leaderTokenCount} />}
+      </Box>;
+  }
+
+  // Time-based tip overrides: coarse thresholds so a stale ref read (we're
+  // off the 50ms clock) is fine. Other triggers (mode change, setMessages)
+  // cause re-renders that refresh this in practice.
+  let contextTipsActive = false;
+  const tipsEnabled = settings.spinnerTipsEnabled !== false;
+  const showClearTip = tipsEnabled && elapsedSnapshot > 1_800_000;
+  const showBtwTip = tipsEnabled && elapsedSnapshot > 30_000 && !getGlobalConfig().btwUseCount;
+  const effectiveTip = contextTipsActive ? undefined : showClearTip && !nextTask ? 'Use /clear to start fresh when switching topics and free up context' : showBtwTip && !nextTask ? "Use /btw to ask a quick side question without interrupting Claude's current work" : spinnerTip;
+
+  // Budget text (ant-only) — shown above the tip line
+  let budgetText: string | null = null;
+  if (feature('TOKEN_BUDGET')) {
+    const budget = getCurrentTurnTokenBudget();
+    if (budget !== null && budget > 0) {
+      const tokens = getTurnOutputTokens();
+      if (tokens >= budget) {
+        budgetText = `Target: ${formatNumber(tokens)} used (${formatNumber(budget)} min ${figures.tick})`;
+      } else {
+        const pct = Math.round(tokens / budget * 100);
+        const remaining = budget - tokens;
+        const rate = elapsedSnapshot > 5000 && tokens >= 2000 ? tokens / elapsedSnapshot : 0;
+        const eta = rate > 0 ? ` \u00B7 ~${formatDuration(remaining / rate, {
+          mostSignificantOnly: true
+        })}` : '';
+        budgetText = `Target: ${formatNumber(tokens)} / ${formatNumber(budget)} (${pct}%)${eta}`;
+      }
+    }
+  }
+  return <Box flexDirection="column" width="100%" alignItems="flex-start">
+      <SpinnerAnimationRow mode={mode} reducedMotion={reducedMotion} hasActiveTools={hasActiveTools} responseLengthRef={responseLengthRef} message={message} messageColor={messageColor} shimmerColor={shimmerColor} overrideColor={overrideColor} loadingStartTimeRef={loadingStartTimeRef} totalPausedMsRef={totalPausedMsRef} pauseStartTimeRef={pauseStartTimeRef} spinnerSuffix={spinnerSuffix} verbose={verbose} columns={columns} hasRunningTeammates={hasRunningTeammates} teammateTokens={teammateTokens} foregroundedTeammate={foregroundedTeammate} leaderIsIdle={leaderIsIdle} thinkingStatus={thinkingStatus} effortSuffix={effortSuffix} />
+      {showSpinnerTree && hasRunningTeammates ? <TeammateSpinnerTree selectedIndex={selectedIPAgentIndex} isInSelectionMode={viewSelectionMode === 'selecting-agent'} allIdle={allIdle} leaderVerb={leaderIsIdle ? undefined : leaderVerb} leaderIdleText={leaderIsIdle ? 'Idle' : undefined} leaderTokenCount={leaderTokenCount} /> : showExpandedTodos && tasksV2 && tasksV2.length > 0 ? <Box width="100%" flexDirection="column">
+          <MessageResponse>
+            <TaskListV2 tasks={tasksV2} />
+          </MessageResponse>
+        </Box> : nextTask || effectiveTip || budgetText ?
+    // IMPORTANT: we need this width="100%" to avoid an Ink bug where the
+    // tip gets duplicated over and over while the spinner is running if
+    // the terminal is very small. TODO: fix this in Ink.
+    <Box width="100%" flexDirection="column">
+          {budgetText && <MessageResponse>
+              <Text dimColor>{budgetText}</Text>
+            </MessageResponse>}
+          {(nextTask || effectiveTip) && <MessageResponse>
+              <Text dimColor>
+                {nextTask ? `Next: ${nextTask.subject}` : `Tip: ${effectiveTip}`}
+              </Text>
+            </MessageResponse>}
+        </Box> : null}
+    </Box>;
+}
+
+// Brief/assistant mode spinner: single status line. PromptInput drops its
+// own marginTop when isBriefOnly is active, so this component owns the
+// 2-row footprint between messages and input. Footprint is [blank, content]
+// — one blank row above (breathing room under the messages list), spinner
+// flush against the input bar. PromptInput's absolute-positioned
+// Notifications overlay compensates with marginTop=-2 in brief mode
+// (PromptInput.tsx:~2928) so it floats into the blank row above the
+// spinner, not over the spinner content. Paired with BriefIdleStatus which
+// keeps the same footprint when idle.
+type BriefSpinnerProps = {
+  mode: SpinnerMode;
+  overrideMessage?: string | null;
+};
+function BriefSpinner(t0) {
+  const $ = _c(31);
+  const {
+    mode,
+    overrideMessage
+  } = t0;
+  const settings = useSettings();
+  const reducedMotion = settings.prefersReducedMotion ?? false;
+  const [randomVerb] = useState(_temp4);
+  const verb = overrideMessage ?? randomVerb;
+  const connStatus = useAppState(_temp5);
+  let t1;
+  let t2;
+  if ($[0] !== mode) {
+    t1 = () => {
+      const operationId = "spinner-" + mode;
+      activityManager.startCLIActivity(operationId);
+      return () => {
+        activityManager.endCLIActivity(operationId);
+      };
+    };
+    t2 = [mode];
+    $[0] = mode;
+    $[1] = t1;
+    $[2] = t2;
+  } else {
+    t1 = $[1];
+    t2 = $[2];
+  }
+  useEffect(t1, t2);
+  const [, time] = useAnimationFrame(reducedMotion ? null : 120);
+  const runningCount = useAppState(_temp6);
+  const showConnWarning = connStatus === "reconnecting" || connStatus === "disconnected";
+  const connText = connStatus === "reconnecting" ? "Reconnecting" : "Disconnected";
+  const dotFrame = Math.floor(time / 300) % 3;
+  let t3;
+  if ($[3] !== dotFrame || $[4] !== reducedMotion) {
+    t3 = reducedMotion ? "\u2026  " : ".".repeat(dotFrame + 1).padEnd(3);
+    $[3] = dotFrame;
+    $[4] = reducedMotion;
+    $[5] = t3;
+  } else {
+    t3 = $[5];
+  }
+  const dots = t3;
+  let t4;
+  if ($[6] !== verb) {
+    t4 = stringWidth(verb);
+    $[6] = verb;
+    $[7] = t4;
+  } else {
+    t4 = $[7];
+  }
+  const verbWidth = t4;
+  let t5;
+  if ($[8] !== reducedMotion || $[9] !== showConnWarning || $[10] !== time || $[11] !== verb || $[12] !== verbWidth) {
+    const glimmerIndex = reducedMotion || showConnWarning ? -100 : computeGlimmerIndex(Math.floor(time / SHIMMER_INTERVAL_MS), verbWidth);
+    t5 = computeShimmerSegments(verb, glimmerIndex);
+    $[8] = reducedMotion;
+    $[9] = showConnWarning;
+    $[10] = time;
+    $[11] = verb;
+    $[12] = verbWidth;
+    $[13] = t5;
+  } else {
+    t5 = $[13];
+  }
+  const {
+    before,
+    shimmer,
+    after
+  } = t5;
+  const {
+    columns
+  } = useTerminalSize();
+  const rightText = runningCount > 0 ? `${runningCount} in background` : "";
+  let t6;
+  if ($[14] !== connText || $[15] !== showConnWarning || $[16] !== verbWidth) {
+    t6 = showConnWarning ? stringWidth(connText) : verbWidth;
+    $[14] = connText;
+    $[15] = showConnWarning;
+    $[16] = verbWidth;
+    $[17] = t6;
+  } else {
+    t6 = $[17];
+  }
+  const leftWidth = t6 + 3;
+  const pad = Math.max(1, columns - 2 - leftWidth - stringWidth(rightText));
+  let t7;
+  if ($[18] !== after || $[19] !== before || $[20] !== connText || $[21] !== dots || $[22] !== shimmer || $[23] !== showConnWarning) {
+    t7 = showConnWarning ? <Text color="error">{connText + dots}</Text> : <>{before ? <Text dimColor={true}>{before}</Text> : null}{shimmer ? <Text>{shimmer}</Text> : null}{after ? <Text dimColor={true}>{after}</Text> : null}<Text dimColor={true}>{dots}</Text></>;
+    $[18] = after;
+    $[19] = before;
+    $[20] = connText;
+    $[21] = dots;
+    $[22] = shimmer;
+    $[23] = showConnWarning;
+    $[24] = t7;
+  } else {
+    t7 = $[24];
+  }
+  let t8;
+  if ($[25] !== pad || $[26] !== rightText) {
+    t8 = rightText ? <><Text>{" ".repeat(pad)}</Text><Text color="subtle">{rightText}</Text></> : null;
+    $[25] = pad;
+    $[26] = rightText;
+    $[27] = t8;
+  } else {
+    t8 = $[27];
+  }
+  let t9;
+  if ($[28] !== t7 || $[29] !== t8) {
+    t9 = <Box flexDirection="row" width="100%" marginTop={1} paddingLeft={2}>{t7}{t8}</Box>;
+    $[28] = t7;
+    $[29] = t8;
+    $[30] = t9;
+  } else {
+    t9 = $[30];
+  }
+  return t9;
+}
+
+// Idle placeholder for brief mode. Same 2-row [blank, content] footprint
+// as BriefSpinner so the input bar never jumps when toggling between
+// working/idle/disconnected. See BriefSpinner's comment for the
+// Notifications overlay coupling.
+function _temp6(s_0) {
+  return count(Object.values(s_0.tasks), isBackgroundTask) + s_0.remoteBackgroundTaskCount;
+}
+function _temp5(s) {
+  return s.remoteConnectionStatus;
+}
+function _temp4() {
+  return sample(getSpinnerVerbs()) ?? "Working";
+}
+export function BriefIdleStatus() {
+  const $ = _c(9);
+  const connStatus = useAppState(_temp7);
+  const runningCount = useAppState(_temp8);
+  const {
+    columns
+  } = useTerminalSize();
+  const showConnWarning = connStatus === "reconnecting" || connStatus === "disconnected";
+  const connText = connStatus === "reconnecting" ? "Reconnecting\u2026" : "Disconnected";
+  const leftText = showConnWarning ? connText : "";
+  const rightText = runningCount > 0 ? `${runningCount} in background` : "";
+  if (!leftText && !rightText) {
+    let t0;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t0 = <Box height={2} />;
+      $[0] = t0;
+    } else {
+      t0 = $[0];
+    }
+    return t0;
+  }
+  const pad = Math.max(1, columns - 2 - stringWidth(leftText) - stringWidth(rightText));
+  let t0;
+  if ($[1] !== leftText) {
+    t0 = leftText ? <Text color="error">{leftText}</Text> : null;
+    $[1] = leftText;
+    $[2] = t0;
+  } else {
+    t0 = $[2];
+  }
+  let t1;
+  if ($[3] !== pad || $[4] !== rightText) {
+    t1 = rightText ? <><Text>{" ".repeat(pad)}</Text><Text color="subtle">{rightText}</Text></> : null;
+    $[3] = pad;
+    $[4] = rightText;
+    $[5] = t1;
+  } else {
+    t1 = $[5];
+  }
+  let t2;
+  if ($[6] !== t0 || $[7] !== t1) {
+    t2 = <Box marginTop={1} paddingLeft={2}><Text>{t0}{t1}</Text></Box>;
+    $[6] = t0;
+    $[7] = t1;
+    $[8] = t2;
+  } else {
+    t2 = $[8];
+  }
+  return t2;
+}
+function _temp8(s_0) {
+  return count(Object.values(s_0.tasks), isBackgroundTask) + s_0.remoteBackgroundTaskCount;
+}
+function _temp7(s) {
+  return s.remoteConnectionStatus;
+}
+export function Spinner() {
+  const $ = _c(8);
+  const settings = useSettings();
+  const reducedMotion = settings.prefersReducedMotion ?? false;
+  const [ref, time] = useAnimationFrame(reducedMotion ? null : 120);
+  if (reducedMotion) {
+    let t0;
+    if ($[0] === Symbol.for("react.memo_cache_sentinel")) {
+      t0 = <Text color="text">●</Text>;
+      $[0] = t0;
+    } else {
+      t0 = $[0];
+    }
+    let t1;
+    if ($[1] !== ref) {
+      t1 = <Box ref={ref} flexWrap="wrap" height={1} width={2}>{t0}</Box>;
+      $[1] = ref;
+      $[2] = t1;
+    } else {
+      t1 = $[2];
+    }
+    return t1;
+  }
+  const frame = Math.floor(time / 120) % SPINNER_FRAMES.length;
+  const t0 = SPINNER_FRAMES[frame];
+  let t1;
+  if ($[3] !== t0) {
+    t1 = <Text color="text">{t0}</Text>;
+    $[3] = t0;
+    $[4] = t1;
+  } else {
+    t1 = $[4];
+  }
+  let t2;
+  if ($[5] !== ref || $[6] !== t1) {
+    t2 = <Box ref={ref} flexWrap="wrap" height={1} width={2}>{t1}</Box>;
+    $[5] = ref;
+    $[6] = t1;
+    $[7] = t2;
+  } else {
+    t2 = $[7];
+  }
+  return t2;
+}
+function findNextPendingTask(tasks: Task[] | undefined): Task | undefined {
+  if (!tasks) {
+    return undefined;
+  }
+  const pendingTasks = tasks.filter(t => t.status === 'pending');
+  if (pendingTasks.length === 0) {
+    return undefined;
+  }
+  const unresolvedIds = new Set(tasks.filter(t => t.status !== 'completed').map(t => t.id));
+  return pendingTasks.find(t => !t.blockedBy.some(id => unresolvedIds.has(id))) ?? pendingTasks[0];
+}
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["Box","Text","React","useEffect","useMemo","useRef","useState","computeGlimmerIndex","computeShimmerSegments","SHIMMER_INTERVAL_MS","feature","getKairosActive","getUserMsgOptIn","getFeatureValue_CACHED_MAY_BE_STALE","isEnvTruthy","count","sample","formatDuration","formatNumber","formatSecondsShort","Theme","activityManager","getSpinnerVerbs","MessageResponse","TaskListV2","useTasksV2","Task","useAppState","useTerminalSize","stringWidth","getDefaultCharacters","SpinnerMode","SpinnerAnimationRow","useSettings","isInProcessTeammateTask","isBackgroundTask","getAllInProcessTeammateTasks","getEffortSuffix","getMainLoopModel","getViewedTeammateTask","TEARDROP_ASTERISK","figures","getCurrentTurnTokenBudget","getTurnOutputTokens","TeammateSpinnerTree","useAnimationFrame","getGlobalConfig","DEFAULT_CHARACTERS","SPINNER_FRAMES","reverse","Props","mode","loadingStartTimeRef","RefObject","totalPausedMsRef","pauseStartTimeRef","spinnerTip","responseLengthRef","overrideColor","overrideShimmerColor","overrideMessage","spinnerSuffix","verbose","hasActiveTools","leaderIsIdle","SpinnerWithVerb","props","ReactNode","isBriefOnly","s","viewingAgentTaskId","briefEnvEnabled","process","env","CLAUDE_CODE_BRIEF","SpinnerWithVerbInner","settings","reducedMotion","prefersReducedMotion","tasks","expandedView","showExpandedTodos","showSpinnerTree","selectedIPAgentIndex","viewSelectionMode","foregroundedTeammate","undefined","columns","tasksV2","thinkingStatus","setThinkingStatus","thinkingStartRef","showDurationTimer","ReturnType","setTimeout","clearStatusTimer","current","Date","now","duration","elapsed","remainingThinkingTime","Math","max","showDuration","clearTimeout","currentTodo","find","task","status","nextTask","findNextPendingTask","randomVerb","leaderVerb","activeForm","subject","effectiveVerb","isIdle","spinnerVerb","message","operationId","startCLIActivity","endCLIActivity","effortValue","effortSuffix","runningTeammates","filter","t","hasRunningTeammates","length","allIdle","every","teammateTokens","Object","values","progress","tokenCount","elapsedSnapshot","leaderTokenCount","round","defaultColor","defaultShimmerColor","messageColor","shimmerColor","ttftText","apiMetricsRef","computeTtftText","idleText","startTime","contextTipsActive","tipsEnabled","spinnerTipsEnabled","showClearTip","showBtwTip","btwUseCount","effectiveTip","budgetText","budget","tokens","tick","pct","remaining","rate","eta","mostSignificantOnly","BriefSpinnerProps","BriefSpinner","t0","$","_c","_temp4","verb","connStatus","_temp5","t1","t2","time","runningCount","_temp6","showConnWarning","connText","dotFrame","floor","t3","repeat","padEnd","dots","t4","verbWidth","t5","glimmerIndex","before","shimmer","after","rightText","t6","leftWidth","pad","t7","t8","t9","s_0","remoteBackgroundTaskCount","remoteConnectionStatus","BriefIdleStatus","_temp7","_temp8","leftText","Symbol","for","Spinner","ref","frame","pendingTasks","unresolvedIds","Set","map","id","blockedBy","some","has"],"sources":["Spinner.tsx"],"sourcesContent":["// biome-ignore-all assist/source/organizeImports: ANT-ONLY import markers must not be reordered\nimport { Box, Text } from '../ink.js'\nimport * as React from 'react'\nimport { useEffect, useMemo, useRef, useState } from 'react'\nimport {\n  computeGlimmerIndex,\n  computeShimmerSegments,\n  SHIMMER_INTERVAL_MS,\n} from '../bridge/bridgeStatusUtil.js'\nimport { feature } from 'bun:bundle'\nimport { getKairosActive, getUserMsgOptIn } from '../bootstrap/state.js'\nimport { getFeatureValue_CACHED_MAY_BE_STALE } from '../services/analytics/growthbook.js'\nimport { isEnvTruthy } from '../utils/envUtils.js'\nimport { count } from '../utils/array.js'\nimport sample from 'lodash-es/sample.js'\nimport {\n  formatDuration,\n  formatNumber,\n  formatSecondsShort,\n} from '../utils/format.js'\nimport type { Theme } from 'src/utils/theme.js'\nimport { activityManager } from '../utils/activityManager.js'\nimport { getSpinnerVerbs } from '../constants/spinnerVerbs.js'\nimport { MessageResponse } from './MessageResponse.js'\nimport { TaskListV2 } from './TaskListV2.js'\nimport { useTasksV2 } from '../hooks/useTasksV2.js'\nimport type { Task } from '../utils/tasks.js'\nimport { useAppState } from '../state/AppState.js'\nimport { useTerminalSize } from '../hooks/useTerminalSize.js'\nimport { stringWidth } from '../ink/stringWidth.js'\nimport { getDefaultCharacters, type SpinnerMode } from './Spinner/index.js'\nimport { SpinnerAnimationRow } from './Spinner/SpinnerAnimationRow.js'\nimport { useSettings } from '../hooks/useSettings.js'\nimport { isInProcessTeammateTask } from '../tasks/InProcessTeammateTask/types.js'\nimport { isBackgroundTask } from '../tasks/types.js'\nimport { getAllInProcessTeammateTasks } from '../tasks/InProcessTeammateTask/InProcessTeammateTask.js'\nimport { getEffortSuffix } from '../utils/effort.js'\nimport { getMainLoopModel } from '../utils/model/model.js'\nimport { getViewedTeammateTask } from '../state/selectors.js'\nimport { TEARDROP_ASTERISK } from '../constants/figures.js'\nimport figures from 'figures'\nimport {\n  getCurrentTurnTokenBudget,\n  getTurnOutputTokens,\n} from '../bootstrap/state.js'\n\nimport { TeammateSpinnerTree } from './Spinner/TeammateSpinnerTree.js'\nimport { useAnimationFrame } from '../ink.js'\nimport { getGlobalConfig } from '../utils/config.js'\nexport type { SpinnerMode } from './Spinner/index.js'\n\nconst DEFAULT_CHARACTERS = getDefaultCharacters()\n\nconst SPINNER_FRAMES = [\n  ...DEFAULT_CHARACTERS,\n  ...[...DEFAULT_CHARACTERS].reverse(),\n]\n\n\ntype Props = {\n  mode: SpinnerMode\n  loadingStartTimeRef: React.RefObject<number>\n  totalPausedMsRef: React.RefObject<number>\n  pauseStartTimeRef: React.RefObject<number | null>\n  spinnerTip?: string\n  responseLengthRef: React.RefObject<number>\n  overrideColor?: keyof Theme | null\n  overrideShimmerColor?: keyof Theme | null\n  overrideMessage?: string | null\n  spinnerSuffix?: string | null\n  verbose: boolean\n  hasActiveTools?: boolean\n  /** Leader's turn has completed (no active query). Used to suppress stall-red spinner when only teammates are running. */\n  leaderIsIdle?: boolean\n}\n\n// Thin wrapper: branches on isBriefOnly so the two variants have independent\n// hook call chains. Without this split, toggling /brief mid-render would\n// violate Rules of Hooks (the inner variant calls ~10 more hooks).\nexport function SpinnerWithVerb(props: Props): React.ReactNode {\n  const isBriefOnly = useAppState(s => s.isBriefOnly)\n  // REPL overrides isBriefOnly→false when viewing a teammate transcript\n  // (see isBriefOnly={viewedTeammateTask ? false : isBriefOnly}). That\n  // prop isn't threaded here, so replicate the gate from the store —\n  // teammate view needs the real spinner (which shows teammate status).\n  const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId)\n  // Hoisted to mount-time — this component re-renders at animation framerate.\n  const briefEnvEnabled =\n    feature('KAIROS') || feature('KAIROS_BRIEF')\n      ? // biome-ignore lint/correctness/useHookAtTopLevel: feature() is a compile-time constant\n        useMemo(() => isEnvTruthy(process.env.CLAUDE_CODE_BRIEF), [])\n      : false\n\n  // Runtime gate mirrors isBriefEnabled() but inlined — importing from\n  // BriefTool.ts would leak tool-name strings into external builds. Single\n  // spinner instance → hooks stay unconditional (two subs, negligible).\n  if (\n    (feature('KAIROS') || feature('KAIROS_BRIEF')) &&\n    (getKairosActive() ||\n      (getUserMsgOptIn() &&\n        (briefEnvEnabled ||\n          getFeatureValue_CACHED_MAY_BE_STALE('tengu_kairos_brief', false)))) &&\n    isBriefOnly &&\n    !viewingAgentTaskId\n  ) {\n    return (\n      <BriefSpinner mode={props.mode} overrideMessage={props.overrideMessage} />\n    )\n  }\n\n  return <SpinnerWithVerbInner {...props} />\n}\n\nfunction SpinnerWithVerbInner({\n  mode,\n  loadingStartTimeRef,\n  totalPausedMsRef,\n  pauseStartTimeRef,\n  spinnerTip,\n  responseLengthRef,\n  overrideColor,\n  overrideShimmerColor,\n  overrideMessage,\n  spinnerSuffix,\n  verbose,\n  hasActiveTools = false,\n  leaderIsIdle = false,\n}: Props): React.ReactNode {\n  const settings = useSettings()\n  const reducedMotion = settings.prefersReducedMotion ?? false\n\n  // NOTE: useAnimationFrame(50) lives in SpinnerAnimationRow, not here.\n  // This component only re-renders when props or app state change —\n  // it is no longer on the 50ms clock. All `time`-derived values\n  // (frame, glimmer, stalled intensity, token counter, thinking shimmer,\n  // elapsed-time timer) are computed inside the child.\n\n  const tasks = useAppState(s => s.tasks)\n  const viewingAgentTaskId = useAppState(s => s.viewingAgentTaskId)\n  const expandedView = useAppState(s => s.expandedView)\n  const showExpandedTodos = expandedView === 'tasks'\n  const showSpinnerTree = expandedView === 'teammates'\n  const selectedIPAgentIndex = useAppState(s => s.selectedIPAgentIndex)\n  const viewSelectionMode = useAppState(s => s.viewSelectionMode)\n  // Get foregrounded teammate (if viewing a teammate's transcript)\n  const foregroundedTeammate = viewingAgentTaskId\n    ? getViewedTeammateTask({ viewingAgentTaskId, tasks })\n    : undefined\n  const { columns } = useTerminalSize()\n  const tasksV2 = useTasksV2()\n\n  // Track thinking status: 'thinking' | number (duration in ms) | null\n  // Shows each state for minimum 2s to avoid UI jank\n  const [thinkingStatus, setThinkingStatus] = useState<\n    'thinking' | number | null\n  >(null)\n  const thinkingStartRef = useRef<number | null>(null)\n\n  useEffect(() => {\n    let showDurationTimer: ReturnType<typeof setTimeout> | null = null\n    let clearStatusTimer: ReturnType<typeof setTimeout> | null = null\n\n    if (mode === 'thinking') {\n      // Started thinking\n      if (thinkingStartRef.current === null) {\n        thinkingStartRef.current = Date.now()\n        setThinkingStatus('thinking')\n      }\n    } else if (thinkingStartRef.current !== null) {\n      // Stopped thinking - calculate duration and ensure 2s minimum display\n      const duration = Date.now() - thinkingStartRef.current\n      const elapsed = Date.now() - thinkingStartRef.current\n      const remainingThinkingTime = Math.max(0, 2000 - elapsed)\n\n      thinkingStartRef.current = null\n\n      // Show \"thinking...\" for remaining time if < 2s elapsed, then show duration\n      const showDuration = (): void => {\n        setThinkingStatus(duration)\n        // Clear after 2s\n        clearStatusTimer = setTimeout(setThinkingStatus, 2000, null)\n      }\n\n      if (remainingThinkingTime > 0) {\n        showDurationTimer = setTimeout(showDuration, remainingThinkingTime)\n      } else {\n        showDuration()\n      }\n    }\n\n    return () => {\n      if (showDurationTimer) clearTimeout(showDurationTimer)\n      if (clearStatusTimer) clearTimeout(clearStatusTimer)\n    }\n  }, [mode])\n\n  // Find the current in-progress task and next pending task\n  const currentTodo = tasksV2?.find(\n    task => task.status !== 'pending' && task.status !== 'completed',\n  )\n  const nextTask = findNextPendingTask(tasksV2)\n\n  // Use useState with initializer to pick a random verb once on mount\n  const [randomVerb] = useState(() => sample(getSpinnerVerbs()))\n\n  // Leader's own verb (always the leader's, regardless of who is foregrounded)\n  const leaderVerb =\n    overrideMessage ??\n    currentTodo?.activeForm ??\n    currentTodo?.subject ??\n    randomVerb\n\n  const effectiveVerb =\n    foregroundedTeammate && !foregroundedTeammate.isIdle\n      ? (foregroundedTeammate.spinnerVerb ?? randomVerb)\n      : leaderVerb\n  const message = effectiveVerb + '…'\n\n  // Track CLI activity when spinner is active\n  useEffect(() => {\n    const operationId = 'spinner-' + mode\n    activityManager.startCLIActivity(operationId)\n    return () => {\n      activityManager.endCLIActivity(operationId)\n    }\n  }, [mode])\n\n  const effortValue = useAppState(s => s.effortValue)\n  const effortSuffix = getEffortSuffix(getMainLoopModel(), effortValue)\n\n  // Check if any running in-process teammates exist (needed for both modes)\n  const runningTeammates = getAllInProcessTeammateTasks(tasks).filter(\n    t => t.status === 'running',\n  )\n  const hasRunningTeammates = runningTeammates.length > 0\n  const allIdle = hasRunningTeammates && runningTeammates.every(t => t.isIdle)\n\n  // Gather aggregate token stats from all running swarm teammates\n  // In spinner-tree mode, skip aggregation (teammates have their own lines in the tree)\n  let teammateTokens = 0\n  if (!showSpinnerTree) {\n    for (const task of Object.values(tasks)) {\n      if (isInProcessTeammateTask(task) && task.status === 'running') {\n        if (task.progress?.tokenCount) {\n          teammateTokens += task.progress.tokenCount\n        }\n      }\n    }\n  }\n\n  // Stale read of the refs for showBtwTip below — we're off the 50ms clock\n  // so this only updates when props/app state change, which is sufficient for\n  // a coarse 30s threshold.\n  const elapsedSnapshot =\n    pauseStartTimeRef.current !== null\n      ? pauseStartTimeRef.current -\n        loadingStartTimeRef.current -\n        totalPausedMsRef.current\n      : Date.now() - loadingStartTimeRef.current - totalPausedMsRef.current\n\n  // Leader token count for TeammateSpinnerTree — read raw (non-animated) from\n  // the ref. The tree is only shown when teammates are running; teammate\n  // progress updates to s.tasks trigger re-renders that keep this fresh.\n  const leaderTokenCount = Math.round(responseLengthRef.current / 4)\n\n  const defaultColor: keyof Theme = 'claude'\n  const defaultShimmerColor = 'claudeShimmer'\n  const messageColor = overrideColor ?? defaultColor\n  const shimmerColor = overrideShimmerColor ?? defaultShimmerColor\n\n  // Compute TTFT string here (off the 50ms animation clock) and pass to\n  // SpinnerAnimationRow so it folds into the `(thought for Ns · ...)` status\n  // line instead of taking a separate row. apiMetricsRef is a ref so this\n  // doesn't trigger re-renders; we pick up updates on the parent's ~25x/turn\n  // re-render cadence, same as the old ApiMetricsLine did.\n  let ttftText: string | null = null\n  if (\n    \"external\" === 'ant' &&\n    apiMetricsRef?.current &&\n    apiMetricsRef.current.length > 0\n  ) {\n    ttftText = computeTtftText(apiMetricsRef.current)\n  }\n\n  // When leader is idle but teammates are running (and we're viewing the leader),\n  // show a static dim idle display instead of the animated spinner — otherwise\n  // useStalledAnimation detects no new tokens after 3s and turns the spinner red.\n  if (leaderIsIdle && hasRunningTeammates && !foregroundedTeammate) {\n    return (\n      <Box flexDirection=\"column\" width=\"100%\" alignItems=\"flex-start\">\n        <Box flexDirection=\"row\" flexWrap=\"wrap\" marginTop={1} width=\"100%\">\n          <Text dimColor>\n            {TEARDROP_ASTERISK} Idle\n            {!allIdle && ' · teammates running'}\n          </Text>\n        </Box>\n        {showSpinnerTree && (\n          <TeammateSpinnerTree\n            selectedIndex={selectedIPAgentIndex}\n            isInSelectionMode={viewSelectionMode === 'selecting-agent'}\n            allIdle={allIdle}\n            leaderTokenCount={leaderTokenCount}\n            leaderIdleText=\"Idle\"\n          />\n        )}\n      </Box>\n    )\n  }\n\n  // When viewing an idle teammate, show static idle display instead of animated spinner\n  if (foregroundedTeammate?.isIdle) {\n    const idleText = allIdle\n      ? `${TEARDROP_ASTERISK} Worked for ${formatDuration(Date.now() - foregroundedTeammate.startTime)}`\n      : `${TEARDROP_ASTERISK} Idle`\n    return (\n      <Box flexDirection=\"column\" width=\"100%\" alignItems=\"flex-start\">\n        <Box flexDirection=\"row\" flexWrap=\"wrap\" marginTop={1} width=\"100%\">\n          <Text dimColor>{idleText}</Text>\n        </Box>\n        {showSpinnerTree && hasRunningTeammates && (\n          <TeammateSpinnerTree\n            selectedIndex={selectedIPAgentIndex}\n            isInSelectionMode={viewSelectionMode === 'selecting-agent'}\n            allIdle={allIdle}\n            leaderVerb={leaderIsIdle ? undefined : leaderVerb}\n            leaderIdleText={leaderIsIdle ? 'Idle' : undefined}\n            leaderTokenCount={leaderTokenCount}\n          />\n        )}\n      </Box>\n    )\n  }\n\n  // Time-based tip overrides: coarse thresholds so a stale ref read (we're\n  // off the 50ms clock) is fine. Other triggers (mode change, setMessages)\n  // cause re-renders that refresh this in practice.\n  let contextTipsActive = false\n  const tipsEnabled = settings.spinnerTipsEnabled !== false\n  const showClearTip = tipsEnabled && elapsedSnapshot > 1_800_000\n  const showBtwTip =\n    tipsEnabled && elapsedSnapshot > 30_000 && !getGlobalConfig().btwUseCount\n\n  const effectiveTip = contextTipsActive\n    ? undefined\n    : showClearTip && !nextTask\n      ? 'Use /clear to start fresh when switching topics and free up context'\n      : showBtwTip && !nextTask\n        ? \"Use /btw to ask a quick side question without interrupting Claude's current work\"\n        : spinnerTip\n\n  // Budget text (ant-only) — shown above the tip line\n  let budgetText: string | null = null\n  if (feature('TOKEN_BUDGET')) {\n    const budget = getCurrentTurnTokenBudget()\n    if (budget !== null && budget > 0) {\n      const tokens = getTurnOutputTokens()\n      if (tokens >= budget) {\n        budgetText = `Target: ${formatNumber(tokens)} used (${formatNumber(budget)} min ${figures.tick})`\n      } else {\n        const pct = Math.round((tokens / budget) * 100)\n        const remaining = budget - tokens\n        const rate =\n          elapsedSnapshot > 5000 && tokens >= 2000\n            ? tokens / elapsedSnapshot\n            : 0\n        const eta =\n          rate > 0\n            ? ` \\u00B7 ~${formatDuration(remaining / rate, { mostSignificantOnly: true })}`\n            : ''\n        budgetText = `Target: ${formatNumber(tokens)} / ${formatNumber(budget)} (${pct}%)${eta}`\n      }\n    }\n  }\n\n  return (\n    <Box flexDirection=\"column\" width=\"100%\" alignItems=\"flex-start\">\n      <SpinnerAnimationRow\n        mode={mode}\n        reducedMotion={reducedMotion}\n        hasActiveTools={hasActiveTools}\n        responseLengthRef={responseLengthRef}\n        message={message}\n        messageColor={messageColor}\n        shimmerColor={shimmerColor}\n        overrideColor={overrideColor}\n        loadingStartTimeRef={loadingStartTimeRef}\n        totalPausedMsRef={totalPausedMsRef}\n        pauseStartTimeRef={pauseStartTimeRef}\n        spinnerSuffix={spinnerSuffix}\n        verbose={verbose}\n        columns={columns}\n        hasRunningTeammates={hasRunningTeammates}\n        teammateTokens={teammateTokens}\n        foregroundedTeammate={foregroundedTeammate}\n        leaderIsIdle={leaderIsIdle}\n        thinkingStatus={thinkingStatus}\n        effortSuffix={effortSuffix}\n      />\n      {showSpinnerTree && hasRunningTeammates ? (\n        <TeammateSpinnerTree\n          selectedIndex={selectedIPAgentIndex}\n          isInSelectionMode={viewSelectionMode === 'selecting-agent'}\n          allIdle={allIdle}\n          leaderVerb={leaderIsIdle ? undefined : leaderVerb}\n          leaderIdleText={leaderIsIdle ? 'Idle' : undefined}\n          leaderTokenCount={leaderTokenCount}\n        />\n      ) : showExpandedTodos && tasksV2 && tasksV2.length > 0 ? (\n        <Box width=\"100%\" flexDirection=\"column\">\n          <MessageResponse>\n            <TaskListV2 tasks={tasksV2} />\n          </MessageResponse>\n        </Box>\n      ) : nextTask || effectiveTip || budgetText ? (\n        // IMPORTANT: we need this width=\"100%\" to avoid an Ink bug where the\n        // tip gets duplicated over and over while the spinner is running if\n        // the terminal is very small. TODO: fix this in Ink.\n        <Box width=\"100%\" flexDirection=\"column\">\n          {budgetText && (\n            <MessageResponse>\n              <Text dimColor>{budgetText}</Text>\n            </MessageResponse>\n          )}\n          {(nextTask || effectiveTip) && (\n            <MessageResponse>\n              <Text dimColor>\n                {nextTask\n                  ? `Next: ${nextTask.subject}`\n                  : `Tip: ${effectiveTip}`}\n              </Text>\n            </MessageResponse>\n          )}\n        </Box>\n      ) : null}\n    </Box>\n  )\n}\n\n// Brief/assistant mode spinner: single status line. PromptInput drops its\n// own marginTop when isBriefOnly is active, so this component owns the\n// 2-row footprint between messages and input. Footprint is [blank, content]\n// — one blank row above (breathing room under the messages list), spinner\n// flush against the input bar. PromptInput's absolute-positioned\n// Notifications overlay compensates with marginTop=-2 in brief mode\n// (PromptInput.tsx:~2928) so it floats into the blank row above the\n// spinner, not over the spinner content. Paired with BriefIdleStatus which\n// keeps the same footprint when idle.\ntype BriefSpinnerProps = {\n  mode: SpinnerMode\n  overrideMessage?: string | null\n}\n\nfunction BriefSpinner({\n  mode,\n  overrideMessage,\n}: BriefSpinnerProps): React.ReactNode {\n  const settings = useSettings()\n  const reducedMotion = settings.prefersReducedMotion ?? false\n  const [randomVerb] = useState(() => sample(getSpinnerVerbs()) ?? 'Working')\n  const verb = overrideMessage ?? randomVerb\n  const connStatus = useAppState(s => s.remoteConnectionStatus)\n\n  // Track CLI activity so OS/IDE \"busy\" indicators fire in brief mode too\n  useEffect(() => {\n    const operationId = 'spinner-' + mode\n    activityManager.startCLIActivity(operationId)\n    return () => {\n      activityManager.endCLIActivity(operationId)\n    }\n  }, [mode])\n\n  // Drive both dot cycle and shimmer from the shared clock. The viewport\n  // ref is unused — the spinner unmounts on turn end so viewport-based\n  // pausing isn't needed.\n  const [, time] = useAnimationFrame(reducedMotion ? null : 120)\n\n  // Local tasks + remote tasks are mutually exclusive (viewer mode has an\n  // empty local AppState.tasks; local mode has remoteBackgroundTaskCount=0).\n  // Summing avoids a mode branch.\n  const runningCount = useAppState(\n    s =>\n      count(Object.values(s.tasks), isBackgroundTask) +\n      s.remoteBackgroundTaskCount,\n  )\n\n  // Connection trouble overrides the verb — `claude assistant` is a pure viewer,\n  // nothing useful is happening while the WS is down.\n  const showConnWarning =\n    connStatus === 'reconnecting' || connStatus === 'disconnected'\n  const connText =\n    connStatus === 'reconnecting' ? 'Reconnecting' : 'Disconnected'\n\n  // Dots padded to a fixed 3 columns so the right-aligned count doesn't\n  // jitter as the cycle advances.\n  const dotFrame = Math.floor(time / 300) % 3\n  const dots = reducedMotion ? '…  ' : '.'.repeat(dotFrame + 1).padEnd(3)\n\n  // Shimmer: reverse-sweep highlight across the verb. Skip for connection\n  // warnings (shimmer reads as \"working\"; Reconnecting/Disconnected is not).\n  const verbWidth = useMemo(() => stringWidth(verb), [verb])\n  const glimmerIndex =\n    reducedMotion || showConnWarning\n      ? -100\n      : computeGlimmerIndex(Math.floor(time / SHIMMER_INTERVAL_MS), verbWidth)\n  const { before, shimmer, after } = computeShimmerSegments(verb, glimmerIndex)\n\n  const { columns } = useTerminalSize()\n  const rightText = runningCount > 0 ? `${runningCount} in background` : ''\n  // Manual right-align via space padding — flexGrow spacers inside\n  // FullscreenLayout's `main` slot don't resolve a width and caused the\n  // diff engine to miss dot-frame updates.\n  const leftWidth = (showConnWarning ? stringWidth(connText) : verbWidth) + 3\n  const pad = Math.max(1, columns - 2 - leftWidth - stringWidth(rightText))\n\n  return (\n    <Box flexDirection=\"row\" width=\"100%\" marginTop={1} paddingLeft={2}>\n      {showConnWarning ? (\n        <Text color=\"error\">{connText + dots}</Text>\n      ) : (\n        <>\n          {before ? <Text dimColor>{before}</Text> : null}\n          {shimmer ? <Text>{shimmer}</Text> : null}\n          {after ? <Text dimColor>{after}</Text> : null}\n          <Text dimColor>{dots}</Text>\n        </>\n      )}\n      {rightText ? (\n        <>\n          <Text>{' '.repeat(pad)}</Text>\n          <Text color=\"subtle\">{rightText}</Text>\n        </>\n      ) : null}\n    </Box>\n  )\n}\n\n// Idle placeholder for brief mode. Same 2-row [blank, content] footprint\n// as BriefSpinner so the input bar never jumps when toggling between\n// working/idle/disconnected. See BriefSpinner's comment for the\n// Notifications overlay coupling.\nexport function BriefIdleStatus(): React.ReactNode {\n  const connStatus = useAppState(s => s.remoteConnectionStatus)\n  const runningCount = useAppState(\n    s =>\n      count(Object.values(s.tasks), isBackgroundTask) +\n      s.remoteBackgroundTaskCount,\n  )\n  const { columns } = useTerminalSize()\n\n  const showConnWarning =\n    connStatus === 'reconnecting' || connStatus === 'disconnected'\n  const connText =\n    connStatus === 'reconnecting' ? 'Reconnecting…' : 'Disconnected'\n  const leftText = showConnWarning ? connText : ''\n  const rightText = runningCount > 0 ? `${runningCount} in background` : ''\n\n  if (!leftText && !rightText) return <Box height={2} />\n\n  const pad = Math.max(\n    1,\n    columns - 2 - stringWidth(leftText) - stringWidth(rightText),\n  )\n  return (\n    <Box marginTop={1} paddingLeft={2}>\n      <Text>\n        {leftText ? <Text color=\"error\">{leftText}</Text> : null}\n        {rightText ? (\n          <>\n            <Text>{' '.repeat(pad)}</Text>\n            <Text color=\"subtle\">{rightText}</Text>\n          </>\n        ) : null}\n      </Text>\n    </Box>\n  )\n}\n\nexport function Spinner(): React.ReactNode {\n  const settings = useSettings()\n  const reducedMotion = settings.prefersReducedMotion ?? false\n  const [ref, time] = useAnimationFrame(reducedMotion ? null : 120)\n\n  // Reduced motion: static dot instead of animated spinner\n  if (reducedMotion) {\n    return (\n      <Box ref={ref} flexWrap=\"wrap\" height={1} width={2}>\n        <Text color=\"text\">●</Text>\n      </Box>\n    )\n  }\n\n  // Derive frame from synced time - all spinners animate together\n  const frame = Math.floor(time / 120) % SPINNER_FRAMES.length\n\n  return (\n    <Box ref={ref} flexWrap=\"wrap\" height={1} width={2}>\n      <Text color=\"text\">{SPINNER_FRAMES[frame]}</Text>\n    </Box>\n  )\n}\n\n\nfunction findNextPendingTask(tasks: Task[] | undefined): Task | undefined {\n  if (!tasks) {\n    return undefined\n  }\n  const pendingTasks = tasks.filter(t => t.status === 'pending')\n  if (pendingTasks.length === 0) {\n    return undefined\n  }\n  const unresolvedIds = new Set(\n    tasks.filter(t => t.status !== 'completed').map(t => t.id),\n  )\n  return (\n    pendingTasks.find(t => !t.blockedBy.some(id => unresolvedIds.has(id))) ??\n    pendingTasks[0]\n  )\n}\n"],"mappings":"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","ignoreList":[]}