@within-7/minto 0.4.2 → 0.4.3

package/dist/hooks/useAgentEngine.js

@@ -1,129 +0,0 @@
-import { useState, useEffect, useRef, useCallback, useMemo } from "react";
-function useAgentEngine(engine) {
-  const [messages, setMessagesState] = useState([]);
-  const [isLoading, setIsLoading] = useState(false);
-  const [engineState, setEngineState] = useState("created");
-  const [lastTurnDurationMs, setLastTurnDurationMs] = useState(
-    null
-  );
-  const engineRef = useRef(engine);
-  engineRef.current = engine;
-  const pendingMessagesRef = useRef([]);
-  const timerRef = useRef(null);
-  const prevEngineRef = useRef(engine);
-  if (prevEngineRef.current !== engine) {
-    prevEngineRef.current = engine;
-    if (engine) {
-      setMessagesState([...engine.messages]);
-      setEngineState(engine.state);
-      setIsLoading(engine.state === "querying");
-    } else {
-      setMessagesState([]);
-      setEngineState("created");
-      setIsLoading(false);
-    }
-    setLastTurnDurationMs(null);
-    pendingMessagesRef.current = [];
-    if (timerRef.current) {
-      clearImmediate(timerRef.current);
-      timerRef.current = null;
-    }
-  }
-  const flushMessages = useCallback(() => {
-    if (pendingMessagesRef.current.length === 0) return;
-    const batch = pendingMessagesRef.current.splice(0);
-    setMessagesState((prev) => [...prev, ...batch]);
-  }, []);
-  useEffect(() => {
-    if (!engine) return () => {
-    };
-    setMessagesState([...engine.messages]);
-    setEngineState(engine.state);
-    setIsLoading(engine.state === "querying");
-    const handleEvent = (event) => {
-      switch (event.type) {
-        case "state_change":
-          setEngineState(event.to);
-          setIsLoading(event.to === "querying");
-          break;
-        case "message":
-          pendingMessagesRef.current.push(event.message);
-          if (!timerRef.current) {
-            timerRef.current = setImmediate(() => {
-              timerRef.current = null;
-              flushMessages();
-            });
-          }
-          break;
-        case "messages_set":
-          pendingMessagesRef.current = [];
-          if (timerRef.current) {
-            clearImmediate(timerRef.current);
-            timerRef.current = null;
-          }
-          setMessagesState([...event.messages]);
-          if (event.messages.length === 0) {
-            setLastTurnDurationMs(null);
-          }
-          break;
-        case "turn_start":
-          setLastTurnDurationMs(null);
-          break;
-        case "turn_end":
-          setLastTurnDurationMs(event.durationMs);
-          flushMessages();
-          break;
-        case "error":
-          flushMessages();
-          break;
-      }
-    };
-    const unsub = engine.on(handleEvent);
-    return () => {
-      unsub();
-      if (timerRef.current) {
-        clearImmediate(timerRef.current);
-        timerRef.current = null;
-      }
-      flushMessages();
-    };
-  }, [engine, flushMessages]);
-  const submitPrompt = useCallback(async (input) => {
-    await engineRef.current?.submitPrompt(input);
-  }, []);
-  const abort = useCallback(() => {
-    engineRef.current?.abort();
-  }, []);
-  const setMessages = useCallback((msgs) => {
-    engineRef.current?.setMessages(msgs);
-  }, []);
-  const appendMessages = useCallback((msgs) => {
-    engineRef.current?.appendMessages(msgs);
-  }, []);
-  return useMemo(
-    () => ({
-      messages,
-      isLoading,
-      engineState,
-      lastTurnDurationMs,
-      submitPrompt,
-      abort,
-      setMessages,
-      appendMessages
-    }),
-    [
-      messages,
-      isLoading,
-      engineState,
-      lastTurnDurationMs,
-      submitPrompt,
-      abort,
-      setMessages,
-      appendMessages
-    ]
-  );
-}
-export {
-  useAgentEngine
-};
-//# sourceMappingURL=useAgentEngine.js.map

