mu-coding 0.5.0 → 0.9.0

package/src/tui/chat/useChatPanel.ts

@@ -1,8 +1,10 @@
 import { type DOMElement as InkDOMElement, useInput } from 'ink';
-import type { PluginRegistry } from 'mu-agents';
-import type { ChatMessage, ProviderConfig } from 'mu-provider';
+import type { SubagentRunRegistry } from 'mu-agents';
+import type { ChatMessage, PluginRegistry, ProviderConfig } from 'mu-core';
 import { useEffect, useMemo, useRef } from 'react';
 import type { ShutdownFn } from '../../app/shutdown';
+import type { SessionPathHolder } from '../../runtime/createRegistry';
+import type { HostMessageBus } from '../../runtime/messageBus';
 import type { ChatPanelBodyProps } from '../components/chat/ChatPanelBody';
 import { useToast } from '../components/primitives/toast';
 import { useScroll } from '../hooks/useScroll';
@@ -11,6 +13,7 @@ import type { InkUIService, ToastRequest } from '../plugins/InkUIService';
 import { useChat } from './useChat';
 import { usePluginStatus } from './usePluginStatus';
 import { useStatusSegments } from './useStatusSegments';
+import { type SubagentBrowserState, useSubagentBrowser } from './useSubagentBrowser';
 
 const TOAST_LEVEL_COLORS: Record<string, string> = {
   info: 'cyan',
@@ -23,13 +26,27 @@ interface UseChatPanelOptions {
   config: ProviderConfig;
   initialMessages?: ChatMessage[];
   registry: PluginRegistry;
+  messageBus?: HostMessageBus;
   uiService?: InkUIService;
   shutdown?: ShutdownFn;
+  sessionPathHolder?: SessionPathHolder;
+  subagentRuns?: SubagentRunRegistry;
 }
 
 export function useChatPanel(options: UseChatPanelOptions) {
-  const { config, initialMessages, registry, uiService, shutdown } = options;
-  const ctx = useChat(config, registry, initialMessages, shutdown);
+  const { config, initialMessages, registry, messageBus, uiService, shutdown, sessionPathHolder, subagentRuns } =
+    options;
+  const ctx = useChat(
+    config,
+    registry,
+    initialMessages,
+    shutdown,
+    uiService,
+    messageBus,
+    sessionPathHolder,
+    subagentRuns,
+  );
+  const browser = useSubagentBrowser(subagentRuns);
   const { width, height } = useTerminalSize();
   const viewRef = useRef<InkDOMElement>(null);
   const contentRef = useRef<InkDOMElement>(null);
@@ -58,13 +75,16 @@ export function useChatPanel(options: UseChatPanelOptions) {
     });
   }, [uiService, show]);
 
+  const contextLimit = ctx.models.models.find((m) => m.id === ctx.models.currentModel)?.contextLimit;
   const statusSegments = useStatusSegments({
     streaming: ctx.session.streaming,
     abortWarning: ctx.abort.abortWarning,
     quitWarning: ctx.abort.quitWarning,
     error: ctx.session.error,
     modelError: ctx.models.modelError,
-    tokensPerSecond: ctx.session.stream.tps,
+    totalTokens: ctx.session.stream.totalTokens,
+    cachedTokens: ctx.session.stream.cachedTokens,
+    contextLimit,
     pluginStatus,
   });
 
@@ -76,7 +96,7 @@ export function useChatPanel(options: UseChatPanelOptions) {
     scrollOffset,
     viewHeight,
     contentHeight,
-    isActive: !anyModalOpen,
+    isActive: !anyModalOpen && browser.mode.kind === 'chat',
     onScrollUp,
     onScrollDown,
     uiService,
@@ -90,7 +110,10 @@ export function useChatPanel(options: UseChatPanelOptions) {
     statusSegments,
     toasts,
     onDismissToast: dismiss,
+    browser,
   };
 
   return { ctx, bodyProps };
 }
+
+export type { SubagentBrowserState };

package/src/tui/chat/useChatSession.ts

@@ -1,11 +1,19 @@
-import type { PluginRegistry } from 'mu-agents';
-import type { ChatMessage, ProviderConfig } from 'mu-provider';
-import { useCallback } from 'react';
+import type { ChatMessage, ProviderConfig, Session } from 'mu-core';
+import { type PluginRegistry, runDecorateMessageHooks, runTransformUserInputHooks } from 'mu-core';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { SessionPathHolder } from '../../runtime/createRegistry';
+import type { HostMessageBus } from '../../runtime/messageBus';
 import type { AttachmentState } from './useAttachment';
 import { useSessionPersistence } from './useSessionPersistence';
