mu-coding 0.8.0 → 0.10.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "mu-coding",
-  "version": "0.8.0",
+  "version": "0.10.0",
   "description": "Minimal terminal AI assistant for local models",
   "type": "module",
   "bin": {
@@ -24,9 +24,9 @@
   },
   "dependencies": {
     "ink": "^7.0.1",
-    "mu-agents": "0.8.0",
-    "mu-core": "0.8.0",
-    "mu-openai-provider": "0.8.0",
+    "mu-agents": "0.10.0",
+    "mu-core": "0.10.0",
+    "mu-openai-provider": "0.10.0",
     "react": "^19.2.5"
   }
 }

package/src/cli/install.ts

@@ -5,7 +5,7 @@ import { canonicalNpmSpecifier, getDataDir, loadConfig, parseBareNpmSpec, saveCo
 
 const INIT_PACKAGE_JSON = JSON.stringify({ private: true, dependencies: {} }, null, 2);
 
-function ensureDataDir(): string {
+export function ensureDataDir(): string {
   const dataDir = getDataDir();
   mkdirSync(dataDir, { recursive: true });
 
@@ -17,6 +17,21 @@ function ensureDataDir(): string {
   return dataDir;
 }
 
+/**
+ * Install an npm package into the mu data dir using `bun add`. Shared by the
+ * `mu install` CLI and the runtime auto-installer (pluginLoader). `bare` is
+ * the spec without the `npm:` prefix (e.g. `mu-coding-agents`,
+ * `@scope/foo@^1.0.0`). When `silent`, stdout is suppressed (used by the
+ * runtime path so the TUI isn't garbled at startup).
+ */
+export function installNpmPackage(bare: string, options: { silent?: boolean } = {}): void {
+  const dataDir = ensureDataDir();
+  execFileSync('bun', ['add', bare], {
+    cwd: dataDir,
+    stdio: options.silent ? 'pipe' : 'inherit',
+  });
+}
+
 function stripNpmPrefix(specifier: string): string {
   if (!specifier.startsWith('npm:')) {
     console.error(`Error: package specifier must start with npm: — got "${specifier}"`);
@@ -31,7 +46,7 @@ export async function runInstall(args: string[]): Promise<void> {
     process.exit(1);
   }
 
-  const dataDir = ensureDataDir();
+  ensureDataDir();
   const config = loadConfig();
   const plugins = config.plugins ?? [];
 
@@ -41,7 +56,7 @@ export async function runInstall(args: string[]): Promise<void> {
 
     console.log(`Installing ${bare}...`);
     try {
-      execFileSync('bun', ['add', bare], { cwd: dataDir, stdio: 'inherit' });
+      installNpmPackage(bare);
     } catch (err) {
       console.error(`Failed to install ${bare}: ${err instanceof Error ? err.message : err}`);
       process.exit(1);

package/src/plugin.ts

@@ -12,11 +12,13 @@
  * registry in after constructing it.
  */
 
-import type { ApprovalGateway } from 'mu-agents';
+import type { ApprovalGateway, SubagentRunRegistry } from 'mu-agents';
 import type { ChatMessage, Plugin, PluginContext, PluginRegistry } from 'mu-core';
 import type { ShutdownFn } from './app/shutdown';
 import type { AppConfig } from './config/index';
 import { createCodingToolsPlugin } from './runtime/codingTools/index';
+import type { SessionPathHolder } from './runtime/createRegistry';
+import { createFileMentionProvider } from './runtime/fileMentionProvider';
 import type { HostMessageBus } from './runtime/messageBus';
 import { createTuiChannel } from './tui/channel/tuiChannel';
 import { createInkApprovalChannel } from './tui/plugins/InkApprovalChannel';
@@ -28,6 +30,12 @@ export interface CodingPluginConfig {
   messageBus: HostMessageBus;
   uiService: InkUIService;
   shutdown: ShutdownFn;
+  /**
+   * Mutable holder updated by the TUI's session persistence hook so other
+   * plugins (mu-agents) can read the current parent session path when
+   * dispatching subagents. `undefined` until the React tree mounts.
+   */
+  sessionPathHolder?: SessionPathHolder;
   /**
    * Concrete `PluginRegistry` instance used by the TUI to subscribe to
    * renderers / shortcuts / status segments. Required because `ctx.registry`
@@ -38,6 +46,7 @@ export interface CodingPluginConfig {
 
 interface AgentPluginShape {
   approvalGateway?: ApprovalGateway;
+  runs?: SubagentRunRegistry;
 }
 
 export function createCodingPlugin(config: CodingPluginConfig): Plugin {
@@ -49,6 +58,7 @@ export function createCodingPlugin(config: CodingPluginConfig): Plugin {
   // Captured at activation time so deactivate can clean up both registrations.
   let unregisterTuiChannel: (() => void) | null = null;
   let unregisterApprovalChannel: (() => void) | null = null;
+  let unregisterFileMentions: (() => void) | null = null;
 
   return {
     name: 'mu-coding',
@@ -62,6 +72,13 @@ export function createCodingPlugin(config: CodingPluginConfig): Plugin {
       // Register the TUI channel so other code can stop it gracefully via
       // ctx.channels.stopAll(). The TUI subscribes to the concrete registry
       // (passed in via config), not the narrow context-exposed view.
+      // Resolve the live mu-agents handle so the TUI can subscribe to the
+      // subagent run registry (browser panel + live header). Looked up
+      // loosely so coding still works in setups that disabled the agent
+      // plugin — the TUI then renders a fallback header without the live
+      // subagent navigation surfaces.
+      const agentPlugin = ctx.getPlugin?.<Plugin & AgentPluginShape>('mu-agents');
+
       unregisterTuiChannel =
         ctx.channels?.register(
           createTuiChannel({
@@ -71,13 +88,22 @@ export function createCodingPlugin(config: CodingPluginConfig): Plugin {
             messageBus: config.messageBus,
             uiService: config.uiService,
             shutdown: config.shutdown,
+            sessionPathHolder: config.sessionPathHolder,
+            subagentRuns: agentPlugin?.runs,
           }),
         ) ?? null;
 
-      // Register the Ink approval channel against mu-agents' gateway, when
-      // mu-agents is present. We use `ctx.getPlugin` to look it up loosely
-      // so coding still works in setups that disabled the agent plugin.
-      const agentPlugin = ctx.getPlugin?.<Plugin & AgentPluginShape>('mu-agents');
+      // Register a file completion provider on `@`. Sits alongside the
+      // mu-agents `@`-provider — useMentionPicker concatenates results from
+      // every provider matching a trigger, grouped by category in the UI.
+      // When the user types `@foo`, agents that match by name appear first;
+      // files matching by basename/path follow.
+      if (ctx.registerMentionProvider) {
+        unregisterFileMentions = ctx.registerMentionProvider('@', createFileMentionProvider(ctx.cwd));
+      }
+
+      // Register the Ink approval channel against mu-agents' gateway when
+      // it's available (the lookup above already resolved `agentPlugin`).
       if (agentPlugin?.approvalGateway) {
         unregisterApprovalChannel = agentPlugin.approvalGateway.registerChannel(
           'tui',
@@ -88,6 +114,8 @@ export function createCodingPlugin(config: CodingPluginConfig): Plugin {
     deactivate() {
       unregisterApprovalChannel?.();
       unregisterApprovalChannel = null;
+      unregisterFileMentions?.();
+      unregisterFileMentions = null;
       unregisterTuiChannel?.();
       unregisterTuiChannel = null;
       inner.deactivate?.();

package/src/runtime/createRegistry.test.ts

@@ -124,7 +124,7 @@ describe('createRegistry — activation order + plugin propagation', () => {
     }
   });
 
-  it('agent slash command is contributed by mu-agents (no coding-agents by default)', async () => {
+  it('mu-agents contributes per-primary-agent slash commands but no generic /agent', async () => {
     const cwd = mkdtempSync(join(tmpdir(), 'mu-cr-'));
     try {
       const ui = new InkUIService();
@@ -135,8 +135,9 @@ describe('createRegistry — activation order + plugin propagation', () => {
       });
 
       const commandNames = registry.getCommands().map((c) => c.name);
-      expect(commandNames).toContain('agent');
-      // build/plan/review come from mu-agents' DEFAULT_PRIMARY_AGENTS.
+      // The generic `/agent` command was removed; discoverability is via
+      // the per-agent switch commands and the Tab shortcut.
+      expect(commandNames).not.toContain('agent');
       // `explore` originates from mu-coding-agents, which is no longer auto-loaded.
       expect(commandNames).not.toContain('explore');
     } finally {

package/src/runtime/createRegistry.ts

@@ -1,3 +1,5 @@
+import { mkdir } from 'node:fs/promises';
+import { dirname } from 'node:path';
 import { createAgentsPlugin } from 'mu-agents';
 import type { ChatMessage } from 'mu-core';
 import {
@@ -13,10 +15,28 @@ import { createOpenAIProviderPlugin } from 'mu-openai-provider';
 import type { ShutdownFn } from '../app/shutdown';
 import type { AppConfig } from '../config/index';
 import { createCodingPlugin } from '../plugin';
+import { saveSession } from '../sessions/index';
 import type { InkUIService } from '../tui/plugins/InkUIService';
 import { createMessageBus, type HostMessageBus } from './messageBus';
 import { discoverPluginFiles, loadConfiguredPlugin } from './pluginLoader';
 
+/**
+ * Tiny mutable holder used to bridge the React-owned current session path
+ * (`useSessionPersistence`) with plugins that need it at construction time
+ * (here, mu-agents — to derive a sibling directory for subagent runs).
+ *
+ * The holder is created up-front and passed both to `mu-agents` (read via
+ * `getParentSessionPath`) and to the TUI channel (which forwards it into
+ * the React tree where `useSessionPersistence` keeps it in sync).
+ */
+export interface SessionPathHolder {
+  current: string | undefined;
+}
+
+function createSessionPathHolder(): SessionPathHolder {
+  return { current: undefined };
+}
+
 interface CreateRegistryOptions {
   cwd: string;
   config: AppConfig;
@@ -42,6 +62,7 @@ interface RegistryBundle {
   providers: ProviderRegistry;
   channels: ChannelRegistry;
   activity: ActivityBus;
+  sessionPathHolder: SessionPathHolder;
 }
 
 interface PluginConfigInputs {
@@ -101,6 +122,7 @@ async function registerBuiltins(
   options: CreateRegistryOptions,
   inputs: PluginConfigInputs,
   messageBus: HostMessageBus,
+  sessionPathHolder: SessionPathHolder,
 ): Promise<void> {
   await registry.register(createOpenAIProviderPlugin());
   await registry.register(
@@ -108,6 +130,14 @@ async function registerBuiltins(
       config: options.config,
       model: options.config.model,
       approvalChannelId: 'tui',
+      // The chat session updates this holder once `useSessionPersistence`
+      // mounts; mu-agents reads it lazily so subagent runs always land
+      // beside the *current* parent transcript file (survives /new + load).
+      getParentSessionPath: () => sessionPathHolder.current,
+      sessionWriter: async (path, messages) => {
+        await mkdir(dirname(path), { recursive: true });
+        await saveSession(path, messages);
+      },
     }),
   );
   await registry.register(
@@ -117,6 +147,7 @@ async function registerBuiltins(
       messageBus,
       uiService: options.uiService,
       shutdown: options.shutdown ?? noopShutdown,
+      sessionPathHolder,
       // Pass the concrete registry: the TUI subscribes to renderer / shortcut
       // / status streams that are not part of the narrow `PluginRegistryView`
       // exposed via `ctx.registry`.
@@ -133,6 +164,7 @@ export async function createRegistry(options: CreateRegistryOptions): Promise<Re
   const providers = createProviderRegistry();
   const channels = createChannelRegistry();
   const activity = createActivityBus();
+  const sessionPathHolder = createSessionPathHolder();
   const registry = new PluginRegistry({
     cwd,
     config: {},
@@ -146,7 +178,7 @@ export async function createRegistry(options: CreateRegistryOptions): Promise<Re
 
   const inputs: PluginConfigInputs = { uiService, shutdown, appConfig: config };
 
-  await registerBuiltins(registry, options, inputs, messageBus);
+  await registerBuiltins(registry, options, inputs, messageBus, sessionPathHolder);
 
   // User-extension plugins ride on top of the builtins.
   for (const filePath of discoverPluginFiles()) {
@@ -159,5 +191,5 @@ export async function createRegistry(options: CreateRegistryOptions): Promise<Re
     await loadConfiguredPlugin(registry, name, buildPluginConfig(inputs, pluginConfig), uiService);
   }
 
-  return { registry, messageBus, providers, channels, activity };
+  return { registry, messageBus, providers, channels, activity, sessionPathHolder };
 }

package/src/runtime/fileMentionProvider.ts

@@ -0,0 +1,117 @@
+import { execFileSync } from 'node:child_process';
+import { type Dirent, readdirSync } from 'node:fs';
+import { join, relative, sep } from 'node:path';
+import type { MentionCompletion, MentionProvider } from 'mu-core';
+
+const CACHE_TTL_MS = 5_000;
+const MAX_FILES = 5_000;
+const MAX_RESULTS = 12;
+const IGNORE_DIRS = new Set(['node_modules', '.git', 'dist', 'build', 'out', '.next', '.turbo', 'coverage']);
+
+interface FileCache {
+  files: string[];
+  builtAt: number;
+}
+
+let cache: FileCache | null = null;
+let cacheCwd = '';
+
+function listGitFiles(cwd: string): string[] | null {
+  try {
+    const stdout = execFileSync('git', ['ls-files', '--cached', '--others', '--exclude-standard'], {
+      cwd,
+      encoding: 'utf8',
+      maxBuffer: 8 * 1024 * 1024,
+      stdio: ['ignore', 'pipe', 'ignore'],
+    });
+    const files = stdout.split('\n').filter((line) => line.length > 0);
+    return files.slice(0, MAX_FILES);
+  } catch {
+    return null;
+  }
+}
+
+// biome-ignore lint/complexity/noExcessiveCognitiveComplexity: iterative FS walker with MAX_FILES early-exit — branching is the algorithm; extracting helpers would scatter the cap check.
+function walkFs(root: string): string[] {
+  const out: string[] = [];
+  const stack: string[] = [root];
+  while (stack.length > 0 && out.length < MAX_FILES) {
+    const dir = stack.pop();
+    if (!dir) break;
+    let entries: Dirent[];
+    try {
+      entries = readdirSync(dir, { withFileTypes: true }) as Dirent[];
+    } catch {
+      continue;
+    }
+    for (const entry of entries) {
+      if (entry.name.startsWith('.') && entry.name !== '.env.example') continue;
+      if (IGNORE_DIRS.has(entry.name)) continue;
+      const full = join(dir, entry.name);
+      if (entry.isDirectory()) {
+        stack.push(full);
+      } else if (entry.isFile()) {
+        out.push(relative(root, full).split(sep).join('/'));
+        if (out.length >= MAX_FILES) break;
+      }
+    }
+  }
+  return out;
+}
+
+function refreshCache(cwd: string): string[] {
+  if (cache && cacheCwd === cwd && Date.now() - cache.builtAt < CACHE_TTL_MS) {
+    return cache.files;
+  }
+  const files = listGitFiles(cwd) ?? walkFs(cwd);
+  cache = { files, builtAt: Date.now() };
+  cacheCwd = cwd;
+  return files;
+}
+
+/**
+ * Score a file path against `partial` for ranking.
+ *  - exact basename match → 0 (best)
+ *  - basename starts with partial → 1
+ *  - basename contains partial → 2
+ *  - path contains partial → 3
+ *  - otherwise → Infinity (filtered out)
+ */
+function scorePath(path: string, partial: string): number {
+  if (!partial) return path.length; // empty partial → shorter paths first
+  const lower = path.toLowerCase();
+  const base = lower.slice(lower.lastIndexOf('/') + 1);
+  const p = partial.toLowerCase();
+  if (base === p) return 0;
+  if (base.startsWith(p)) return 1;
+  if (base.includes(p)) return 2;
+  if (lower.includes(p)) return 3;
+  return Number.POSITIVE_INFINITY;
+}
+
+/**
+ * Build the file mention provider bound to `cwd`. Suggests up to
+ * `MAX_RESULTS` files matched against the partial, ranked by basename
+ * proximity. Cached for {@link CACHE_TTL_MS} so rapid keystrokes don't
+ * re-walk the tree.
+ */
+export function createFileMentionProvider(cwd: string): MentionProvider {
+  return (partial: string): MentionCompletion[] => {
+    const files = refreshCache(cwd);
+    if (files.length === 0) return [];
+    const scored: { path: string; score: number }[] = [];
+    for (const f of files) {
+      const score = scorePath(f, partial);
+      if (score < Number.POSITIVE_INFINITY) scored.push({ path: f, score });
+    }
+    scored.sort((a, b) => a.score - b.score || a.path.length - b.path.length || a.path.localeCompare(b.path));
+    return scored.slice(0, MAX_RESULTS).map(({ path }) => ({
+      value: path,
+      // Show the full path so the basename sits at the end of the line —
+      // the picker truncates the prefix when needed (`wrap="truncate-start"`)
+      // so the filename stays visible.
+      label: path,
+      category: 'files',
+    }));
+  };
+}

package/src/runtime/pluginLoader.ts

@@ -2,6 +2,7 @@ import { readdirSync } from 'node:fs';
 import { createRequire } from 'node:module';
 import { join, resolve } from 'node:path';
 import type { Plugin, PluginRegistry } from 'mu-core';
+import { installNpmPackage } from '../cli/install';
 import { getDataDir, getPluginsDir, parseBareNpmSpec } from '../config/index';
 import type { InkUIService } from '../tui/plugins/InkUIService';
 
@@ -31,14 +32,44 @@ function formatPluginError(name: string, err: unknown): string {
   return parts.join(': ');
 }
 
-function resolveNpmPlugin(specifier: string): string {
-  const { name } = parseBareNpmSpec(specifier.slice(4));
+/**
+ * Resolve an `npm:<spec>` plugin specifier to an absolute path on disk.
+ *
+ * If the package isn't installed yet, runs `bun add <spec>` against the mu
+ * data dir and retries — so users can list a plugin in `config.plugins`
+ * without having to invoke `mu install` first.
+ *
+ * `uiService` is optional: when provided, surface "Installing …" / failure
+ * messages through the TUI; otherwise fall back to stderr so the host's
+ * boot log still shows what happened.
+ */
+async function resolveNpmPlugin(specifier: string, uiService?: InkUIService): Promise<string> {
+  const bare = specifier.slice(4);
+  const { name } = parseBareNpmSpec(bare);
   const dataDir = getDataDir();
+  const require = createRequire(resolve(dataDir, 'package.json'));
+
   try {
-    const require = createRequire(resolve(dataDir, 'package.json'));
     return require.resolve(name);
-  } catch (err) {
-    throw new Error(`Cannot resolve "${name}" from ${dataDir}/node_modules — is it installed?`, { cause: err });
+  } catch (_firstErr) {
+    const installMsg = `Installing ${name}…`;
+    if (uiService) uiService.notify(installMsg, 'info');
+    else console.error(`[mu] ${installMsg}`);
+
+    try {
+      installNpmPackage(bare, { silent: true });
+    } catch (installErr) {
+      throw new Error(`Failed to auto-install "${name}" into ${dataDir}/node_modules`, { cause: installErr });
+    }
+
+    try {
+      return require.resolve(name);
+    } catch (retryErr) {
+      throw new Error(
+        `Auto-installed "${name}" but cannot resolve it from ${dataDir}/node_modules — install may have failed silently`,
+        { cause: retryErr },
+      );
+    }
   }
 }
 
@@ -85,7 +116,7 @@ export async function resolveConfiguredPlugin(
   const config = pluginConfig ?? {};
   let target: string;
   try {
-    target = name.startsWith('npm:') ? resolveNpmPlugin(name) : name;
+    target = name.startsWith('npm:') ? await resolveNpmPlugin(name, uiService) : name;
   } catch (err) {
     uiService?.notify(formatPluginError(name, err), 'error');
     return null;

package/src/tui/channel/tuiChannel.ts

@@ -5,9 +5,11 @@
  */
 
 import type { Instance } from 'ink';
+import type { SubagentRunRegistry } from 'mu-agents';
 import type { Channel, ChatMessage, PluginRegistry } from 'mu-core';
 import type { ShutdownFn } from '../../app/shutdown';
 import type { AppConfig } from '../../config/index';
+import type { SessionPathHolder } from '../../runtime/createRegistry';
 import type { HostMessageBus } from '../../runtime/messageBus';
 import type { InkUIService } from '../plugins/InkUIService';
 import { renderApp } from '../renderApp';
@@ -19,6 +21,8 @@ export interface TuiChannelOptions {
   messageBus: HostMessageBus;
   uiService: InkUIService;
   shutdown: ShutdownFn;
+  sessionPathHolder?: SessionPathHolder;
+  subagentRuns?: SubagentRunRegistry;
 }
 
 export function createTuiChannel(opts: TuiChannelOptions): Channel {
@@ -29,7 +33,16 @@ export function createTuiChannel(opts: TuiChannelOptions): Channel {
       // Idempotent: re-starting after a stop remounts; re-starting while
       // mounted is a no-op.
       if (instance) return;
-      instance = renderApp(opts);
+      instance = renderApp({
+        config: opts.config,
+        initialMessages: opts.initialMessages,
+        registry: opts.registry,
+        messageBus: opts.messageBus,
+        uiService: opts.uiService,
+        shutdown: opts.shutdown,
+        sessionPathHolder: opts.sessionPathHolder,
+        subagentRuns: opts.subagentRuns,
+      });
     },
     async stop() {
       if (!instance) return;

package/src/tui/chat/useAbort.ts

@@ -7,9 +7,14 @@ function useDoublePress(timeoutMs: number) {
 
   const confirm = useCallback(() => {
     if (warning) {
+      // Confirmed press: cancel the pending auto-reset and clear the
+      // warning flag immediately so the status hint ("Esc again to stop"
+      // / "Ctrl+C again to quit") disappears as soon as the action fires.
       if (timerRef.current) {
         clearTimeout(timerRef.current);
+        timerRef.current = null;
       }
+      setWarning(false);
       return true;
     }
     setWarning(true);

package/src/tui/chat/useChat.ts

@@ -1,4 +1,5 @@
 import { useApp } from 'ink';
+import type { SubagentRunRegistry } from 'mu-agents';
 import {
   type ChatMessage,
   createSessionManager,
@@ -8,6 +9,7 @@ import {
 } from 'mu-core';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import type { ShutdownFn } from '../../app/shutdown';
+import type { SessionPathHolder } from '../../runtime/createRegistry';
 import type { HostMessageBus } from '../../runtime/messageBus';
 import { listSessionsAsync, type SessionInfo } from '../../sessions/index';
 import type { InkUIService } from '../plugins/InkUIService';
@@ -30,6 +32,7 @@ export interface ChatContextValue {
   registry: PluginRegistry;
   uiService?: InkUIService;
   messageBus?: HostMessageBus;
+  subagentRuns?: SubagentRunRegistry;
 }
 
 export function useChat(
@@ -39,6 +42,8 @@ export function useChat(
   shutdown?: ShutdownFn,
   uiService?: InkUIService,
   messageBus?: HostMessageBus,
+  sessionPathHolder?: SessionPathHolder,
+  subagentRuns?: SubagentRunRegistry,
 ): ChatContextValue {
   const { exit } = useApp();
   const controllerRef = useRef<AbortController | null>(null);
@@ -65,6 +70,7 @@ export function useChat(
     initialMessages,
     registry,
     messageBus,
+    sessionPathHolder,
   });
   const abort = useAbort(session.streaming, controllerRef, exit, ABORT_TIMEOUT_MS, shutdown);
 
@@ -102,5 +108,6 @@ export function useChat(
     registry,
     uiService,
     messageBus,
+    subagentRuns,
   };
 }

package/src/tui/chat/useChatPanel.ts

@@ -1,7 +1,9 @@
 import { type DOMElement as InkDOMElement, useInput } from 'ink';
+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';
@@ -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',
@@ -26,11 +29,24 @@ interface UseChatPanelOptions {
   messageBus?: HostMessageBus;
   uiService?: InkUIService;
   shutdown?: ShutdownFn;
+  sessionPathHolder?: SessionPathHolder;
+  subagentRuns?: SubagentRunRegistry;
 }
 
 export function useChatPanel(options: UseChatPanelOptions) {
-  const { config, initialMessages, registry, messageBus, uiService, shutdown } = options;
-  const ctx = useChat(config, registry, initialMessages, shutdown, uiService, messageBus);
+  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);
@@ -59,6 +75,7 @@ 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,
@@ -67,6 +84,7 @@ export function useChatPanel(options: UseChatPanelOptions) {
     modelError: ctx.models.modelError,
     totalTokens: ctx.session.stream.totalTokens,
     cachedTokens: ctx.session.stream.cachedTokens,
+    contextLimit,
     pluginStatus,
   });
 
@@ -78,7 +96,7 @@ export function useChatPanel(options: UseChatPanelOptions) {
     scrollOffset,
     viewHeight,
     contentHeight,
-    isActive: !anyModalOpen,
+    isActive: !anyModalOpen && browser.mode.kind === 'chat',
     onScrollUp,
     onScrollDown,
     uiService,
@@ -92,7 +110,10 @@ export function useChatPanel(options: UseChatPanelOptions) {
     statusSegments,
     toasts,
     onDismissToast: dismiss,
+    browser,
   };
 
   return { ctx, bodyProps };
 }
+
+export type { SubagentBrowserState };