package/dist/hooks/useAgentEngine.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useAgentEngine.ts"],
-  "sourcesContent": ["/**\n * useAgentEngine \u2014 React bridge for AgentEngine events.\n *\n * Subscribes to an AgentEngine's event stream and provides\n * React-compatible state for rendering. Uses batched updates\n * to minimize render churn during high-frequency message streams.\n */\n\nimport { useState, useEffect, useRef, useCallback, useMemo } from 'react'\nimport type { AgentEngine } from '../engine/AgentEngine'\nimport type { EngineState, EngineEvent } from '../engine/types'\nimport type { Message } from '@query'\n\nexport interface UseAgentEngineResult {\n  /** Current messages from the engine. */\n  messages: Message[]\n  /** Whether the engine is currently querying. */\n  isLoading: boolean\n  /** Current engine state. */\n  engineState: EngineState\n  /** Duration of the last completed turn in ms, or null if no turn completed yet. */\n  lastTurnDurationMs: number | null\n  /** Submit user input to the engine. Delegates to engine.submitPrompt(). */\n  submitPrompt: (input: string | Message[]) => Promise<void>\n  /** Abort the current query. Delegates to engine.abort(). */\n  abort: () => void\n  /** Replace the messages array (e.g., for rollback). Delegates to engine.setMessages(). */\n  setMessages: (messages: Message[]) => void\n  /** Append messages without triggering a query. Delegates to engine.appendMessages(). */\n  appendMessages: (messages: Message[]) => void\n}\n\n/**\n * React hook that bridges AgentEngine events to React state.\n *\n * @param engine - The AgentEngine instance to subscribe to, or null.\n * @returns Reactive state derived from engine events, plus stable callbacks.\n */\nexport function useAgentEngine(\n  engine: AgentEngine | null,\n): UseAgentEngineResult {\n  const [messages, setMessagesState] = useState<Message[]>([])\n  const [isLoading, setIsLoading] = useState(false)\n  const [engineState, setEngineState] = useState<EngineState>('created')\n  const [lastTurnDurationMs, setLastTurnDurationMs] = useState<number | null>(\n    null,\n  )\n\n  // Keep a ref to the engine for stable callbacks\n  const engineRef = useRef(engine)\n  engineRef.current = engine\n\n  // Batch buffer: accumulate messages and flush on next tick.\n  // Uses setImmediate (Node.js/Bun) instead of requestAnimationFrame (browser-only)\n  // to ensure messages flush reliably in CLI environments.\n  const pendingMessagesRef = useRef<Message[]>([])\n  const timerRef = useRef<ReturnType<typeof setImmediate> | null>(null)\n\n  // \u2500\u2500 Synchronous state sync when engine parameter changes \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\n  // React 18+ \"adjusting state based on props\" pattern.\n  //\n  // Without this, there's a one-render-cycle delay: the first render after\n  // an engine switch still uses the OLD engine's messages (because useEffect\n  // hasn't fired yet). If a <Static> component is recreated (via forkNumber\n  // key change) during that render, it permanently writes the stale messages\n  // to the terminal. Then useEffect fires, syncing new messages, which get\n  // appended \u2014 resulting in duplicated content.\n  //\n  // By syncing during render, React discards the stale render and immediately\n  // retries with correct state, ensuring <Static> only sees the new engine.\n  const prevEngineRef = useRef(engine)\n  if (prevEngineRef.current !== engine) {\n    prevEngineRef.current = engine\n    if (engine) {\n      setMessagesState([...engine.messages])\n      setEngineState(engine.state)\n      setIsLoading(engine.state === 'querying')\n    } else {\n      setMessagesState([])\n      setEngineState('created')\n      setIsLoading(false)\n    }\n    setLastTurnDurationMs(null)\n    // Clear any pending batched messages from the old engine.\n    // Without this, stale messages from the old engine's event stream\n    // could flush into the new engine's message list.\n    pendingMessagesRef.current = []\n    if (timerRef.current) {\n      clearImmediate(timerRef.current)\n      timerRef.current = null\n    }\n  }\n\n  const flushMessages = useCallback(() => {\n    if (pendingMessagesRef.current.length === 0) return\n    const batch = pendingMessagesRef.current.splice(0)\n    setMessagesState(prev => [...prev, ...batch])\n  }, [])\n\n  useEffect(() => {\n    if (!engine) return () => {}\n\n    // Sync initial state\n    setMessagesState([...engine.messages])\n    setEngineState(engine.state)\n    setIsLoading(engine.state === 'querying')\n\n    const handleEvent = (event: EngineEvent) => {\n      switch (event.type) {\n        case 'state_change':\n          setEngineState(event.to)\n          setIsLoading(event.to === 'querying')\n          break\n\n        case 'message':\n          // Batch messages for efficient rendering\n          pendingMessagesRef.current.push(event.message)\n          if (!timerRef.current) {\n            timerRef.current = setImmediate(() => {\n              timerRef.current = null\n              flushMessages()\n            })\n          }\n          break\n\n        case 'messages_set':\n          // Full replacement \u2014 flush any pending and set directly\n          pendingMessagesRef.current = []\n          if (timerRef.current) {\n            clearImmediate(timerRef.current)\n            timerRef.current = null\n          }\n          setMessagesState([...event.messages])\n          // Reset turn duration when conversation is cleared (empty messages)\n          if (event.messages.length === 0) {\n            setLastTurnDurationMs(null)\n          }\n          break\n\n        case 'turn_start':\n          setLastTurnDurationMs(null)\n          break\n\n        case 'turn_end':\n          setLastTurnDurationMs(event.durationMs)\n          // Flush any remaining batched messages\n          flushMessages()\n          break\n\n        case 'error':\n          // Flush messages so error context is visible\n          flushMessages()\n          break\n      }\n    }\n\n    const unsub = engine.on(handleEvent)\n\n    return () => {\n      unsub()\n      // Flush remaining messages on cleanup\n      if (timerRef.current) {\n        clearImmediate(timerRef.current)\n        timerRef.current = null\n      }\n      flushMessages()\n    }\n  }, [engine, flushMessages])\n\n  // \u2500\u2500 Stable callbacks that delegate to the current engine \u2500\u2500\n\n  const submitPrompt = useCallback(async (input: string | Message[]) => {\n    await engineRef.current?.submitPrompt(input)\n  }, [])\n\n  const abort = useCallback(() => {\n    engineRef.current?.abort()\n  }, [])\n\n  const setMessages = useCallback((msgs: Message[]) => {\n    engineRef.current?.setMessages(msgs)\n  }, [])\n\n  const appendMessages = useCallback((msgs: Message[]) => {\n    engineRef.current?.appendMessages(msgs)\n  }, [])\n\n  return useMemo(\n    () => ({\n      messages,\n      isLoading,\n      engineState,\n      lastTurnDurationMs,\n      submitPrompt,\n      abort,\n      setMessages,\n      appendMessages,\n    }),\n    [\n      messages,\n      isLoading,\n      engineState,\n      lastTurnDurationMs,\n      submitPrompt,\n      abort,\n      setMessages,\n      appendMessages,\n    ],\n  )\n}\n"],
-  "mappings": "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",
-  "names": []
-}

package/dist/hooks/useAgentTokenStats.js

@@ -1,56 +0,0 @@
-import { useState, useEffect } from "react";
-import { tokenStatsManager } from "../core/tokenStatsManager.js";
-function useAgentTokenStats(agentId) {
-  const [stats, setStats] = useState(() => {
-    if (!agentId) return null;
-    return tokenStatsManager.getAgentStats(agentId);
-  });
-  useEffect(() => {
-    if (!agentId) {
-      setStats(null);
-      return void 0;
-    }
-    const initialStats = tokenStatsManager.getAgentStats(agentId);
-    if (initialStats) {
-      setStats(initialStats);
-    }
-    const unsubscribe = tokenStatsManager.onAgentStatsUpdate(
-      agentId,
-      (newStats) => {
-        setStats(newStats);
-      }
-    );
-    return unsubscribe;
-  }, [agentId]);
-  return stats;
-}
-function useGlobalTokenStats() {
-  const [stats, setStats] = useState(
-    () => tokenStatsManager.getGlobalStats()
-  );
-  useEffect(() => {
-    const unsubscribe = tokenStatsManager.onGlobalStatsUpdate((newStats) => {
-      setStats(newStats);
-    });
-    return unsubscribe;
-  }, []);
-  return stats;
-}
-function useAllAgentTokenStats() {
-  const [stats, setStats] = useState(
-    () => tokenStatsManager.getAllAgentStats()
-  );
-  useEffect(() => {
-    const unsubscribe = tokenStatsManager.onStatsUpdate((event) => {
-      setStats(tokenStatsManager.getAllAgentStats());
-    });
-    return unsubscribe;
-  }, []);
-  return stats;
-}
-export {
-  useAgentTokenStats,
-  useAllAgentTokenStats,
-  useGlobalTokenStats
-};
-//# sourceMappingURL=useAgentTokenStats.js.map