-import { type StreamState, useStreamConsumer } from './useStreamConsumer';
 
-export type { StreamState } from './useStreamConsumer';
+export interface StreamState {
+  text: string;
+  reasoning: string;
+  totalTokens: number;
+  cachedTokens: number;
+}
+
+const EMPTY_STREAM: StreamState = { text: '', reasoning: '', totalTokens: 0, cachedTokens: 0 };
 
 export interface ChatSessionState {
   messages: ChatMessage[];
@@ -16,100 +24,359 @@ export interface ChatSessionState {
   onSend: (text: string) => Promise<void>;
   onNew: () => void;
   onLoadSession: (path: string) => void;
+  /**
+   * Compact the current transcript: ask the model to summarize the entire
+   * conversation, then replace the transcript with `[user marker, assistant
+   * summary]`. Frees context while keeping intent + key decisions in scope.
+   */
+  onCompact: () => Promise<void>;
 }
 
 interface SessionDeps {
+  /**
+   * mu-core Session instance owned by the host. Authoritative for the
+   * transcript — this hook only mirrors it into React state and writes
+   * persistence on each message_changed event.
+   */
+  session: Session;
+  /** Provider config used as `runTurn` override (model lookup happens here). */
   config: ProviderConfig;
+  /** Currently selected model id (may shift across sends). */
   currentModel: string;
   attachment: AttachmentState;
   controllerRef: React.RefObject<AbortController | null>;
   initialMessages?: ChatMessage[];
   registry: PluginRegistry;
+  messageBus?: HostMessageBus;
+  sessionPathHolder?: SessionPathHolder;
 }
 
 /**
- * Top-level chat-session hook. Composes:
- *  - `useSessionPersistence` — transcript, history, save path
- *  - `useStreamConsumer`     — in-flight tokens, tps, error
- *
- * Provides the `onSend` glue that wires user input through the agent.
+ * Wire the host MessageBus to the Session: bus.append flows through
+ * `session.appendSynthetic` so every subscriber (TUI, broadcaster) sees the
+ * same change. `bus.get()` mirrors the live transcript.
  */
-export function useChatSession(deps: SessionDeps): ChatSessionState {
-  const { config, currentModel, attachment, controllerRef, initialMessages, registry } = deps;
-  const persistence = useSessionPersistence(initialMessages);
-  const consumer = useStreamConsumer();
-  const { messages, setMessages, appendHistory, saveCurrent } = persistence;
+function useMessageBusWiring(messageBus: HostMessageBus | undefined, messages: ChatMessage[], session: Session): void {
+  useEffect(() => {
+    messageBus?.setMessages(messages);
+  }, [messageBus, messages]);
+
+  useEffect(() => {
+    if (!messageBus) return;
+    messageBus.setAppender((message) => {
+      session.appendSynthetic(message);
+    });
+    return () => {
+      messageBus.setAppender(null);
+    };
+  }, [messageBus, session]);
+}
+
+interface SubscriptionDeps {
+  session: Session;
+  setMessages: React.Dispatch<React.SetStateAction<ChatMessage[]>>;
+  setStream: React.Dispatch<React.SetStateAction<StreamState>>;
+  setStreaming: React.Dispatch<React.SetStateAction<boolean>>;
+  setError: React.Dispatch<React.SetStateAction<string | null>>;
+  saveCurrent: (messages: ChatMessage[]) => void;
+}
+
+/**
+ * Subscribe React state to mu-core Session events. Session is authoritative;
+ * this hook only mirrors. Persistence is driven from the same stream so disk
+ * writes are guaranteed to match what the user sees, but writes are
+ * coalesced to once per `stream_ended` to keep tool-heavy turns light on I/O.
+ */
+/**
+ * Build the event handler. Extracted so the cognitive complexity of the
+ * dispatch lives outside the React effect closure (the effect itself is
+ * just `session.subscribe(handler)`).
+ */
+function makeSessionEventHandler(
+  deps: SubscriptionDeps,
+  lastMessagesRef: React.MutableRefObject<ChatMessage[]>,
+): (event: import('mu-core').SessionEvent) => void {
+  const { setMessages, setStream, setStreaming, setError, saveCurrent } = deps;
+  return (event) => {
+    if (event.type === 'messages_changed') {
+      lastMessagesRef.current = event.messages;
+      setMessages(event.messages);
+      return;
+    }
+    if (event.type === 'stream_partial') {
+      setStream((s) => ({ ...s, text: event.text, reasoning: event.reasoning ?? '' }));
+      return;
+    }
+    if (event.type === 'stream_started') {
+      setStreaming(true);
+      setError(null);
+      return;
+    }
+    if (event.type === 'stream_ended') {
+      setStreaming(false);
+      setStream((s) => ({ ...s, text: '', reasoning: '' }));
+      if (lastMessagesRef.current.length > 0) saveCurrent(lastMessagesRef.current);
+      return;
+    }
+    if (event.type === 'usage') {
+      setStream((s) => ({
+        ...s,
+        totalTokens: s.totalTokens + event.totalTokens,
+        cachedTokens: s.cachedTokens + event.cachedTokens,
+      }));
+      return;
+    }
+    if (event.type === 'error') {
+      setError(event.message);
+    }
+  };
+}
 
-  const onSend = useCallback(
+function useSessionSubscription(deps: SubscriptionDeps): void {
+  const { session, setMessages, setStream, setStreaming, setError, saveCurrent } = deps;
+  // The "last completed transcript" buffer survives effect re-subscriptions
+  // (e.g. if `saveCurrent` identity ever changes mid-stream). Without a ref
+  // we'd lose the in-flight save target on the next deps change.
+  const lastMessagesRef = useRef<ChatMessage[]>([]);
+  useEffect(() => {
+    const handler = makeSessionEventHandler(
+      { session, setMessages, setStream, setStreaming, setError, saveCurrent },
+      lastMessagesRef,
+    );
+    return session.subscribe(handler);
+  }, [session, setMessages, setStream, setStreaming, setError, saveCurrent]);
+}
+
+interface OnSendDeps {
+  session: Session;
+  config: ProviderConfig;
+  currentModel: string;
+  attachment: AttachmentState;
+  controllerRef: React.RefObject<AbortController | null>;
+  registry: PluginRegistry;
+  messageBus?: HostMessageBus;
+  appendHistory: (text: string) => void;
+  streaming: boolean;
+}
+
+interface OnCompactDeps {
+  streaming: boolean;
+  session: Session;
+  config: ProviderConfig;
+  currentModel: string;
+  registry: PluginRegistry;
+  controllerRef: React.RefObject<AbortController | null>;
+  saveCurrent: (messages: ChatMessage[]) => void;
+}
+
+const COMPACT_INSTRUCTION =
+  'Compact this conversation. Produce ONE concise summary that captures: ' +
+  "1) the user's overall intent, 2) key decisions made, 3) files modified " +
+  '(paths with line refs where relevant), 4) open tasks / next steps, and ' +
+  '5) any important context the assistant should retain. Output ONLY the ' +
+  'summary text — no preface, no markdown headers.';
+
+/**
+ * Walk a transcript backwards starting at `fromIndex` and return the first
+ * assistant message with non-empty content. Used by the compact flow to
+ * locate the summary the LLM produced for the freshly-injected request.
+ */
+function findLatestAssistantContent(messages: ChatMessage[], fromIndex: number): string {
+  for (let i = messages.length - 1; i >= fromIndex; i--) {
+    const m = messages[i];
+    if (m.role === 'assistant' && m.content && m.content.trim().length > 0) {
+      return m.content;
+    }
+  }
+  return '';
+}
+
+function useOnCompact(deps: OnCompactDeps): () => Promise<void> {
+  const { streaming, session, config, currentModel, registry, controllerRef, saveCurrent } = deps;
+  return useCallback(async () => {
+    if (streaming) return;
+    const before = session.getMessages();
+    if (before.length === 0) return;
+    const beforeCount = before.length;
+
+    // Hide the summarization instruction from the on-screen transcript
+    // (`display.hidden`) but keep it in the LLM payload. Once the run
+    // completes we replace the entire transcript anyway.
+    const summaryInstruction: ChatMessage = {
+      role: 'user',
+      content: COMPACT_INSTRUCTION,
+      display: { hidden: true },
+    };
+    const controller = new AbortController();
+    controllerRef.current = controller;
+    controller.signal.addEventListener('abort', () => session.abort(), { once: true });
+    try {
+      await session.runTurn({ userMessage: summaryInstruction, config, model: currentModel, registry });
+      const summary = findLatestAssistantContent(session.getMessages(), beforeCount);
+      if (!summary) return;
+      // Replace the entire history with a single user marker + the assistant
+      // summary. The next turn runs with a tiny context, "resumed" from
+      // the compacted state.
+      const compacted: ChatMessage[] = [
+        { role: 'user', content: '[Conversation compacted — context below preserves prior intent and decisions]' },
+        { role: 'assistant', content: summary },
+      ];
+      session.setMessages(compacted);
+      saveCurrent(compacted);
+    } finally {
+      controllerRef.current = null;
+    }
+  }, [streaming, session, config, currentModel, registry, controllerRef, saveCurrent]);
+}
+
+function useOnSend(deps: OnSendDeps): (text: string) => Promise<void> {
+  const { session, config, currentModel, attachment, controllerRef, registry, messageBus, appendHistory, streaming } =
+    deps;
+  return useCallback(
     async (text: string) => {
-      if (consumer.streaming) {
-        return;
-      }
-      const userMsg: ChatMessage = {
-        role: 'user',
-        content: text,
-        ...(attachment.attachment ? { images: [attachment.attachment] } : {}),
-      };
-      setMessages((prev) => [...prev, userMsg]);
+      if (streaming) return;
+
+      const transform = await runTransformUserInputHooks(registry.getHooks(), text);
+      if (transform.kind === 'intercept') return;
+
+      // `continue` signals the hook handled the user message itself
+      // (e.g. mu-agents' @-mention dispatch path appends the user msg
+      // live, runs the subagent live, and queues the synthetic tool
+      // flow for the upcoming turn). We skip the userMessage push but
+      // still drain the queue and stream the LLM follow-up.
+      const isContinue = transform.kind === 'continue';
+      const finalText = transform.kind === 'transform' ? transform.text : text;
+
+      const userMsg: ChatMessage | undefined = isContinue
+        ? undefined
+        : await runDecorateMessageHooks(registry.getHooks(), {
+            role: 'user',
+            content: finalText,
+            ...(attachment.attachment ? { images: [attachment.attachment] } : {}),
+          });
+
+      const injections = messageBus?.drainNext() ?? [];
+      for (const inj of injections) session.queueForNextTurn(inj);
+
       appendHistory(text);
       attachment.clear();
 
       const controller = new AbortController();
       controllerRef.current = controller;
+      controller.signal.addEventListener('abort', () => session.abort(), { once: true });
 
       try {
-        const final = await consumer.runStream(
-          [...messages, userMsg],
+        await session.runTurn({
+          userMessage: userMsg,
           config,
-          currentModel,
-          controller.signal,
+          model: currentModel,
           registry,
-          setMessages,
-        );
-        if (final) {
-          saveCurrent(final);
-        }
+        });
       } finally {
         controllerRef.current = null;
       }
     },
-    [
-      consumer.streaming,
-      consumer.runStream,
-      messages,
-      config,
-      currentModel,
-      attachment,
-      controllerRef,
-      registry,
-      setMessages,
-      appendHistory,
-      saveCurrent,
-    ],
+    [streaming, session, config, currentModel, attachment, controllerRef, registry, messageBus, appendHistory],
   );
+}
+
+/**
+ * Top-level chat-session hook. Composes:
+ *  - mu-core `Session` — single source of truth for the transcript
+ *  - `useSessionPersistence` — disk write + history + session paths
+ *
+ * The hook is purely reactive: it subscribes to session events and exposes
+ * the resulting state, plus thin wrappers around `session.runTurn` /
+ * `session.setMessages` for user actions.
+ */
+export function useChatSession(deps: SessionDeps): ChatSessionState {
+  const { session, config, currentModel, attachment, controllerRef, initialMessages, registry, messageBus } = deps;
+  const persistence = useSessionPersistence(initialMessages, deps.sessionPathHolder);
+  const { appendHistory, saveCurrent, resetForNew, loadFromPath } = persistence;
+
+  // Initial seed: feed any persisted messages into the session once.
+  // The session subscription below will then mirror them into React state.
+  useEffect(() => {
+    if (initialMessages?.length) session.setMessages(initialMessages);
+    // Run once per session instance.
+    // eslint-disable-next-line react-hooks/exhaustive-deps
+  }, [session, initialMessages?.length, initialMessages]);
+
+  const [messages, setMessages] = useState<ChatMessage[]>(() => initialMessages ?? []);
+  const [streaming, setStreaming] = useState(false);
+  const [error, setError] = useState<string | null>(null);
+  const [stream, setStream] = useState<StreamState>(EMPTY_STREAM);
+
+  useMessageBusWiring(messageBus, messages, session);
+  useSessionSubscription({ session, setMessages, setStream, setStreaming, setError, saveCurrent });
+
+  const onSend = useOnSend({
+    session,
+    config,
+    currentModel,
+    attachment,
+    controllerRef,
+    registry,
+    messageBus,
+    appendHistory,
+    streaming,
+  });
 
   const onNew = useCallback(() => {
-    persistence.onNew();
-    consumer.resetError();
+    // Abort any in-flight turn *before* rotating the session path.
+    // Without this, the streaming `runTurn` keeps emitting `messages_changed`
+    // events that are saved to the newly-rotated path via `stream_ended`,
+    // mixing the old transcript into the brand-new file.
+    if (controllerRef.current) {
+      controllerRef.current.abort();
+      controllerRef.current = null;
+    }
+    resetForNew();
+    // `session.setMessages([])` emits `messages_changed` which the
+    // subscription mirrors into React state, so we don't double-write here.
+    session.setMessages([]);
+    setStream(EMPTY_STREAM);
+    setError(null);
     attachment.clear();
-  }, [persistence.onNew, consumer.resetError, attachment]);
+  }, [resetForNew, session, attachment, controllerRef]);
+
+  const onCompact = useOnCompact({
+    streaming,
+    session,
+    config,
+    currentModel,
+    registry,
+    controllerRef,
+    saveCurrent,
+  });
 
   const onLoadSession = useCallback(
     (path: string) => {
-      persistence.onLoadSession(path);
-      consumer.resetError();
+      const loaded = loadFromPath(path);
+      if (loaded.length === 0) return;
+      // Abort any in-flight turn before replacing the transcript, for the
+      // same reason as onNew above.
+      if (controllerRef.current) {
+        controllerRef.current.abort();
+        controllerRef.current = null;
+      }
+      // setMessages emits messages_changed → React state mirrors it.
+      session.setMessages(loaded);
+      setStream(EMPTY_STREAM);
+      setError(null);
     },
-    [persistence.onLoadSession, consumer.resetError],
+    [loadFromPath, session, controllerRef],
   );
 
   return {
-    messages: persistence.messages,
-    streaming: consumer.streaming,
-    error: consumer.error,
-    stream: consumer.stream,
+    messages,
+    streaming,
+    error,
+    stream,
     inputHistory: persistence.inputHistory,
     onSend,
     onNew,
     onLoadSession,
+    onCompact,
   };
 }

package/src/tui/chat/useModels.ts

@@ -1,4 +1,5 @@
-import { type ApiModel, listModels } from 'mu-provider';
+import type { ApiModel } from 'mu-core';
+import { fetchModelContextLimit, listModels } from 'mu-openai-provider';
 import { useCallback, useEffect, useState } from 'react';
 import { saveConfig } from '../../config/index';
 
@@ -41,6 +42,30 @@ export function useModelList(baseUrl: string, preferredModel?: string): ModelLis
     };
   }, [baseUrl, preferredModel]);
 
