mu-coding 0.8.0 → 0.9.0

package/src/tui/chat/useChatSession.ts

@@ -1,6 +1,7 @@
 import type { ChatMessage, ProviderConfig, Session } from 'mu-core';
-import { type PluginRegistry, runTransformUserInputHooks } 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';
@@ -23,6 +24,12 @@ 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 {
@@ -41,6 +48,7 @@ interface SessionDeps {
   initialMessages?: ChatMessage[];
   registry: PluginRegistry;
   messageBus?: HostMessageBus;
+  sessionPathHolder?: SessionPathHolder;
 }
 
 /**
@@ -151,6 +159,76 @@ interface OnSendDeps {
   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;
@@ -160,13 +238,22 @@ function useOnSend(deps: OnSendDeps): (text: string) => Promise<void> {
 
       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 = {
-        role: 'user',
-        content: finalText,
-        ...(attachment.attachment ? { images: [attachment.attachment] } : {}),
-      };
+      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);
@@ -204,7 +291,7 @@ function useOnSend(deps: OnSendDeps): (text: string) => Promise<void> {
  */
 export function useChatSession(deps: SessionDeps): ChatSessionState {
   const { session, config, currentModel, attachment, controllerRef, initialMessages, registry, messageBus } = deps;
-  const persistence = useSessionPersistence(initialMessages);
+  const persistence = useSessionPersistence(initialMessages, deps.sessionPathHolder);
   const { appendHistory, saveCurrent, resetForNew, loadFromPath } = persistence;
 
   // Initial seed: feed any persisted messages into the session once.
@@ -253,6 +340,16 @@ export function useChatSession(deps: SessionDeps): ChatSessionState {
     attachment.clear();
   }, [resetForNew, session, attachment, controllerRef]);
 
+  const onCompact = useOnCompact({
+    streaming,
+    session,
+    config,
+    currentModel,
+    registry,
+    controllerRef,
+    saveCurrent,
+  });
+
   const onLoadSession = useCallback(
     (path: string) => {
       const loaded = loadFromPath(path);
@@ -280,5 +377,6 @@ export function useChatSession(deps: SessionDeps): ChatSessionState {
     onSend,
     onNew,
     onLoadSession,
+    onCompact,
   };
 }

package/src/tui/chat/useModels.ts

@@ -1,5 +1,5 @@
 import type { ApiModel } from 'mu-core';
-import { listModels } from 'mu-openai-provider';
+import { fetchModelContextLimit, listModels } from 'mu-openai-provider';
 import { useCallback, useEffect, useState } from 'react';
 import { saveConfig } from '../../config/index';
 
@@ -42,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/useSessionPersistence.ts

@@ -1,5 +1,6 @@
 import type { ChatMessage } from 'mu-core';
-import { useCallback, useRef, useState } from 'react';
+import { useCallback, useEffect, useRef, useState } from 'react';
+import type { SessionPathHolder } from '../../runtime/createRegistry';
 import { generateSessionPath, loadSession, saveSession } from '../../sessions/index';
 
 export interface SessionPersistenceState {
@@ -32,10 +33,20 @@ function userPromptsFrom(messages: ChatMessage[]): string[] {
  * 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 {
+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]);
   }, []);
@@ -48,17 +59,22 @@ export function useSessionPersistence(initialMessages?: ChatMessage[]): SessionP
 
   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;
-      setInputHistory(userPromptsFrom(msgs));
-    }
-    return msgs;
-  }, []);
+  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 setHistory = useCallback((history: string[]) => {
     setInputHistory(history);

package/src/tui/chat/useStatusSegments.ts

@@ -14,6 +14,9 @@ interface StatusSegmentOptions {
   /** Tokens served from server-side prompt cache. Rendered as `(N cached)`
    *  next to the total when > 0. Omit (or pass 0) to hide the suffix. */
   cachedTokens?: number;
+  /** Model context window (input + output) reported by the provider; when
+   *  set, the tokens segment is rendered as `used/limit tokens`. */
+  contextLimit?: number;
   pluginStatus?: StatusSegment[];
 }
 
@@ -23,6 +26,14 @@ function truncate(text: string, max: number): string {
 
 const tokenFormatter = new Intl.NumberFormat('en-US');
 function formatTokens(n: number): string {
+  if (n >= 1_000_000) {
+    const v = n / 1_000_000;
+    return `${v >= 10 ? v.toFixed(0) : v.toFixed(1)}M`;
+  }
+  if (n >= 1000) {
+    const v = n / 1000;
+    return `${v >= 10 ? v.toFixed(0) : v.toFixed(1)}k`;
+  }
   return tokenFormatter.format(n);
 }
 
@@ -31,15 +42,24 @@ export function useStatusSegments(options: StatusSegmentOptions): StatusBarSegme
   const segments: StatusBarSegment[] = [];
 
   if (options.streaming) {
-    segments.push({ text: `${spinner} generating`, color: 'yellow' });
+    segments.push({ text: spinner, color: 'yellow', align: 'left' });
   }
   if (options.totalTokens > 0) {
     const cached = options.cachedTokens ?? 0;
-    const label =
-      cached > 0
-        ? `${formatTokens(options.totalTokens)} tokens (${formatTokens(cached)} cached)`
-        : `${formatTokens(options.totalTokens)} tokens`;
-    segments.push({ text: label, dim: true });
+    const used = formatTokens(options.totalTokens);
+    let head: string;
+    if (options.contextLimit) {
+      const pct = (options.totalTokens / options.contextLimit) * 100;
+      const pctStr = pct >= 10 ? pct.toFixed(0) : pct.toFixed(1);
+      head = `${used} (${pctStr}%)`;
+    } else {
+      head = used;
+    }
+    if (cached > 0) {
+      segments.push({ text: `${head} · ${formatTokens(cached)} cached`, dim: true });
+    } else {
+      segments.push({ text: head, dim: true });
+    }
   }
   if (options.abortWarning) {
     segments.push({ text: 'Esc again to stop', color: 'yellow' });

package/src/tui/chat/useSubagentBrowser.ts

@@ -0,0 +1,133 @@
+/**
+ * Subagent browser state machine.
+ *
+ * Exposes:
+ *  - the live list of `SubagentRun`s (subscribed to the registry)
+ *  - the current `viewMode` (chat vs browsing a specific run)
+ *  - keyboard handlers wired through `useChordKeyboard`:
+ *      Ctrl+X ↓        — enter browser at the most recent run
+ *      Ctrl+X →        — next run (loops)
+ *      Ctrl+X ←        — previous run (loops)
+ *      Ctrl+X ↑ or Esc — back to chat
+ *
+ * Returning to chat happens via the `Esc` handler the panel registers
+ * directly (kept outside the chord so it's reachable without the prefix).
+ */
+
+import { useInput } from 'ink';
+import type { SubagentRun, SubagentRunRegistry } from 'mu-agents';
+import { useCallback, useEffect, useMemo, useState } from 'react';
+import { useChordKeyboard } from '../hooks/useChordKeyboard';
+
+export type SubagentViewMode = { kind: 'chat' } | { kind: 'subagent'; runId: string };
+
+export interface SubagentBrowserState {
+  mode: SubagentViewMode;
+  runs: SubagentRun[];
+  currentRun: SubagentRun | undefined;
+  /** 1-based position of the current run (for UI labels like "i / N"). */
+  position: { index: number; total: number } | null;
+  enterLatest: () => void;
+  next: () => void;
+  prev: () => void;
+  exit: () => void;
+}
+
+const NOOP = (): void => {
+  // Intentional: returned by the empty-registry shape so call sites can
+  // wire handlers up without null-checking each invocation.
+};
+
+const EMPTY_BROWSER: SubagentBrowserState = {
+  mode: { kind: 'chat' },
+  runs: [],
+  currentRun: undefined,
+  position: null,
+  enterLatest: NOOP,
+  next: NOOP,
+  prev: NOOP,
+  exit: NOOP,
+};
+
+export function useSubagentBrowser(registry: SubagentRunRegistry | undefined): SubagentBrowserState {
+  const [runs, setRuns] = useState<SubagentRun[]>(() => registry?.list() ?? []);
+  const [mode, setMode] = useState<SubagentViewMode>({ kind: 'chat' });
+
+  // Subscribe to registry events; the listener fires immediately on
+  // subscribe with the current snapshot, so the initial state is correct
+  // even when the registry already has runs from a resumed session.
+  useEffect(() => {
+    if (!registry) return;
+    return registry.subscribe((next) => setRuns(next));
+  }, [registry]);
+
+  // If the run we're showing disappears (registry cleared on /new), bounce
+  // back to chat so the user isn't stuck on a phantom run.
+  useEffect(() => {
+    if (mode.kind !== 'subagent') return;
+    if (!runs.some((r) => r.id === mode.runId)) setMode({ kind: 'chat' });
+  }, [runs, mode]);
+
+  const exit = useCallback(() => setMode({ kind: 'chat' }), []);
+
+  const enterLatest = useCallback(() => {
+    if (runs.length === 0) return;
+    const last = runs[runs.length - 1];
+    setMode({ kind: 'subagent', runId: last.id });
+  }, [runs]);
+
+  const cycle = useCallback(
+    (direction: 1 | -1) => {
+      if (runs.length === 0) return;
+      const currentId = mode.kind === 'subagent' ? mode.runId : runs[runs.length - 1].id;
+      const idx = runs.findIndex((r) => r.id === currentId);
+      const start = idx === -1 ? runs.length - 1 : idx;
+      const len = runs.length;
+      // Wrap-around — `(start + direction + len) % len` is the canonical
+      // modulo trick that handles negative results in JS (`%` keeps sign).
+      const nextIdx = (start + direction + len) % len;
+      setMode({ kind: 'subagent', runId: runs[nextIdx].id });
+    },
+    [mode, runs],
+  );
+
+  const next = useCallback(() => cycle(1), [cycle]);
+  const prev = useCallback(() => cycle(-1), [cycle]);
+
+  // Ctrl+X chord is always armed, but the follow-ups are no-ops while no
+  // subagent run exists (so the user gets terminal-bell silence rather
+  // than an unexpected mode switch).
+  useChordKeyboard({
+    prefix: ({ key, input }) => key.ctrl === true && input === 'x',
+    followUps: [
+      { match: ({ key }) => key.downArrow === true, handler: enterLatest },
+      { match: ({ key }) => key.rightArrow === true, handler: next },
+      { match: ({ key }) => key.leftArrow === true, handler: prev },
+      { match: ({ key }) => key.upArrow === true, handler: exit },
+    ],
+  });
+
+  // Esc returns to chat from the browser. Active only while we're actually
+  // showing a run; otherwise we'd intercept Esc clearing modal/picker UIs.
+  useInput(
+    (_input, key) => {
+      if (key.escape) exit();
+    },
+    { isActive: mode.kind === 'subagent' },
+  );
+
+  const currentRun = useMemo(
+    () => (mode.kind === 'subagent' ? runs.find((r) => r.id === mode.runId) : undefined),
+    [mode, runs],
+  );
+  const position = useMemo(() => {
+    if (mode.kind !== 'subagent') return null;
+    const i = runs.findIndex((r) => r.id === mode.runId);
+    if (i === -1) return null;
+    return { index: i + 1, total: runs.length };
+  }, [mode, runs]);
+
+  if (!registry) return EMPTY_BROWSER;
+
+  return { mode, runs, currentRun, position, enterLatest, next, prev, exit };
+}

package/src/tui/components/chat/ChatPanel.tsx

@@ -1,5 +1,7 @@
+import type { SubagentRunRegistry } from 'mu-agents';
 import type { ChatMessage, PluginRegistry, ProviderConfig } from 'mu-core';
 import type { ShutdownFn } from '../../../app/shutdown';
+import type { SessionPathHolder } from '../../../runtime/createRegistry';
 import type { HostMessageBus } from '../../../runtime/messageBus';
 import { ChatContext } from '../../chat/ChatContext';
 import { MessageRendererProvider, useRegistryRenderers } from '../../chat/MessageRendererContext';
@@ -15,6 +17,8 @@ export function ChatPanel({
   messageBus,
   uiService,
   shutdown,
+  sessionPathHolder,
+  subagentRuns,
 }: {
   config: ProviderConfig;
   initialMessages?: ChatMessage[];
@@ -22,8 +26,19 @@ export function ChatPanel({
   messageBus?: HostMessageBus;
   uiService?: InkUIService;
   shutdown?: ShutdownFn;
+  sessionPathHolder?: SessionPathHolder;
+  subagentRuns?: SubagentRunRegistry;
 }) {
-  const { ctx, bodyProps } = useChatPanel({ config, initialMessages, registry, messageBus, uiService, shutdown });
+  const { ctx, bodyProps } = useChatPanel({
+    config,
+    initialMessages,
+    registry,
+    messageBus,
+    uiService,
+    shutdown,
+    sessionPathHolder,
+    subagentRuns,
+  });
   const toolDisplays = useToolDisplayMap(registry);
   const renderers = useRegistryRenderers(registry);
 

package/src/tui/components/chat/ChatPanelBody.tsx

@@ -1,6 +1,8 @@
 import { Box, type DOMElement as InkDOMElement } from 'ink';
 import type { ChatMessage } from 'mu-core';
 import type { StreamState } from '../../chat/useChatSession';
+import type { SubagentBrowserState } from '../../chat/useSubagentBrowser';
+import { useInputInfoSegments } from '../../hooks/useInputInfoSegments';
 import { InputBox } from '../../input/InputBox';
 import type { InkUIService } from '../../plugins/InkUIService';
 import { MessageView } from '../messageView';
@@ -9,6 +11,7 @@ import type { StatusBarSegment } from '../statusBar';
 import { StatusBar } from '../statusBar';
 import { DialogLayer } from '../ui/dialogLayer';
 import { Pickers } from './Pickers';
+import { SubagentBrowserPanel } from './SubagentBrowserPanel';
 
 export interface ChatPanelBodyProps {
   width: number;
@@ -32,9 +35,26 @@ export interface ChatPanelBodyProps {
   statusSegments: StatusBarSegment[];
   toasts: Toast[];
   onDismissToast: (id: number) => void;
+  /** Subagent browser state — when in subagent mode the chat body is replaced. */
+  browser?: SubagentBrowserState;
 }
 
 export function ChatPanelBody(props: ChatPanelBodyProps) {
+  const infoSegments = useInputInfoSegments();
+
+  // Browser mode: replace the entire chat body with the subagent panel.
+  // Modals (dialog layer, toasts) still render so an `ask` triggered by a
+  // subagent dispatch can still surface to the user.
+  if (props.browser?.mode.kind === 'subagent' && props.browser.currentRun) {
+    return (
+      <Box flexDirection="column" height={props.height} width={props.width}>
+        <SubagentBrowserPanel run={props.browser.currentRun} position={props.browser.position} />
+        {props.uiService && <DialogLayer service={props.uiService} />}
+        <ToastContainer toasts={props.toasts} onDismiss={props.onDismissToast} />
+      </Box>
+    );
+  }
+
   return (
     <Box flexDirection="column" height={props.height} width={props.width}>
       <MessageView
@@ -55,6 +75,7 @@ export function ChatPanelBody(props: ChatPanelBodyProps) {
         isActive={props.isActive}
         model={props.model}
         history={props.history}
+        infoSegments={infoSegments}
       />
       <StatusBar segments={props.statusSegments} />
       <Pickers />