package/dist/hooks/useAgentTokenStats.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useAgentTokenStats.ts"],
-  "sourcesContent": ["/**\n * useAgentTokenStats Hook\n *\n * Provides real-time access to token statistics for a specific agent.\n * Subscribes to TokenStatsManager events for automatic updates.\n *\n * Usage:\n * ```tsx\n * function SubagentDisplay({ agentId }) {\n *   const stats = useAgentTokenStats(agentId)\n *\n *   if (!stats) return <Text>Loading...</Text>\n *\n *   return (\n *     <Text>\n *       {stats.grandTotalTokens.toLocaleString()} tokens\n *     </Text>\n *   )\n * }\n * ```\n */\n\nimport { useState, useEffect, useCallback } from 'react'\nimport { tokenStatsManager } from '@core/tokenStatsManager'\nimport type { AggregatedTokenStats } from '@core/tokenStats'\n\n/**\n * Hook for accessing token statistics for a specific agent\n *\n * @param agentId - The agent ID to track\n * @returns Current token statistics or null if not found\n */\nexport function useAgentTokenStats(\n  agentId: string | undefined,\n): AggregatedTokenStats | null {\n  const [stats, setStats] = useState<AggregatedTokenStats | null>(() => {\n    if (!agentId) return null\n    return tokenStatsManager.getAgentStats(agentId)\n  })\n\n  useEffect(() => {\n    if (!agentId) {\n      setStats(null)\n      return undefined\n    }\n\n    // Get initial stats\n    const initialStats = tokenStatsManager.getAgentStats(agentId)\n    if (initialStats) {\n      setStats(initialStats)\n    }\n\n    // Subscribe to updates\n    const unsubscribe = tokenStatsManager.onAgentStatsUpdate(\n      agentId,\n      newStats => {\n        setStats(newStats)\n      },\n    )\n\n    return unsubscribe\n  }, [agentId])\n\n  return stats\n}\n\n/**\n * Hook for accessing global token statistics\n *\n * @returns Current global token statistics\n */\nexport function useGlobalTokenStats(): AggregatedTokenStats {\n  const [stats, setStats] = useState<AggregatedTokenStats>(() =>\n    tokenStatsManager.getGlobalStats(),\n  )\n\n  useEffect(() => {\n    // Subscribe to global updates\n    const unsubscribe = tokenStatsManager.onGlobalStatsUpdate(newStats => {\n      setStats(newStats)\n    })\n\n    return unsubscribe\n  }, [])\n\n  return stats\n}\n\n/**\n * Hook for accessing all agent statistics\n *\n * @returns Map of agentId to token statistics\n */\nexport function useAllAgentTokenStats(): Map<string, AggregatedTokenStats> {\n  const [stats, setStats] = useState<Map<string, AggregatedTokenStats>>(() =>\n    tokenStatsManager.getAllAgentStats(),\n  )\n\n  useEffect(() => {\n    // Subscribe to all updates\n    const unsubscribe = tokenStatsManager.onStatsUpdate(event => {\n      // Refresh the entire map on any update\n      setStats(tokenStatsManager.getAllAgentStats())\n    })\n\n    return unsubscribe\n  }, [])\n\n  return stats\n}\n"],
-  "mappings": "AAsBA,SAAS,UAAU,iBAA8B;AACjD,SAAS,yBAAyB;AAS3B,SAAS,mBACd,SAC6B;AAC7B,QAAM,CAAC,OAAO,QAAQ,IAAI,SAAsC,MAAM;AACpE,QAAI,CAAC,QAAS,QAAO;AACrB,WAAO,kBAAkB,cAAc,OAAO;AAAA,EAChD,CAAC;AAED,YAAU,MAAM;AACd,QAAI,CAAC,SAAS;AACZ,eAAS,IAAI;AACb,aAAO;AAAA,IACT;AAGA,UAAM,eAAe,kBAAkB,cAAc,OAAO;AAC5D,QAAI,cAAc;AAChB,eAAS,YAAY;AAAA,IACvB;AAGA,UAAM,cAAc,kBAAkB;AAAA,MACpC;AAAA,MACA,cAAY;AACV,iBAAS,QAAQ;AAAA,MACnB;AAAA,IACF;AAEA,WAAO;AAAA,EACT,GAAG,CAAC,OAAO,CAAC;AAEZ,SAAO;AACT;AAOO,SAAS,sBAA4C;AAC1D,QAAM,CAAC,OAAO,QAAQ,IAAI;AAAA,IAA+B,MACvD,kBAAkB,eAAe;AAAA,EACnC;AAEA,YAAU,MAAM;AAEd,UAAM,cAAc,kBAAkB,oBAAoB,cAAY;AACpE,eAAS,QAAQ;AAAA,IACnB,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAOO,SAAS,wBAA2D;AACzE,QAAM,CAAC,OAAO,QAAQ,IAAI;AAAA,IAA4C,MACpE,kBAAkB,iBAAiB;AAAA,EACrC;AAEA,YAAU,MAAM;AAEd,UAAM,cAAc,kBAAkB,cAAc,WAAS;AAE3D,eAAS,kBAAkB,iBAAiB,CAAC;AAAA,IAC/C,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;",
-  "names": []
-}

package/dist/hooks/useAgentTranscripts.js

@@ -1,141 +0,0 @@
-import { useState, useEffect, useMemo, useCallback, useRef } from "react";
-import {
-  transcriptEmitter,
-  getAgentTranscript
-} from "../utils/agentTranscripts.js";
-function useAgentTranscripts(agentIds) {
-  const [transcripts, setTranscripts] = useState(
-    () => /* @__PURE__ */ new Map()
-  );
-  const lazyLoadCacheRef = useRef(/* @__PURE__ */ new Map());
-  const syncScheduledRef = useRef(false);
-  const trackedAgentIds = useMemo(
-    () => agentIds ? new Set(agentIds) : null,
-    [agentIds?.join(",")]
-  );
-  useEffect(() => {
-    const handleUpdate = (event) => {
-      if (trackedAgentIds && !trackedAgentIds.has(event.agentId)) {
-        return;
-      }
-      setTranscripts((prev) => {
-        const next = new Map(prev);
-        next.set(event.agentId, event.transcript);
-        return next;
-      });
-    };
-    transcriptEmitter.on("update", handleUpdate);
-    if (trackedAgentIds) {
-      for (const agentId of trackedAgentIds) {
-        const transcript = getAgentTranscript(agentId);
-        if (transcript) {
-          setTranscripts((prev) => {
-            const next = new Map(prev);
-            next.set(agentId, transcript);
-            return next;
-          });
-        }
-      }
-    }
-    return () => {
-      transcriptEmitter.off("update", handleUpdate);
-    };
-  }, [trackedAgentIds]);
-  const getTranscriptCallback = useCallback(
-    (agentId) => {
-      const cached = transcripts.get(agentId);
-      if (cached) {
-        return cached;
-      }
-      const lazyCached = lazyLoadCacheRef.current.get(agentId);
-      if (lazyCached) {
-        return lazyCached;
-      }
-      const loaded = getAgentTranscript(agentId);
-      if (loaded) {
-        lazyLoadCacheRef.current.set(agentId, loaded);
-      }
-      return loaded;
-    },
-    [transcripts]
-  );
-  useEffect(() => {
-    if (lazyLoadCacheRef.current.size > 0 && !syncScheduledRef.current) {
-      syncScheduledRef.current = true;
-      const timeoutId = setTimeout(() => {
-        setTranscripts((prev) => {
-          const next = new Map(prev);
-          for (const [agentId, transcript] of lazyLoadCacheRef.current) {
-            if (!next.has(agentId)) {
-              next.set(agentId, transcript);
-            }
-          }
-          return next;
-        });
-        lazyLoadCacheRef.current = /* @__PURE__ */ new Map();
-        syncScheduledRef.current = false;
-      }, 0);
-      return () => {
-        clearTimeout(timeoutId);
-        syncScheduledRef.current = false;
-      };
-    }
-    return void 0;
-  }, [transcripts]);
-  const refreshTranscript = useCallback((agentId) => {
-    const fresh = getAgentTranscript(agentId);
-    if (fresh) {
-      setTranscripts((prev) => {
-        const next = new Map(prev);
-        next.set(agentId, fresh);
-        return next;
-      });
-    }
-  }, []);
-  const activeCount = useMemo(() => {
-    let count = 0;
-    for (const transcript of transcripts.values()) {
-      if (transcript.status === "running" || transcript.status === "pending") {
-        count++;
-      }
-    }
-    return count;
-  }, [transcripts]);
-  return {
-    transcripts,
-    getTranscript: getTranscriptCallback,
-    refreshTranscript,
-    activeCount
-  };
-}
-function useAgentTranscript(agentId) {
-  const [transcript, setTranscript] = useState(() => {
-    if (!agentId) return null;
-    return getAgentTranscript(agentId);
-  });
-  useEffect(() => {
-    if (!agentId) {
-      setTranscript(null);
-      return void 0;
-    }
-    const initial = getAgentTranscript(agentId);
-    if (initial) {
-      setTranscript(initial);
-    }
-    const handleUpdate = (event) => {
-      if (event.agentId === agentId) {
-        setTranscript(event.transcript);
-      }
-    };
-    transcriptEmitter.on("update", handleUpdate);
-    return () => {
-      transcriptEmitter.off("update", handleUpdate);
-    };
-  }, [agentId]);
-  return transcript;
-}
-export {
-  useAgentTranscript,
-  useAgentTranscripts
-};
-//# sourceMappingURL=useAgentTranscripts.js.map