+  // Lazily probe the active model's context window. Fires whenever the
+  // selection changes; skips if we already know the limit for that id.
+  // Runs in the background so the UI never blocks waiting for `/props`.
+  // Triggers a model load on llama-swap-style proxies, but only for the
+  // model the user has actually picked — same model the next chat would
+  // load anyway.
+  useEffect(() => {
+    if (!(baseUrl && currentModel)) return;
+    const known = models.find((m) => m.id === currentModel);
+    if (!known || known.contextLimit !== undefined) return;
+    let cancelled = false;
+    fetchModelContextLimit(baseUrl, currentModel)
+      .then((limit) => {
+        if (cancelled || !limit) return;
+        setModels((prev) => prev.map((m) => (m.id === currentModel ? { ...m, contextLimit: limit } : m)));
+      })
+      .catch(() => {
+        /* silently ignore — providers without `/props` just don't get a limit */
+      });
+    return () => {
+      cancelled = true;
+    };
+  }, [baseUrl, currentModel, models]);
+
   const cycleModel = useCallback(() => {
     if (models.length === 0) {
       return;

package/src/tui/chat/usePluginStatus.ts

@@ -1,4 +1,4 @@
-import type { PluginRegistry, StatusSegment } from 'mu-agents';
+import type { PluginRegistry, StatusSegment } from 'mu-core';
 import { useEffect, useMemo, useState } from 'react';
 import type { InkUIService } from '../plugins/InkUIService';
 

package/src/tui/chat/useSessionPersistence.ts

@@ -1,16 +1,23 @@
-import type { ChatMessage } from 'mu-provider';
-import { useCallback, useRef, useState } from 'react';
+import type { ChatMessage } from 'mu-core';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { SessionPathHolder } from '../../runtime/createRegistry';
 import { generateSessionPath, loadSession, saveSession } from '../../sessions/index';
 
 export interface SessionPersistenceState {
-  messages: ChatMessage[];
-  setMessages: React.Dispatch<React.SetStateAction<ChatMessage[]>>;
   inputHistory: string[];
   appendHistory: (text: string) => void;
   sessionPathRef: React.RefObject<string>;
+  /** Persist the given transcript to the current session file. */
   saveCurrent: (messages: ChatMessage[]) => void;
-  onNew: () => void;
-  onLoadSession: (path: string) => void;
+  /** Reset to a brand-new session: rotates the file path. */
+  resetForNew: () => void;
+  /**
+   * Load a transcript from disk and adopt its path. Returns the loaded
+   * messages so the caller can hand them to the session.
+   */
+  loadFromPath: (path: string) => ChatMessage[];
+  /** Replace history (used after resume / load). */
+  setHistory: (history: string[]) => void;
 }
 
 function userPromptsFrom(messages: ChatMessage[]): string[] {
@@ -18,17 +25,28 @@ function userPromptsFrom(messages: ChatMessage[]): string[] {
 }
 
 /**
- * Owns the conversation transcript and its on-disk persistence. Keeps the
- * current session path, the transcript, and the user-input history in sync.
+ * Side-channel persistence: history bookkeeping, on-disk save, and session
+ * file path management. Does NOT own the transcript — `Session` is the
+ * single source of truth in the new architecture, this hook only writes to
+ * disk and tracks the current target path.
  *
  * Save errors are logged to stderr and do not surface to the chat error
  * channel — they're considered non-fatal (next save attempt may succeed).
  */
-export function useSessionPersistence(initialMessages?: ChatMessage[]): SessionPersistenceState {
-  const [messages, setMessages] = useState<ChatMessage[]>(initialMessages ?? []);
+export function useSessionPersistence(
+  initialMessages?: ChatMessage[],
+  sessionPathHolder?: SessionPathHolder,
+): SessionPersistenceState {
   const [inputHistory, setInputHistory] = useState<string[]>(userPromptsFrom(initialMessages ?? []));
   const sessionPathRef = useRef(generateSessionPath());
 
+  // Mirror the live path into the cross-plugin holder so mu-agents can read
+  // it lazily when dispatching a subagent. Using a useEffect keeps the
+  // holder write off the React render path.
+  useEffect(() => {
+    if (sessionPathHolder) sessionPathHolder.current = sessionPathRef.current;
+  }, [sessionPathHolder]);
+
   const appendHistory = useCallback((text: string) => {
     setInputHistory((prev) => [...prev, text]);
   }, []);
@@ -39,19 +57,28 @@ export function useSessionPersistence(initialMessages?: ChatMessage[]): SessionP
     });
   }, []);
 
-  const onNew = useCallback(() => {
-    setMessages([]);
+  const resetForNew = useCallback(() => {
     sessionPathRef.current = generateSessionPath();
-  }, []);
+    if (sessionPathHolder) sessionPathHolder.current = sessionPathRef.current;
+    setInputHistory([]);
+  }, [sessionPathHolder]);
+
+  const loadFromPath = useCallback(
+    (path: string): ChatMessage[] => {
+      const msgs = loadSession(path);
+      if (msgs.length > 0) {
+        sessionPathRef.current = path;
+        if (sessionPathHolder) sessionPathHolder.current = sessionPathRef.current;
+        setInputHistory(userPromptsFrom(msgs));
+      }
+      return msgs;
+    },
+    [sessionPathHolder],
+  );
 
-  const onLoadSession = useCallback((path: string) => {
-    const msgs = loadSession(path);
-    if (msgs.length > 0) {
-      setMessages(msgs);
-      setInputHistory(userPromptsFrom(msgs));
-      sessionPathRef.current = path;
-    }
+  const setHistory = useCallback((history: string[]) => {
+    setInputHistory(history);
   }, []);
 
-  return { messages, setMessages, inputHistory, appendHistory, sessionPathRef, saveCurrent, onNew, onLoadSession };
+  return { inputHistory, appendHistory, sessionPathRef, saveCurrent, resetForNew, loadFromPath, setHistory };
 }