package/dist/hooks/useAgentTranscripts.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useAgentTranscripts.ts"],
-  "sourcesContent": ["/**\n * useAgentTranscripts Hook\n *\n * Provides real-time access to agent transcripts with automatic updates.\n * Subscribes to transcript events and maintains a reactive map of transcripts.\n */\n\nimport { useState, useEffect, useMemo, useCallback, useRef } from 'react'\nimport {\n  transcriptEmitter,\n  getAgentTranscript,\n  type AgentTranscript,\n  type TranscriptEvent,\n} from '@utils/agentTranscripts'\n\ninterface UseAgentTranscriptsResult {\n  /** Map of agentId to transcript */\n  transcripts: Map<string, AgentTranscript>\n  /** Get transcript by agentId */\n  getTranscript: (agentId: string) => AgentTranscript | null\n  /** Force refresh of a specific transcript */\n  refreshTranscript: (agentId: string) => void\n  /** Number of active transcripts */\n  activeCount: number\n}\n\n/**\n * Hook for accessing agent transcripts with real-time updates\n *\n * @param agentIds - Optional list of specific agent IDs to track\n * @returns Transcript state and utilities\n */\nexport function useAgentTranscripts(\n  agentIds?: string[],\n): UseAgentTranscriptsResult {\n  // State to hold current transcripts\n  const [transcripts, setTranscripts] = useState<Map<string, AgentTranscript>>(\n    () => new Map(),\n  )\n\n  // Ref-based cache for lazy loading during render (avoids setState during render)\n  // This allows getTranscript to return cached values synchronously without triggering re-renders\n  const lazyLoadCacheRef = useRef<Map<string, AgentTranscript>>(new Map())\n\n  // Prevent duplicate sync scheduling - avoids infinite render loops\n  const syncScheduledRef = useRef<boolean>(false)\n\n  // Track which agents we're interested in\n  const trackedAgentIds = useMemo(\n    () => (agentIds ? new Set(agentIds) : null),\n    [agentIds?.join(',')],\n  )\n\n  // Handle transcript updates\n  useEffect(() => {\n    const handleUpdate = (event: TranscriptEvent) => {\n      // If we have a tracked list and this agent isn't in it, skip\n      if (trackedAgentIds && !trackedAgentIds.has(event.agentId)) {\n        return\n      }\n\n      setTranscripts(prev => {\n        const next = new Map(prev)\n        next.set(event.agentId, event.transcript)\n        return next\n      })\n    }\n\n    // Subscribe to all transcript updates\n    transcriptEmitter.on('update', handleUpdate)\n\n    // Initial load for tracked agents\n    if (trackedAgentIds) {\n      for (const agentId of trackedAgentIds) {\n        const transcript = getAgentTranscript(agentId)\n        if (transcript) {\n          setTranscripts(prev => {\n            const next = new Map(prev)\n            next.set(agentId, transcript)\n            return next\n          })\n        }\n      }\n    }\n\n    return () => {\n      transcriptEmitter.off('update', handleUpdate)\n    }\n  }, [trackedAgentIds])\n\n  // Get transcript by ID (with fallback to disk)\n  // IMPORTANT: This function may be called during render (e.g., by ParallelTasksGroupView),\n  // so we must NOT call setTranscripts here. Instead, we use a ref-based cache for lazy loading\n  // and schedule state updates via useEffect.\n  const getTranscriptCallback = useCallback(\n    (agentId: string): AgentTranscript | null => {\n      // Check state first (reactive updates)\n      const cached = transcripts.get(agentId)\n      if (cached) {\n        return cached\n      }\n\n      // Check ref cache (lazy loaded during render)\n      const lazyCached = lazyLoadCacheRef.current.get(agentId)\n      if (lazyCached) {\n        return lazyCached\n      }\n\n      // Try to load from disk - store in ref only (no setState during render!)\n      const loaded = getAgentTranscript(agentId)\n      if (loaded) {\n        lazyLoadCacheRef.current.set(agentId, loaded)\n      }\n      return loaded\n    },\n    [transcripts],\n  )\n\n  // Sync lazy-loaded transcripts from ref cache to state after render\n  // This ensures state stays up-to-date for future renders without causing\n  // \"Cannot update component while rendering\" warnings\n  useEffect(() => {\n    if (lazyLoadCacheRef.current.size > 0 && !syncScheduledRef.current) {\n      syncScheduledRef.current = true\n      const timeoutId = setTimeout(() => {\n        setTranscripts(prev => {\n          const next = new Map(prev)\n          for (const [agentId, transcript] of lazyLoadCacheRef.current) {\n            if (!next.has(agentId)) {\n              next.set(agentId, transcript)\n            }\n          }\n          return next\n        })\n        lazyLoadCacheRef.current = new Map()\n        syncScheduledRef.current = false\n      }, 0)\n      return () => {\n        clearTimeout(timeoutId)\n        syncScheduledRef.current = false\n      }\n    }\n    return undefined\n  }, [transcripts])\n\n  // Force refresh a specific transcript\n  const refreshTranscript = useCallback((agentId: string) => {\n    const fresh = getAgentTranscript(agentId)\n    if (fresh) {\n      setTranscripts(prev => {\n        const next = new Map(prev)\n        next.set(agentId, fresh)\n        return next\n      })\n    }\n  }, [])\n\n  // Count active (non-completed) transcripts\n  const activeCount = useMemo(() => {\n    let count = 0\n    for (const transcript of transcripts.values()) {\n      if (transcript.status === 'running' || transcript.status === 'pending') {\n        count++\n      }\n    }\n    return count\n  }, [transcripts])\n\n  return {\n    transcripts,\n    getTranscript: getTranscriptCallback,\n    refreshTranscript,\n    activeCount,\n  }\n}\n\n/**\n * Simplified hook for single transcript tracking\n */\nexport function useAgentTranscript(\n  agentId: string | undefined,\n): AgentTranscript | null {\n  const [transcript, setTranscript] = useState<AgentTranscript | null>(() => {\n    if (!agentId) return null\n    return getAgentTranscript(agentId)\n  })\n\n  useEffect(() => {\n    if (!agentId) {\n      setTranscript(null)\n      return undefined\n    }\n\n    // Load initial\n    const initial = getAgentTranscript(agentId)\n    if (initial) {\n      setTranscript(initial)\n    }\n\n    // Subscribe to updates for this specific agent\n    const handleUpdate = (event: TranscriptEvent) => {\n      if (event.agentId === agentId) {\n        setTranscript(event.transcript)\n      }\n    }\n\n    transcriptEmitter.on('update', handleUpdate)\n    return () => {\n      transcriptEmitter.off('update', handleUpdate)\n    }\n  }, [agentId])\n\n  return transcript\n}\n"],
-  "mappings": "AAOA,SAAS,UAAU,WAAW,SAAS,aAAa,cAAc;AAClE;AAAA,EACE;AAAA,EACA;AAAA,OAGK;AAmBA,SAAS,oBACd,UAC2B;AAE3B,QAAM,CAAC,aAAa,cAAc,IAAI;AAAA,IACpC,MAAM,oBAAI,IAAI;AAAA,EAChB;AAIA,QAAM,mBAAmB,OAAqC,oBAAI,IAAI,CAAC;AAGvE,QAAM,mBAAmB,OAAgB,KAAK;AAG9C,QAAM,kBAAkB;AAAA,IACtB,MAAO,WAAW,IAAI,IAAI,QAAQ,IAAI;AAAA,IACtC,CAAC,UAAU,KAAK,GAAG,CAAC;AAAA,EACtB;AAGA,YAAU,MAAM;AACd,UAAM,eAAe,CAAC,UAA2B;AAE/C,UAAI,mBAAmB,CAAC,gBAAgB,IAAI,MAAM,OAAO,GAAG;AAC1D;AAAA,MACF;AAEA,qBAAe,UAAQ;AACrB,cAAM,OAAO,IAAI,IAAI,IAAI;AACzB,aAAK,IAAI,MAAM,SAAS,MAAM,UAAU;AACxC,eAAO;AAAA,MACT,CAAC;AAAA,IACH;AAGA,sBAAkB,GAAG,UAAU,YAAY;AAG3C,QAAI,iBAAiB;AACnB,iBAAW,WAAW,iBAAiB;AACrC,cAAM,aAAa,mBAAmB,OAAO;AAC7C,YAAI,YAAY;AACd,yBAAe,UAAQ;AACrB,kBAAM,OAAO,IAAI,IAAI,IAAI;AACzB,iBAAK,IAAI,SAAS,UAAU;AAC5B,mBAAO;AAAA,UACT,CAAC;AAAA,QACH;AAAA,MACF;AAAA,IACF;AAEA,WAAO,MAAM;AACX,wBAAkB,IAAI,UAAU,YAAY;AAAA,IAC9C;AAAA,EACF,GAAG,CAAC,eAAe,CAAC;AAMpB,QAAM,wBAAwB;AAAA,IAC5B,CAAC,YAA4C;AAE3C,YAAM,SAAS,YAAY,IAAI,OAAO;AACtC,UAAI,QAAQ;AACV,eAAO;AAAA,MACT;AAGA,YAAM,aAAa,iBAAiB,QAAQ,IAAI,OAAO;AACvD,UAAI,YAAY;AACd,eAAO;AAAA,MACT;AAGA,YAAM,SAAS,mBAAmB,OAAO;AACzC,UAAI,QAAQ;AACV,yBAAiB,QAAQ,IAAI,SAAS,MAAM;AAAA,MAC9C;AACA,aAAO;AAAA,IACT;AAAA,IACA,CAAC,WAAW;AAAA,EACd;AAKA,YAAU,MAAM;AACd,QAAI,iBAAiB,QAAQ,OAAO,KAAK,CAAC,iBAAiB,SAAS;AAClE,uBAAiB,UAAU;AAC3B,YAAM,YAAY,WAAW,MAAM;AACjC,uBAAe,UAAQ;AACrB,gBAAM,OAAO,IAAI,IAAI,IAAI;AACzB,qBAAW,CAAC,SAAS,UAAU,KAAK,iBAAiB,SAAS;AAC5D,gBAAI,CAAC,KAAK,IAAI,OAAO,GAAG;AACtB,mBAAK,IAAI,SAAS,UAAU;AAAA,YAC9B;AAAA,UACF;AACA,iBAAO;AAAA,QACT,CAAC;AACD,yBAAiB,UAAU,oBAAI,IAAI;AACnC,yBAAiB,UAAU;AAAA,MAC7B,GAAG,CAAC;AACJ,aAAO,MAAM;AACX,qBAAa,SAAS;AACtB,yBAAiB,UAAU;AAAA,MAC7B;AAAA,IACF;AACA,WAAO;AAAA,EACT,GAAG,CAAC,WAAW,CAAC;AAGhB,QAAM,oBAAoB,YAAY,CAAC,YAAoB;AACzD,UAAM,QAAQ,mBAAmB,OAAO;AACxC,QAAI,OAAO;AACT,qBAAe,UAAQ;AACrB,cAAM,OAAO,IAAI,IAAI,IAAI;AACzB,aAAK,IAAI,SAAS,KAAK;AACvB,eAAO;AAAA,MACT,CAAC;AAAA,IACH;AAAA,EACF,GAAG,CAAC,CAAC;AAGL,QAAM,cAAc,QAAQ,MAAM;AAChC,QAAI,QAAQ;AACZ,eAAW,cAAc,YAAY,OAAO,GAAG;AAC7C,UAAI,WAAW,WAAW,aAAa,WAAW,WAAW,WAAW;AACtE;AAAA,MACF;AAAA,IACF;AACA,WAAO;AAAA,EACT,GAAG,CAAC,WAAW,CAAC;AAEhB,SAAO;AAAA,IACL;AAAA,IACA,eAAe;AAAA,IACf;AAAA,IACA;AAAA,EACF;AACF;AAKO,SAAS,mBACd,SACwB;AACxB,QAAM,CAAC,YAAY,aAAa,IAAI,SAAiC,MAAM;AACzE,QAAI,CAAC,QAAS,QAAO;AACrB,WAAO,mBAAmB,OAAO;AAAA,EACnC,CAAC;AAED,YAAU,MAAM;AACd,QAAI,CAAC,SAAS;AACZ,oBAAc,IAAI;AAClB,aAAO;AAAA,IACT;AAGA,UAAM,UAAU,mBAAmB,OAAO;AAC1C,QAAI,SAAS;AACX,oBAAc,OAAO;AAAA,IACvB;AAGA,UAAM,eAAe,CAAC,UAA2B;AAC/C,UAAI,MAAM,YAAY,SAAS;AAC7B,sBAAc,MAAM,UAAU;AAAA,MAChC;AAAA,IACF;AAEA,sBAAkB,GAAG,UAAU,YAAY;AAC3C,WAAO,MAAM;AACX,wBAAkB,IAAI,UAAU,YAAY;AAAA,IAC9C;AAAA,EACF,GAAG,CAAC,OAAO,CAAC;AAEZ,SAAO;AACT;",
-  "names": []
-}

package/dist/hooks/useAnimationSync.js

@@ -1,53 +0,0 @@
-import { useState, useEffect } from "react";
-import { animationSync, ANIMATION_INTERVALS } from "../utils/animationSync.js";
-function useAnimationSync() {
-  const [state, setState] = useState(
-    () => animationSync.getFrame()
-  );
-  useEffect(() => {
-    const unsubscribe = animationSync.subscribe((frame) => {
-      setState(frame);
-    });
-    return unsubscribe;
-  }, []);
-  return state;
-}
-function useSpinnerAnimation(frames) {
-  const [frameIndex, setFrameIndex] = useState(0);
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setFrameIndex((f) => (f + 1) % frames.length);
-    }, ANIMATION_INTERVALS.SPINNER);
-    return () => clearInterval(timer);
-  }, [frames.length]);
-  return frames[frameIndex] || frames[0] || "";
-}
-function useBlinkAnimation() {
-  const [visible, setVisible] = useState(true);
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setVisible((v) => !v);
-    }, ANIMATION_INTERVALS.BLINK);
-    return () => clearInterval(timer);
-  }, []);
-  return visible;
-}
-function useElapsedTime(startTime) {
-  const [elapsed, setElapsed] = useState(0);
-  const start = startTime ?? Date.now();
-  useEffect(() => {
-    const timer = setInterval(() => {
-      setElapsed(Math.floor((Date.now() - start) / 1e3));
-    }, ANIMATION_INTERVALS.ELAPSED_TIME);
-    return () => clearInterval(timer);
-  }, [start]);
-  return elapsed;
-}
-export {
-  ANIMATION_INTERVALS,
-  useAnimationSync,
-  useBlinkAnimation,
-  useElapsedTime,
-  useSpinnerAnimation
-};
-//# sourceMappingURL=useAnimationSync.js.map

package/dist/hooks/useAnimationSync.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useAnimationSync.ts"],
-  "sourcesContent": ["/**\n * React hook for synchronized animations across components\n *\n * Provides synchronized animation state that updates at consistent intervals:\n * - Spinner: 120ms\n * - Blinking: 600ms\n * - Elapsed Time: 1000ms\n *\n * Usage:\n * ```tsx\n * function MySpinner() {\n *   const { spinnerFrame, blinkVisible, elapsedSeconds } = useAnimationSync()\n *   const spinnerChars = ['\u00B7', '\u2722', '\u2733', '\u2217', '\u273B', '\u273D']\n *   return <Text>{spinnerChars[spinnerFrame % spinnerChars.length]}</Text>\n * }\n * ```\n */\n\nimport { useState, useEffect, useCallback } from 'react'\nimport { animationSync, ANIMATION_INTERVALS } from '@utils/animationSync'\n\nexport interface AnimationState {\n  spinnerFrame: number\n  blinkVisible: boolean\n  elapsedSeconds: number\n}\n\n/**\n * Hook for synchronized animation state\n * Components using this hook will animate in sync with each other\n */\nexport function useAnimationSync(): AnimationState {\n  const [state, setState] = useState<AnimationState>(() =>\n    animationSync.getFrame(),\n  )\n\n  useEffect(() => {\n    const unsubscribe = animationSync.subscribe(frame => {\n      setState(frame)\n    })\n\n    return unsubscribe\n  }, [])\n\n  return state\n}\n\n/**\n * Hook for just the spinner animation (120ms interval)\n * Lighter weight than full animation sync if you only need spinner\n */\nexport function useSpinnerAnimation(frames: string[]): string {\n  const [frameIndex, setFrameIndex] = useState(0)\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setFrameIndex(f => (f + 1) % frames.length)\n    }, ANIMATION_INTERVALS.SPINNER)\n\n    return () => clearInterval(timer)\n  }, [frames.length])\n\n  return frames[frameIndex] || frames[0] || ''\n}\n\n/**\n * Hook for blinking animation (600ms interval)\n */\nexport function useBlinkAnimation(): boolean {\n  const [visible, setVisible] = useState(true)\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setVisible(v => !v)\n    }, ANIMATION_INTERVALS.BLINK)\n\n    return () => clearInterval(timer)\n  }, [])\n\n  return visible\n}\n\n/**\n * Hook for elapsed time counter (1000ms interval)\n */\nexport function useElapsedTime(startTime?: number): number {\n  const [elapsed, setElapsed] = useState(0)\n  const start = startTime ?? Date.now()\n\n  useEffect(() => {\n    const timer = setInterval(() => {\n      setElapsed(Math.floor((Date.now() - start) / 1000))\n    }, ANIMATION_INTERVALS.ELAPSED_TIME)\n\n    return () => clearInterval(timer)\n  }, [start])\n\n  return elapsed\n}\n\n// Re-export intervals for convenience\nexport { ANIMATION_INTERVALS }\n"],
-  "mappings": "AAkBA,SAAS,UAAU,iBAA8B;AACjD,SAAS,eAAe,2BAA2B;AAY5C,SAAS,mBAAmC;AACjD,QAAM,CAAC,OAAO,QAAQ,IAAI;AAAA,IAAyB,MACjD,cAAc,SAAS;AAAA,EACzB;AAEA,YAAU,MAAM;AACd,UAAM,cAAc,cAAc,UAAU,WAAS;AACnD,eAAS,KAAK;AAAA,IAChB,CAAC;AAED,WAAO;AAAA,EACT,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAMO,SAAS,oBAAoB,QAA0B;AAC5D,QAAM,CAAC,YAAY,aAAa,IAAI,SAAS,CAAC;AAE9C,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,oBAAc,QAAM,IAAI,KAAK,OAAO,MAAM;AAAA,IAC5C,GAAG,oBAAoB,OAAO;AAE9B,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,OAAO,MAAM,CAAC;AAElB,SAAO,OAAO,UAAU,KAAK,OAAO,CAAC,KAAK;AAC5C;AAKO,SAAS,oBAA6B;AAC3C,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,IAAI;AAE3C,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,OAAK,CAAC,CAAC;AAAA,IACpB,GAAG,oBAAoB,KAAK;AAE5B,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,CAAC;AAEL,SAAO;AACT;AAKO,SAAS,eAAe,WAA4B;AACzD,QAAM,CAAC,SAAS,UAAU,IAAI,SAAS,CAAC;AACxC,QAAM,QAAQ,aAAa,KAAK,IAAI;AAEpC,YAAU,MAAM;AACd,UAAM,QAAQ,YAAY,MAAM;AAC9B,iBAAW,KAAK,OAAO,KAAK,IAAI,IAAI,SAAS,GAAI,CAAC;AAAA,IACpD,GAAG,oBAAoB,YAAY;AAEnC,WAAO,MAAM,cAAc,KAAK;AAAA,EAClC,GAAG,CAAC,KAAK,CAAC;AAEV,SAAO;AACT;",
-  "names": []
-}

package/dist/hooks/useApiKeyVerification.js

@@ -1,12 +0,0 @@
-function useApiKeyVerification() {
-  return {
-    status: "valid",
-    reverify: async () => {
-    },
-    error: null
-  };
-}
-export {
-  useApiKeyVerification
-};
-//# sourceMappingURL=useApiKeyVerification.js.map

package/dist/hooks/useApiKeyVerification.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useApiKeyVerification.ts"],
-  "sourcesContent": ["import { useCallback, useState } from 'react'\nimport { verifyApiKey } from '@services/claude'\nimport { getAnthropicApiKey } from '@utils/config'\n\nexport type VerificationStatus =\n  | 'loading'\n  | 'valid'\n  | 'invalid'\n  | 'missing'\n  | 'error'\n\nexport type ApiKeyVerificationResult = {\n  status: VerificationStatus\n  reverify: () => Promise<void>\n  error: Error | null\n}\n\nexport function useApiKeyVerification(): ApiKeyVerificationResult {\n  // const [status, setStatus] = useState<VerificationStatus>(() => {\n  //   const apiKey = getAnthropicApiKey()\n  //   return apiKey ? 'loading' : 'missing'\n  // })\n  // const [error, setError] = useState<Error | null>(null)\n\n  // const verify = useCallback(async (): Promise<void> => {\n  //   if (isDefaultApiKey()) {\n  //     setStatus('valid')\n  //     return\n  //   }\n\n  //   const apiKey = getAnthropicApiKey()\n  //   if (!apiKey) {\n  //     const newStatus = 'missing' as const\n  //     setStatus(newStatus)\n  //     return\n  //   }\n\n  //   try {\n  //     const isValid = await verifyApiKey(apiKey)\n  //     const newStatus = isValid ? 'valid' : 'invalid'\n  //     setStatus(newStatus)\n  //     return\n  //   } catch (error) {\n  //     // This happens when there an error response from the API but it's not an invalid API key error\n  //     // In this case, we still mark the API key as invalid - but we also log the error so we can\n  //     // display it to the user to be more helpful\n  //     setError(error as Error)\n  //     const newStatus = 'error' as const\n  //     setStatus(newStatus)\n  //     return\n  //   }\n  // }, [])\n\n  return {\n    status: 'valid',\n    reverify: async () => {},\n    error: null,\n  }\n}\n"],
-  "mappings": "AAiBO,SAAS,wBAAkD;AAoChE,SAAO;AAAA,IACL,QAAQ;AAAA,IACR,UAAU,YAAY;AAAA,IAAC;AAAA,IACvB,OAAO;AAAA,EACT;AACF;",
-  "names": []
-}

package/dist/hooks/useArrowKeyHistory.js

@@ -1,52 +0,0 @@
-import { useState } from "react";
-import { getHistory } from "../history.js";
-import { sanitizeInput } from "../utils/sanitizeInput.js";
-function useArrowKeyHistory(onSetInput, currentInput) {
-  const [historyIndex, setHistoryIndex] = useState(0);
-  const [lastTypedInput, setLastTypedInput] = useState("");
-  const updateInput = (input) => {
-    if (input !== void 0) {
-      const sanitized = sanitizeInput(input);
-      const mode = sanitized.startsWith("!") ? "bash" : "prompt";
-      const value = mode === "bash" ? sanitized.slice(1) : sanitized;
-      onSetInput(value, mode);
-    }
-  };
-  function onHistoryUp() {
-    const latestHistory = getHistory();
-    if (historyIndex < latestHistory.length) {
-      if (historyIndex === 0 && currentInput.trim() !== "") {
-        setLastTypedInput(currentInput);
-      }
-      const newIndex = historyIndex + 1;
-      setHistoryIndex(newIndex);
-      updateInput(latestHistory[historyIndex]);
-    }
-  }
-  function onHistoryDown() {
-    const latestHistory = getHistory();
-    if (historyIndex > 1) {
-      const newIndex = historyIndex - 1;
-      setHistoryIndex(newIndex);
-      updateInput(latestHistory[newIndex - 1]);
-    } else if (historyIndex === 1) {
-      setHistoryIndex(0);
-      updateInput(lastTypedInput);
-    }
-  }
-  function resetHistory() {
-    setLastTypedInput("");
-    setHistoryIndex(0);
-  }
-  return {
-    historyIndex,
-    setHistoryIndex,
-    onHistoryUp,
-    onHistoryDown,
-    resetHistory
-  };
-}
-export {
-  useArrowKeyHistory
-};
-//# sourceMappingURL=useArrowKeyHistory.js.map

package/dist/hooks/useArrowKeyHistory.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useArrowKeyHistory.ts"],
-  "sourcesContent": ["import { useState } from 'react'\nimport { getHistory } from '@history'\nimport { sanitizeInput } from '@utils/sanitizeInput'\n\nexport function useArrowKeyHistory(\n  onSetInput: (value: string, mode: 'bash' | 'prompt') => void,\n  currentInput: string,\n) {\n  const [historyIndex, setHistoryIndex] = useState(0)\n  const [lastTypedInput, setLastTypedInput] = useState('')\n\n  const updateInput = (input: string | undefined) => {\n    if (input !== undefined) {\n      // Sanitize input to remove dangerous escape sequences\n      // This prevents corrupt history entries (like \"\\x1b\\x1bclear\") from\n      // triggering terminal resets when loaded\n      const sanitized = sanitizeInput(input)\n      const mode = sanitized.startsWith('!') ? 'bash' : 'prompt'\n      const value = mode === 'bash' ? sanitized.slice(1) : sanitized\n      onSetInput(value, mode)\n    }\n  }\n\n  function onHistoryUp() {\n    const latestHistory = getHistory()\n    if (historyIndex < latestHistory.length) {\n      if (historyIndex === 0 && currentInput.trim() !== '') {\n        setLastTypedInput(currentInput)\n      }\n      const newIndex = historyIndex + 1\n      setHistoryIndex(newIndex)\n      updateInput(latestHistory[historyIndex])\n    }\n  }\n\n  function onHistoryDown() {\n    const latestHistory = getHistory()\n    if (historyIndex > 1) {\n      const newIndex = historyIndex - 1\n      setHistoryIndex(newIndex)\n      updateInput(latestHistory[newIndex - 1])\n    } else if (historyIndex === 1) {\n      setHistoryIndex(0)\n      updateInput(lastTypedInput)\n    }\n  }\n\n  function resetHistory() {\n    setLastTypedInput('')\n    setHistoryIndex(0)\n  }\n\n  return {\n    historyIndex,\n    setHistoryIndex,\n    onHistoryUp,\n    onHistoryDown,\n    resetHistory,\n  }\n}\n"],
-  "mappings": "AAAA,SAAS,gBAAgB;AACzB,SAAS,kBAAkB;AAC3B,SAAS,qBAAqB;AAEvB,SAAS,mBACd,YACA,cACA;AACA,QAAM,CAAC,cAAc,eAAe,IAAI,SAAS,CAAC;AAClD,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,SAAS,EAAE;AAEvD,QAAM,cAAc,CAAC,UAA8B;AACjD,QAAI,UAAU,QAAW;AAIvB,YAAM,YAAY,cAAc,KAAK;AACrC,YAAM,OAAO,UAAU,WAAW,GAAG,IAAI,SAAS;AAClD,YAAM,QAAQ,SAAS,SAAS,UAAU,MAAM,CAAC,IAAI;AACrD,iBAAW,OAAO,IAAI;AAAA,IACxB;AAAA,EACF;AAEA,WAAS,cAAc;AACrB,UAAM,gBAAgB,WAAW;AACjC,QAAI,eAAe,cAAc,QAAQ;AACvC,UAAI,iBAAiB,KAAK,aAAa,KAAK,MAAM,IAAI;AACpD,0BAAkB,YAAY;AAAA,MAChC;AACA,YAAM,WAAW,eAAe;AAChC,sBAAgB,QAAQ;AACxB,kBAAY,cAAc,YAAY,CAAC;AAAA,IACzC;AAAA,EACF;AAEA,WAAS,gBAAgB;AACvB,UAAM,gBAAgB,WAAW;AACjC,QAAI,eAAe,GAAG;AACpB,YAAM,WAAW,eAAe;AAChC,sBAAgB,QAAQ;AACxB,kBAAY,cAAc,WAAW,CAAC,CAAC;AAAA,IACzC,WAAW,iBAAiB,GAAG;AAC7B,sBAAgB,CAAC;AACjB,kBAAY,cAAc;AAAA,IAC5B;AAAA,EACF;AAEA,WAAS,eAAe;AACtB,sBAAkB,EAAE;AACpB,oBAAgB,CAAC;AAAA,EACnB;AAEA,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;",
-  "names": []
-}

package/dist/hooks/useAskUser.js

@@ -1,24 +0,0 @@
-import { useCallback } from "react";
-function useAskUser(setAskUserQuestionContext) {
-  return useCallback(
-    (questions) => {
-      return new Promise((resolve, reject) => {
-        setAskUserQuestionContext({
-          questions,
-          resolve: (answers) => {
-            resolve(answers);
-          },
-          reject: () => {
-            reject(new Error("User cancelled the question dialog"));
-          }
-        });
-      });
-    },
-    [setAskUserQuestionContext]
-  );
-}
-var useAskUser_default = useAskUser;
-export {
-  useAskUser_default as default
-};
-//# sourceMappingURL=useAskUser.js.map

package/dist/hooks/useAskUser.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useAskUser.ts"],
-  "sourcesContent": ["import * as React from 'react'\nimport { useCallback } from 'react'\nimport type {\n  UserQuestion,\n  UserAnswer,\n  AskUserQuestionContext,\n} from '@minto-types/askUserQuestion'\n\ntype SetState<T> = React.Dispatch<React.SetStateAction<T>>\n\n/**\n * Function type for asking the user questions\n */\nexport type AskUserFn = (questions: UserQuestion[]) => Promise<UserAnswer[]>\n\n/**\n * Hook to provide the askUser function for triggering user question dialogs\n *\n * Similar to useCanUseTool, this creates a Promise-based interaction\n * where the dialog is shown and the promise resolves when the user responds.\n *\n * @param setAskUserQuestionContext - State setter to trigger the dialog\n * @returns Function to ask user questions\n */\nfunction useAskUser(\n  setAskUserQuestionContext: SetState<AskUserQuestionContext | null>,\n): AskUserFn {\n  return useCallback<AskUserFn>(\n    (questions: UserQuestion[]) => {\n      return new Promise<UserAnswer[]>((resolve, reject) => {\n        // Set the context to trigger the dialog render\n        setAskUserQuestionContext({\n          questions,\n          resolve: (answers: UserAnswer[]) => {\n            // User provided answers\n            resolve(answers)\n          },\n          reject: () => {\n            // User cancelled\n            reject(new Error('User cancelled the question dialog'))\n          },\n        })\n      })\n    },\n    [setAskUserQuestionContext],\n  )\n}\n\nexport default useAskUser\n"],
-  "mappings": "AACA,SAAS,mBAAmB;AAuB5B,SAAS,WACP,2BACW;AACX,SAAO;AAAA,IACL,CAAC,cAA8B;AAC7B,aAAO,IAAI,QAAsB,CAAC,SAAS,WAAW;AAEpD,kCAA0B;AAAA,UACxB;AAAA,UACA,SAAS,CAAC,YAA0B;AAElC,oBAAQ,OAAO;AAAA,UACjB;AAAA,UACA,QAAQ,MAAM;AAEZ,mBAAO,IAAI,MAAM,oCAAoC,CAAC;AAAA,UACxD;AAAA,QACF,CAAC;AAAA,MACH,CAAC;AAAA,IACH;AAAA,IACA,CAAC,yBAAyB;AAAA,EAC5B;AACF;AAEA,IAAO,qBAAQ;",
-  "names": []
-}

package/dist/hooks/useBackgroundShells.js

@@ -1,29 +0,0 @@
-import { useEffect, useState } from "react";
-import {
-  BackgroundShellManager
-} from "../utils/BackgroundShellManager.js";
-function useBackgroundShells() {
-  const [shells, setShells] = useState([]);
-  const [isPanelVisible, setIsPanelVisible] = useState(false);
-  useEffect(() => {
-    const manager = BackgroundShellManager.getInstance();
-    setShells(manager.list());
-    const handleListChange = (updated) => {
-      setShells(updated);
-    };
-    manager.on("listChange", handleListChange);
-    return () => {
-      manager.off("listChange", handleListChange);
-    };
-  }, []);
-  return {
-    shells,
-    isPanelVisible,
-    setIsPanelVisible,
-    runningCount: shells.filter((s) => s.status === "running").length
-  };
-}
-export {
-  useBackgroundShells
-};
-//# sourceMappingURL=useBackgroundShells.js.map

package/dist/hooks/useBackgroundShells.js.map

@@ -1,7 +0,0 @@
-{
-  "version": 3,
-  "sources": ["../../src/hooks/useBackgroundShells.ts"],
-  "sourcesContent": ["/**\n * Manages background shell state via event-driven subscription.\n * Replaces inline state + effect in REPL.tsx.\n */\nimport { useEffect, useState } from 'react'\nimport {\n  BackgroundShellManager,\n  type BackgroundShell,\n} from '@utils/BackgroundShellManager'\n\nexport function useBackgroundShells() {\n  const [shells, setShells] = useState<BackgroundShell[]>([])\n  const [isPanelVisible, setIsPanelVisible] = useState(false)\n\n  useEffect(() => {\n    const manager = BackgroundShellManager.getInstance()\n    setShells(manager.list())\n\n    const handleListChange = (updated: BackgroundShell[]) => {\n      setShells(updated)\n    }\n    manager.on('listChange', handleListChange)\n\n    return () => {\n      manager.off('listChange', handleListChange)\n    }\n  }, [])\n\n  return {\n    shells,\n    isPanelVisible,\n    setIsPanelVisible,\n    runningCount: shells.filter(s => s.status === 'running').length,\n  }\n}\n"],
-  "mappings": "AAIA,SAAS,WAAW,gBAAgB;AACpC;AAAA,EACE;AAAA,OAEK;AAEA,SAAS,sBAAsB;AACpC,QAAM,CAAC,QAAQ,SAAS,IAAI,SAA4B,CAAC,CAAC;AAC1D,QAAM,CAAC,gBAAgB,iBAAiB,IAAI,SAAS,KAAK;AAE1D,YAAU,MAAM;AACd,UAAM,UAAU,uBAAuB,YAAY;AACnD,cAAU,QAAQ,KAAK,CAAC;AAExB,UAAM,mBAAmB,CAAC,YAA+B;AACvD,gBAAU,OAAO;AAAA,IACnB;AACA,YAAQ,GAAG,cAAc,gBAAgB;AAEzC,WAAO,MAAM;AACX,cAAQ,IAAI,cAAc,gBAAgB;AAAA,IAC5C;AAAA,EACF,GAAG,CAAC,CAAC;AAEL,SAAO;AAAA,IACL;AAAA,IACA;AAAA,IACA;AAAA,IACA,cAAc,OAAO,OAAO,OAAK,EAAE,WAAW,SAAS,EAAE;AAAA,EAC3D;AACF;",
-  "names": []
-}