pi-optchat 0.6.3 → 0.6.5

package/README.md

@@ -137,9 +137,10 @@ See OpenAI's guides on [exporting ChatGPT data](https://help.openai.com/en/artic
 
 ## Connected windows
 
-Each profile is locked to one Pi process. If you open the same profile in a second terminal, Pi offers to connect it to the original window as a subagent.
+Each profile is locked to one Pi process. If you open the same profile in a second terminal, Pi offers to connect it to the original window as a subagent, or to go back to the profile picker.
 
 - Your first message starts a subagent in the second window's working directory. Later messages continue the same conversation.
+- The window looks like a normal Pi chat: replies, tool calls with their output and running time, the working spinner, and reports from the subagent's own agents in the dark box. Ctrl+O expands tool output.
 - The subagent runs inside the original process, which stays the only writer of memory. It appears in the original window's inspector and uses one of the 8 agent slots. While it is open, the original window can't switch profile or import.
 - The main agent is told when the conversation starts. Use `/tell-main <message>` to message it yourself; the subagent can use `tell_parent`, and the main agent replies with `tell`. Routine turns don't wake the main agent.
 - Run `/complete` when done. The window closes, remaining work stops, and the compactor writes a handoff for the main agent: decisions, changes, evidence, failures, unfinished work, and links to the transcripts.
@@ -174,12 +175,13 @@ To delete a profile, delete its folder. Your original Pi sessions are kept in Pi
 ## Good to know
 
 - **Profiles separate memory and instructions only.** Agents keep full filesystem access and share provider credentials.
+- **Tab title**: the terminal tab shows the profile and what it is doing: `π personal` while waiting for you, `● π personal` while the agent works, plus `· 2 agents` while subagents run. A connected window shows `↳ personal`, `● ↳ personal`, then `↳ personal · done` or `↳ personal · disconnected`. OptChat replaces Pi's default title and puts its own back when Pi resets it (new session, reload, rename).
 - **Use worktrees** when parallel agents edit the same repository; they share the filesystem.
 - **Instructions**: the main agent and subagents get Pi's usual global and repository `AGENTS.md` files and your skills, followed by the profile's `AGENTS.md`, which comes last and wins. OptChat replaces only Pi's opening prompt. Prompt templates work in the main session only.
 - **Images** are available during the current run but stored in memory as text placeholders.
 - **Pi's auto-compaction is off.** A single very long run can still hit the model's context limit; stop it and continue in a new turn.
 - **Restarts**: unsent inputs are recovered into memory, and pending subagent reports are delivered. Interrupted subagents are not restarted.
-- **Skill and template inputs** can occasionally be recovered as an unanswered input after a crash, because Pi expands them after the input journal records them. Plain text chat is unaffected.
+- **Prompt-template inputs** can be saved twice: expanded, and later in their original form as an unanswered input, because Pi expands them after the input journal records them. Skill commands (`/skill:name`) are matched back to their journaled input and don't have this problem. Plain text chat is unaffected.
 
 ## How it differs from the recipe
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-optchat",
-  "version": "0.6.3",
+  "version": "0.6.5",
   "type": "module",
   "pi": {
     "extensions": [

package/src/agent-view.ts

@@ -60,7 +60,8 @@ export class TranscriptView {
   private streaming?: AssistantMessageComponent;
   private expanded = false;
   constructor(private readonly tui: TUI, private readonly cwd: string, private readonly definition: (name: string) => Renderers = () => undefined) {}
-  toggleTools() { this.expanded = !this.expanded; for (const tool of this.tools.values()) tool.setExpanded(this.expanded); }
+  toggleTools() { this.setExpanded(!this.expanded); }
+  setExpanded(expanded: boolean) { if (expanded === this.expanded) return; this.expanded = expanded; for (const tool of this.tools.values()) tool.setExpanded(expanded); }
   private tool(id: string, name: string, args: unknown) {
     let tool = this.tools.get(id);
     if (!tool) {

package/src/agents.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, getAgentDir, type AgentSession, type AgentSessionEvent, type ModelRegistry } from '@earendil-works/pi-coding-agent';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { SUBAGENT, VIEW_DOC } from './prompts.ts';
@@ -28,10 +29,16 @@ const packageName = (path: string): string | undefined => {
   for (let dir = dirname(path); dir !== dirname(dir); dir = dirname(dir)) {
     const manifest = join(dir, 'package.json');
     if (!existsSync(manifest)) continue;
-    const data: unknown = JSON.parse(readFileSync(manifest, 'utf8'));
-    return data && typeof data === 'object' && 'name' in data && typeof data.name === 'string' ? data.name : undefined;
+    try {
+      const data: unknown = JSON.parse(readFileSync(manifest, 'utf8'));
+      return data && typeof data === 'object' && 'name' in data && typeof data.name === 'string' ? data.name : undefined;
+    } catch { return undefined; } // A broken manifest is not OptChat's and must not block every spawn.
   }
 };
+/** A task's cwd may start with `~` and may be relative to the spawning agent's directory. */
+export const taskDirectory = (cwd: string, path = '.', windows = process.platform === 'win32') =>
+  resolve(cwd, path.replace(windows ? /^~(?=$|[\\/])/ : /^~(?=$|\/)/, homedir()));
+export const CWD_DOC = 'Project directory the subagent works in (~ allowed); its AGENTS.md files load from there. Defaults to your current directory.';
 const isOptchat = (path: string) => packageName(path) === 'pi-optchat';
 export class Children {
   private readonly running = new Map<string, LiveRun>();
@@ -92,6 +99,7 @@ export class Children {
     } catch (error) { this.warn(`Could not record subagent activity: ${String(error)}`); }
   }
   async spawn(tasks: { task: string; cwd?: string }[], cwd: string, signal?: AbortSignal, parentId?: string, connected = false) {
+    for (const directory of tasks.map(t => taskDirectory(cwd, t.cwd))) if (!existsSync(directory) || !statSync(directory).isDirectory()) throw new Error(`No such directory: ${directory}`);
     if (this.closing) throw new Error('Profile is closing.');
     this.settling++;
     try { await this.memory.settle(signal); } finally { this.settling--; }
@@ -113,7 +121,7 @@ export class Children {
       for (const task of tasks) {
         signal?.throwIfAborted();
         if (cancelled()) throw new Error('Parent or profile is stopping.');
-        const id = randomUUID().slice(0, 8), directory = task.cwd ?? cwd;
+        const id = randomUUID().slice(0, 8), directory = taskDirectory(cwd, task.cwd);
         const delegation = depth < 3 ? 'You may delegate parts of your assigned task with spawn when useful. Child reports arrive automatically after your current run ends; the harness keeps you alive to receive them. Never poll, sleep, or wait in a tool for children. Finish your current work and return; you will be prompted with their results. The profile allows 8 active agents total.' : 'You are at the maximum delegation depth. Complete your task with your own tools.';
         const instructions = [this.instructions(), delegation, connected ? 'You are speaking directly with the user in a connected window. Continue this conversation across requests. Use tell_parent for questions or findings the main agent needs now. A handoff will be generated when the user completes or disconnects the window.'
           : 'Use tell_parent only when your parent needs something now (a blocking question, an important early finding, or when asked to). Your final answer is delivered automatically; do not repeat it with tell_parent.'].filter(Boolean).join('\n\n');
@@ -151,7 +159,7 @@ export class Children {
       }
     } catch (error) {
       for (const child of launched) {
-        child.session.dispose(); this.running.delete(child.info.id);
+        this.dispose(child.session); this.running.delete(child.info.id);
         child.info.state = 'failed'; child.info.ended = Date.now(); child.info.report = `Launch failed: ${String(error)}`;
         if (child.info.connected) child.info.handoff = { reason: signal?.aborted ? 'disconnected' : 'failed' };
         this.save(child.info);
@@ -171,7 +179,7 @@ export class Children {
   }
   private delegationTools(parentId: string, cwd: string) {
     return [{ name: 'spawn', label: 'Delegate task', description: 'Delegate parts of your task. Results arrive automatically after this run; never poll or sleep waiting. Maximum depth 3 and 8 active agents per profile.',
-      parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String()) }), { minItems: 1, maxItems: 8 }) }),
+      parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String({ description: CWD_DOC })) }), { minItems: 1, maxItems: 8 }) }),
       execute: async (_id: string, args: { tasks: { task: string; cwd?: string }[] }, signal?: AbortSignal) => result(`Started: ${(await this.spawn(args.tasks, cwd, signal, parentId)).join(', ')}. Results will arrive automatically.`),
     }, { name: 'tell', label: 'Guide child', description: 'Send guidance to one of your direct children.',
       parameters: Type.Object({ id: Type.String(), message: Type.String() }),
@@ -199,11 +207,14 @@ export class Children {
       },
     };
   }
+  private dispose(session: AgentSession) {
+    try { session.dispose(); } catch (error) { this.warn(`Subagent cleanup failed: ${String(error)}`); }
+  }
   private directChildren(id: string) { return [...this.running.values()].filter(c => c.info.parentId === id); }
   private async execute(live: LiveRun, view: string) {
     const { session, info } = live;
     try {
-      if (info.connected) await this.report(`[${info.id}] User started a connected conversation in ${info.cwd}. Initial request: ${info.task}\nUse tell with this agent ID to coordinate. It stays open between replies and sends a final handoff on completion or disconnect.`);
+      if (info.connected) await this.report(`[${info.id}] User started a connected conversation in ${info.cwd}. That agent is handling this request with the user directly; don't do it yourself. Initial message: ${info.task}\n\nUse tell with this agent ID only if you know something it needs. It stays open between replies and sends a final handoff on completion or disconnect.`);
       if (this.closing || info.handoff) throw new Error('Conversation stopped before its first request.');
       await session.prompt(`${view}\n\nYour task:\n${info.task}`);
       while (info.state !== 'stopping') {
@@ -240,7 +251,8 @@ export class Children {
       for (const g of info.guidance) if (g.state === 'queued') g.state = 'undelivered';
       try { await session.extensionRunner.emit({ type: 'session_shutdown', reason: 'quit' }); }
       catch (error) { this.warn(`Subagent cleanup failed: ${String(error)}`); }
-      finally { session.dispose(); this.running.delete(info.id); }
+      // A failed dispose must neither keep the slot taken nor drop the report below.
+      this.dispose(session); this.running.delete(info.id);
     }
     if (info.connected) {
       info.handoff ??= { reason: 'failed' };

package/src/connected-window.ts

@@ -1,42 +1,127 @@
-import { getMarkdownTheme, UserMessageComponent, type ExtensionAPI, type ExtensionContext } from '@earendil-works/pi-coding-agent';
-import { Markdown } from '@earendil-works/pi-tui';
-import { connectWindow, type WindowEvent } from './window-bridge.ts';
+import { getMarkdownTheme, UserMessageComponent, type ExtensionAPI, type ExtensionContext, type Theme } from '@earendil-works/pi-coding-agent';
+import { Container, Loader, Markdown, type Component, type TUI } from '@earendil-works/pi-tui';
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import { connectWindow, type LiveState, type WindowEvent } from './window-bridge.ts';
 import { profilePath } from './profiles.ts';
+import { TranscriptView } from './agent-view.ts';
+import { isReport, reportBox } from './report-message.ts';
+import { statusState, windowTitle, type WindowState } from './title.ts';
 
-type Details = { from?: WindowEvent['from'] };
+/** `turn` is one finished reply of the agent with the results of its tool calls, drawn like Pi draws its own turns. */
+type Details = { from?: WindowEvent['from']; turn?: AgentMessage[] };
+
+/**
+ * One transcript for the window, shared by the chat and the live widget, so tool calls keep their timings when they settle into the chat.
+ * Pi's built-in tools keep their own renderers. Other tools' definitions live in the owner's process, out of reach here, so they get the
+ * look Pi gives any registered tool without a renderer (`spawn tasks=[…]`) instead of the raw-JSON look of an unknown one.
+ */
+let transcript: TranscriptView | undefined;
+const transcriptOn = (tui: TUI) => new TranscriptView(tui, process.cwd(), () => ({}));
+const view = (tui: TUI) => transcript ??= transcriptOn(tui);
+/** Turns drawn before this window has a live view (after /reload) still get their tool boxes; there is just no live screen to redraw. */
+let detached: TranscriptView | undefined;
+const NO_SCREEN = { requestRender() {} } as unknown as TUI;
 
 /** The conversation itself renders like a normal chat; everything else keeps Pi's boxed custom-message look. */
 export function registerConnectedRenderer(pi: ExtensionAPI) {
-  pi.registerMessageRenderer<Details>('optchat-connected', (message, { outputPad }) => {
+  pi.registerMessageRenderer<Details>('optchat-connected', (message, { expanded, outputPad }, theme) => {
     const text = typeof message.content === 'string' ? message.content : '';
     if (message.details?.from === 'user') return new UserMessageComponent(text, getMarkdownTheme(), outputPad);
-    return message.details?.from === 'agent' ? new Markdown(text.trim(), outputPad, 0, getMarkdownTheme()) : undefined;
+    const turn = message.details?.turn;
+    if (turn) {
+      const shown = transcript ?? (detached ??= transcriptOn(NO_SCREEN));
+      shown.setExpanded(expanded);
+      const container = new Container();
+      for (const part of shown.build('', turn)) container.addChild(part);
+      return container;
+    }
+    if (message.details?.from === 'agent') return new Markdown(text.trim(), outputPad, 0, getMarkdownTheme());
+    // Reports from the agent's own subagents get the same dark box as in the main window.
+    return isReport(text) ? reportBox(text, outputPad, theme) : undefined;
   });
 }
 
-export async function openConnectedWindow(pi: ExtensionAPI, ctx: ExtensionContext, profile: string) {
-  let started = false, ended = false;
-  const display = (text: string, from?: WindowEvent['from']) => pi.sendMessage<Details>({ customType: 'optchat-connected', content: text, display: true, details: { from } }, { triggerTurn: false });
+const toolCalls = (message: AgentMessage) => message.role === 'assistant' ? message.content.flatMap(part => part.type === 'toolCall' ? [part.id] : []) : [];
+
+/** What normally sits at the bottom of Pi's chat while it works: the streaming reply, running tools and the working spinner. */
+class LiveTurn implements Component {
+  private readonly loader: Loader;
+  private readonly body = new Container();
+  private spinning = false;
+  turn: AgentMessage[] = [];
+  live?: LiveState;
+  constructor(private readonly tui: TUI, theme: Theme) {
+    this.loader = new Loader(tui, text => theme.fg('accent', text), text => theme.fg('muted', text), 'Working');
+    // Running tools show their elapsed time, which only moves when they are redrawn.
+    this.timer = setInterval(() => { if (this.live?.tools.length) this.update(); }, 1000); this.timer.unref();
+  }
+  private readonly timer: ReturnType<typeof setInterval>;
+  update() {
+    const streaming = this.live?.streaming;
+    const running = new Map((this.live?.tools ?? []).map(t => [t.id, { output: t.output, started: t.started }] as const));
+    this.body.clear();
+    for (const part of view(this.tui).build('', streaming ? [...this.turn, streaming] : this.turn, streaming, running)) this.body.addChild(part);
+    const state = this.live?.state;
+    // Waiting with no agents of its own means it is waiting for you, so nothing spins, like an idle Pi.
+    const agents = this.live?.agents ?? 0;
+    const spin = !!state && statusState(state, agents) === 'working';
+    this.loader.setMessage(state === 'waiting' ? `Waiting for ${agents === 1 ? '1 agent' : `${agents} agents`}` : state === 'stopping' ? 'Stopping' : 'Working');
+    if (spin && !this.spinning) this.loader.start(); else if (!spin && this.spinning) this.loader.stop();
+    this.spinning = spin;
+    this.tui.requestRender();
+  }
+  render(width: number) { return [...this.body.render(width), ...(this.spinning ? this.loader.render(width) : [])]; }
+  invalidate() { this.body.invalidate(); this.loader.invalidate(); }
+  dispose() { clearInterval(this.timer); this.loader.stop(); }
+}
+
+export async function openConnectedWindow(pi: ExtensionAPI, ctx: ExtensionContext, profile: string, setTitle: (title: string) => void = title => ctx.ui.setTitle(title)) {
+  // Each window draws with its own transcript, so nothing from an earlier window carries over.
+  transcript = undefined;
+  let started = false, ended = false, liveTurn: LiveTurn | undefined, live: LiveState | undefined, turn: AgentMessage[] = [];
+  const title = (state: WindowState) => setTitle(windowTitle(profile, state));
+  const display = (text: string, details: Details = {}) => pi.sendMessage<Details>({ customType: 'optchat-connected', content: text, display: true, details }, { triggerTurn: false });
+  const refresh = () => { if (liveTurn) { liveTurn.turn = turn; liveTurn.live = live; liveTurn.update(); } };
+  /** A reply moves into the chat once all its tool calls have results, as Pi's own chat does when a tool finishes. */
+  const commit = () => {
+    if (!turn.length) return;
+    const [reply] = turn;
+    display(reply.role === 'assistant' ? reply.content.flatMap(p => p.type === 'text' ? [p.text] : []).join('\n') : '', { from: 'agent', turn });
+    turn = [];
+  };
+  const settled = () => { const done = new Set(turn.flatMap(m => m.role === 'toolResult' ? [m.toolCallId] : [])); return turn.length > 0 && toolCalls(turn[0]).every(id => done.has(id)); };
+  const showLive = () => ctx.ui.setWidget('optchat-connected', (tui, theme) => { view(tui); liveTurn = new LiveTurn(tui, theme); refresh(); return liveTurn; });
+  const hideLive = () => { live = undefined; liveTurn = undefined; ctx.ui.setWidget('optchat-connected', undefined); };
   const connection = await connectWindow(profilePath(profile), event => {
     if (event.name === 'started') {
-      started = true;
+      started = true; showLive(); title('working');
       ctx.ui.setStatus('optchat', `OptChat: ${profile} · connected agent ${event.text} · /complete`);
     } else if (event.name === 'status') {
-      ctx.ui.setWidget('optchat-connected', event.text.split('\n').slice(-8));
+      live = event.live; refresh();
+      // The tab says working exactly when the spinner spins.
+      if (!ended && live) title(statusState(live.state, live.agents));
+    } else if (event.message?.role === 'assistant') {
+      commit(); turn = [event.message];
+      if (settled()) commit();
+      refresh();
+    } else if (event.message?.role === 'toolResult') {
+      if (turn.length) { turn.push(event.message); if (settled()) commit(); }
+      refresh();
     } else {
-      display(event.text, event.from);
+      commit();
+      display(event.text, { from: event.from });
       if (event.name === 'finished') {
-        ended = true; ctx.ui.setWidget('optchat-connected', undefined);
+        ended = true; hideLive(); title('done');
         ctx.ui.setStatus('optchat', `OptChat: ${profile} · conversation ended · /complete to exit`);
-      }
+      } else refresh();
     }
   }, () => {
     if (ended) return;
-    ended = true; ctx.ui.setWidget('optchat-connected', undefined);
-    ctx.ui.setStatus('optchat', `OptChat: ${profile} · disconnected`);
+    ended = true; commit(); hideLive();
+    ctx.ui.setStatus('optchat', `OptChat: ${profile} · disconnected`); title('disconnected');
     ctx.ui.notify('Connection closed. The owner saves the interrupted conversation and handoff; no local agent will run here.', 'info');
   });
-  ctx.ui.setStatus('optchat', `OptChat: ${profile} · connected window · send a task to start`);
+  ctx.ui.setStatus('optchat', `OptChat: ${profile} · connected window · send a task to start`); title('waiting');
   display(`Connected to ${profile}'s original window. Messages here go to one subagent using the profile's subagent model. /tell-main sends a message to the main agent; /complete ends this conversation and sends a handoff. Closing this window interrupts it.`);
   return {
     async submit(text: string) {

package/src/inbox.ts

@@ -23,8 +23,14 @@ export class Inbox {
     const item = { id: randomUUID(), text, date: new Date().toISOString() };
     this.items.push(item); this.save(); return item.id;
   }
-  claim(text: string) {
-    const item = this.items.find(i => !this.claimed.has(i.id) && i.text === text);
+  claim(text: string) { return this.claimWhere(i => i.text === text); }
+  /** Pi expands `/skill:name args` after the input is journaled; match the expansion back to that input. */
+  claimSkill(name: string, args = '') {
+    const command = `/skill:${name}`;
+    return this.claimWhere(i => i.text.startsWith(command) && /^(\s|$)/.test(i.text.slice(command.length)) && i.text.slice(command.length).trim() === args);
+  }
+  private claimWhere(match: (item: Arrival) => boolean) {
+    const item = this.items.find(i => !this.claimed.has(i.id) && match(i));
     if (!item) return undefined;
     this.claimed.add(item.id); return item.id;
   }

package/src/index.ts

@@ -4,17 +4,17 @@ import { join } from 'node:path';
 import { hostname } from 'node:os';
 import { createHash } from 'node:crypto';
 import type { AgentMessage, ThinkingLevel } from '@earendil-works/pi-agent-core';
-import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import { parseSkillBlock, type ExtensionAPI, type ExtensionContext, type ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 import { Memory } from './memory.ts';
 import { createCompressor } from './compactor.ts';
 import { atomicWrite, createProfile, instructions, lastProfile, listProfiles, loadConfig, lockProfile, profilePath, rememberProfile, saveConfig, ProfileBusyError, type ProfileConfig } from './profiles.ts';
 import { MASTER, VIEW_DOC } from './prompts.ts';
 import { cachePayload, record } from './cache.ts';
-import { asUser, boundedMessage, buildContext, logMessage, previousExchange, REPORT_TYPE, RUN_BOUNDARY, textContent } from './transcript.ts';
+import { asUser, boundedMessage, buildContext, logMessage, previousExchange, REPORT_TYPE, RUN_BOUNDARY, textContent, typedText } from './transcript.ts';
 import { registerReportRenderer } from './report-message.ts';
 import { memoryTools, result } from './tools.ts';
-import { Children } from './agents.ts';
+import { Children, CWD_DOC } from './agents.ts';
 import { exportBrowser } from './browser.ts';
 import { Inbox } from './inbox.ts';
 import { checkpoint } from './checkpoint.ts';
@@ -28,6 +28,7 @@ import { inspectorShortcut, mountNavigation } from './navigation.ts';
 import { serveWindows } from './window-bridge.ts';
 import { openConnectedWindow, registerConnectedRenderer } from './connected-window.ts';
 import { createHandoffSummarizer } from './handoff.ts';
+import { mainTitle, TabTitle } from './title.ts';
 
 const binding = 'optchat.profile';
 interface Active { name: string; dir: string; config: ProfileConfig; memory: Memory; inbox: Inbox; children: Children; usage: UsageLedger; unlock: () => Promise<void> }
@@ -54,6 +55,13 @@ export default function optchat(pi: ExtensionAPI) {
   let unmountNavigation: (() => void) | undefined;
   let inspectorController: AbortController | undefined;
   const shortcut = inspectorShortcut();
+  const title = new TabTitle();
+  let working = false;
+  let untitle: (() => void) | undefined;
+  const showTitle = (ctx: ExtensionContext) => {
+    const a = active;
+    if (a) title.show(text => ctx.ui.setTitle(text), mainTitle(a.name, working, a.children.ids.length));
+  };
   const reportReceipt = (text: string) => 'report:' + createHash('sha256').update(text).digest('hex');
   const errorText = (error: unknown) => error instanceof Error ? error.message : String(error);
   pi.registerFlag('optchat-profile', { description: 'OptChat profile (required for noninteractive sessions without a saved binding)', type: 'string' });
@@ -103,8 +111,10 @@ export default function optchat(pi: ExtensionAPI) {
     } finally {
       await old.memory.close(); await old.unlock(); active = undefined;
       run = []; previous = []; logged = 0; view = undefined; runStarted = false; receipts.clear(); prompt = '';
+      untitle?.(); untitle = undefined; title.clear(); working = false;
     }
   };
+  const CONNECT = 'Start a connected subagent conversation here', BACK = 'Back';
   const chooseProfile = async (ctx: ExtensionContext): Promise<string | undefined> => {
     if (!ctx.hasUI) return undefined;
     const names = listProfiles(), last = lastProfile();
@@ -146,6 +156,7 @@ export default function optchat(pi: ExtensionAPI) {
       active = { name, dir, config, memory, inbox, children, usage, unlock }; fault = undefined;
       if (ctx.mode === 'tui') unmountNavigation = mountNavigation(ctx, children, shortcut, page => { void inspect(ctx, page); });
       closeWindows = await serveWindows(dir, children, () => !stopping && !importing && !pendingImport(dir), deliverReport);
+      untitle = children.subscribe(() => showTitle(ctx)); showTitle(ctx);
       status(ctx);
       ctx.ui.notify(`OptChat · ${name} · ${memory.root.length} messages\nCompactor: ${config.compactor.provider}/${config.compactor.model} (${config.compactor.thinking})`, 'info');
       const queuedReports = [...reports];
@@ -153,6 +164,7 @@ export default function optchat(pi: ExtensionAPI) {
       setImmediate(() => { if (active?.memory === memory && !pendingImport(dir)) for (const text of queuedReports) sendReport(text); });
     } catch (error) {
       await closeWindows?.(); closeWindows = undefined;
+      untitle?.(); untitle = undefined; title.clear();
       if (active && active.memory === openingMemory) {
         unmountNavigation?.(); unmountNavigation = undefined;
         await active.children.close(); active = undefined;
@@ -164,25 +176,36 @@ export default function optchat(pi: ExtensionAPI) {
 
   pi.on('session_start', async (_event, ctx) => {
     stopping = false;
-    const saved = ctx.sessionManager.getEntries().find(e => e.type === 'custom' && e.customType === binding);
+    const entries = ctx.sessionManager.getEntries();
+    const saved = entries.findLast(e => e.type === 'custom' && e.customType === binding);
     const boundName = saved?.type === 'custom' && record(saved.data) && typeof saved.data.name === 'string' ? saved.data.name : undefined;
+    // A session with conversation in it belongs to its profile. One that is only bound (a fresh `/optchat profile` session) may still pick another.
+    const settled = boundName !== undefined && entries.some(e => e.type === 'message' || e.type === 'custom_message');
     const flag = pi.getFlag('optchat-profile');
     try {
       if (boundName && typeof flag === 'string' && flag !== boundName) throw new Error(`Session belongs to ${boundName}; cannot resume it as ${flag}.`);
-      const name = boundName ?? (typeof flag === 'string' ? flag : await chooseProfile(ctx));
-      if (!name) { status(ctx); return; }
-      try { await openProfile(name, ctx); }
-      catch (error) {
-        if (!(error instanceof ProfileBusyError) || ctx.mode !== 'tui') throw error;
-        if (!await ctx.ui.confirm('Profile open in another window', `${error.owner}\nStart a connected subagent conversation here?`)) throw error;
-        remote = await openConnectedWindow(pi, ctx, name); fault = undefined;
+      let name = boundName ?? (typeof flag === 'string' ? flag : await chooseProfile(ctx));
+      for (;;) {
+        if (!name) { status(ctx); return; }
+        try { await openProfile(name, ctx); break; }
+        catch (error) {
+          if (!(error instanceof ProfileBusyError) || ctx.mode !== 'tui') throw error;
+          // A resumed conversation already belongs to this profile, so another profile needs a new session (/optchat profile).
+          const choice = await ctx.ui.select(`${name} is open in another window\n${error.owner}`, settled ? [CONNECT] : [CONNECT, BACK]);
+          if (choice === CONNECT) { remote = await openConnectedWindow(pi, ctx, name, text => title.show(t => ctx.ui.setTitle(t), text)); fault = undefined; break; }
+          if (choice !== BACK) throw error;
+          name = await chooseProfile(ctx);
+        }
       }
-      if (!boundName) pi.appendEntry(binding, { name });
+      if (name !== boundName) pi.appendEntry(binding, { name });
     } catch (error) {
       if (active) await stop().catch(() => {});
       fault = errorText(error); ctx.ui.notify(fault, 'error');
     }
+    // Pi sets its own title once every session_start handler has finished, so put ours back afterwards.
+    for (const ms of [0, 250, 1000]) setTimeout(() => title.reapply(), ms).unref();
   });
+  pi.on('session_info_changed', () => title.reapply()); // Pi retitles the tab on session renames, just before this.
   pi.on('session_shutdown', stop);
   pi.on('session_before_switch', () => remote || importing || active?.children.active ? { cancel: true } : undefined);
   pi.on('session_before_fork', () => remote || importing || active?.children.active ? { cancel: true } : undefined);
@@ -208,7 +231,10 @@ export default function optchat(pi: ExtensionAPI) {
     pi.appendEntry(RUN_BOUNDARY, { state: 'start' });
   };
   // A report sent while Pi is idle starts its run without before_agent_start; it reuses the last built prompt.
-  pi.on('agent_start', (_event, ctx) => { if (active && !runStarted) startRun(ctx); });
+  pi.on('agent_start', (_event, ctx) => {
+    working = true; showTitle(ctx);
+    if (active && !runStarted) startRun(ctx);
+  });
   pi.on('before_agent_start', (event, ctx) => {
     startRun(ctx);
     const a = required();
@@ -226,7 +252,10 @@ export default function optchat(pi: ExtensionAPI) {
         const text = textContent(message.content);
         if (reports.includes(text)) receipts.set(message, reportReceipt(text));
         else {
-          let receipt = active.inbox.claim(text);
+          // The inbox journaled the typed input: match without image placeholders or Pi's image notes.
+          const typed = typedText(message.content), skill = parseSkillBlock(typed.bare);
+          let receipt = active.inbox.claim(typed.text) ?? active.inbox.claim(typed.bare)
+            ?? (skill ? active.inbox.claimSkill(skill.name, skill.userMessage) : undefined);
           if (!receipt) { active.inbox.record(text); receipt = active.inbox.claim(text); }
           if (receipt) receipts.set(message, receipt);
         }
@@ -274,6 +303,7 @@ export default function optchat(pi: ExtensionAPI) {
     try { flush(); } catch (error) { fault = errorText(error); ctx.ui.notify(fault, 'error'); }
     if (runStarted) pi.appendEntry(RUN_BOUNDARY, { state: 'end' });
     runStarted = false; status(ctx);
+    working = false; showTitle(ctx);
     if (active) {
       const dir = active.dir;
       checkpoints = checkpoints.then(() => checkpoint(dir)).catch(error => ctx.ui.notify(`Local checkpoint failed: ${errorText(error)}`, 'error'));
@@ -284,8 +314,8 @@ export default function optchat(pi: ExtensionAPI) {
   registerReportRenderer(pi);
   for (const tool of memoryTools(() => required().memory)) pi.registerTool(tool);
   pi.registerTool({ name: 'spawn', label: 'Spawn background agents',
-    description: 'Start background subagents, returning IDs immediately. Use only when the user asks. Each receives the current memory view and read-only zoom/date. Children may delegate two more levels; the whole profile allows 8 active agents. Completion reports arrive automatically; never poll or sleep waiting for them.',
-    parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String()) }), { minItems: 1, maxItems: 8 }) }),
+    description: 'Start background subagents, returning IDs immediately. Use only when the user asks. Give each task the cwd of the project it works on, so the subagent starts there with that project\'s AGENTS.md. Each receives the current memory view and read-only zoom/date. Children may delegate two more levels; the whole profile allows 8 active agents. Completion reports arrive automatically; never poll or sleep waiting for them.',
+    parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String({ description: CWD_DOC })) }), { minItems: 1, maxItems: 8 }) }),
     async execute(_id, args, signal, _update, ctx) {
       const ids = await required().children.spawn(args.tasks, ctx.cwd, signal); status(ctx);
       return result(`Started: ${ids.join(', ')}. Reports will arrive automatically.`);

package/src/memory.ts

@@ -12,10 +12,12 @@ export interface Part { l: number; i: number }
 export interface Summary extends Part { text: string; size: number }
 export interface Compression { context: string; source: string; merge: boolean; historical?: boolean }
 export type Compressor = (input: Compression, signal: AbortSignal) => Promise<string>;
-const key = ({ l, i }: Part) => `${l}:${i}`;
+const key = ({ l, i }: Part) => l * 2 ** 40 + i;
+const UNBUILT = '(not summarized yet: zoom it)';
 export const start = ({ l, i }: Part) => i * 2 ** l;
 export const end = (part: Part) => start(part) + 2 ** part.l;
 export const bytes = (s: string) => Buffer.byteLength(s, 'utf8');
+const UNBUILT_BYTES = bytes(UNBUILT);
 export const flat = (s: string) => s.replace(/[\r\n]+/g, ' ');
 export function cap(text: string, limit = CAP) {
   if (text.length <= limit) return text;
@@ -68,13 +70,17 @@ function isSummary(value: unknown): value is Summary {
 /** The log is authoritative. The tree and monotonically coarsening view follow recipe §§2–6. */
 export class Memory {
   readonly root: Entry[] = [];
-  readonly tree = new Map<string, Summary>();
+  readonly tree = new Map<number, Summary>();
   readonly view: Part[] = [];
   private readonly events = new EventEmitter();
   private readonly controller = new AbortController();
-  private readonly busy = new Map<string, Promise<void>>();
-  private readonly retryAt = new Map<string, number>();
-  private readonly reported = new Set<string>();
+  private readonly busy = new Map<number, Promise<void>>();
+  private readonly retryAt = new Map<number, number>();
+  private readonly reported = new Set<number>();
+  private viewBytes = 0;
+  private leaves = 0;
+  /** Per level, every node below this index is built. */
+  private readonly low: number[] = [];
   private retryTimer?: ReturnType<typeof setTimeout>;
   private scheduled = false;
   private stopped = false;
@@ -91,40 +97,53 @@ export class Memory {
     for (const value of records(join(directory, 'tree'), warn)) {
       if (!isSummary(value) || value.l < 0 || value.i < 0 || end(value) > this.root.length)
         throw new Error('Invalid OptChat summary record.');
+      if (value.l === 0 && !this.tree.has(key(value))) this.leaves++;
       this.tree.set(key(value), { ...value, size: bytes(value.text) });
     }
     // Fold history in order; do not retile the entire log on each turn.
-    for (let i = 0; i < this.root.length; i++) { this.view.push({ l: 0, i }); this.fit(i + 1); }
+    for (let i = 0; i < this.root.length; i++) { this.push(i); this.fit(i + 1); }
     this.schedule();
   }
   append(kind: Kind, text: string, date = new Date().toISOString(), receipt?: string) {
     if (this.stopped) throw new Error('Memory is closed.');
     const entry: Entry = { i: this.root.length, kind, text, date, size: bytes(`${kind}: ${text}`), ...(receipt ? { receipt } : {}) };
     appendJson(join(this.directory, 'main', `${localDay()}.jsonl`), entry);
-    this.root.push(entry); this.view.push({ l: 0, i: entry.i }); this.fit(); this.schedule();
+    this.root.push(entry); this.push(entry.i); this.fit(); this.schedule();
     return entry;
   }
   node(part: Part) { return this.tree.get(key(part)); }
-  private text(part: Part) { return this.node(part)?.text ?? '(not summarized yet: zoom it)'; }
+  private text(part: Part) { return this.node(part)?.text ?? UNBUILT; }
+  private partBytes(part: Part) { return this.node(part)?.size ?? UNBUILT_BYTES; }
+  private push(i: number) { const part = { l: 0, i }; this.view.push(part); this.viewBytes += this.partBytes(part); }
   render() { return `<chat>\n${this.view.map(p => `${start(p)}+${2 ** p.l}|${flat(this.text(p))}`).join('\n')}\n</chat>`; }
   get ready() { return this.view.every(p => this.node(p)); }
-  get pending() { return this.root.filter(e => !this.tree.has(key({ l: 0, i: e.i }))).length; }
+  get pending() { return this.root.length - this.leaves; }
   get active() { return this.busy.size; }
-  get size() { return this.view.reduce((n, p) => n + bytes(this.text(p)), 0); }
+  get size() { return this.viewBytes; }
+  /** The view tiles the log in order, so a binary search finds the part covering a position. */
+  private visible(part: Part) {
+    const at = start(part);
+    for (let lo = 0, hi = this.view.length - 1; lo <= hi;) {
+      const mid = (lo + hi) >> 1, p = this.view[mid];
+      if (end(p) <= at) lo = mid + 1;
+      else if (start(p) > at) hi = mid - 1;
+      else return p.l === part.l && p.i === part.i;
+    }
+    return false;
+  }
   private fit(total = this.root.length) {
-    let size = this.size;
-    while (size > this.budget) {
+    while (this.viewBytes > this.budget) {
       let best = -1; let due = -Infinity;
       for (let j = 0; j + 1 < this.view.length; j++) {
         const a = this.view[j], b = this.view[j + 1];
-        if (a.l !== b.l || a.i % 2 || b.i !== a.i + 1 || !this.node({ l: a.l + 1, i: a.i / 2 })) continue;
+        if (a.l !== b.l || a.i % 2 || b.i !== a.i + 1) continue;
         const age = (total - start(a)) / 2 ** (a.l + 2);
-        if (age > due) { best = j; due = age; }
+        if (age > due && this.node({ l: a.l + 1, i: a.i / 2 })) { best = j; due = age; }
       }
       if (best < 0) break;
       const a = this.view[best], b = this.view[best + 1];
       const parent = { l: a.l + 1, i: a.i / 2 };
-      size += bytes(this.text(parent)) - bytes(this.text(a)) - bytes(this.text(b));
+      this.viewBytes += this.partBytes(parent) - this.partBytes(a) - this.partBytes(b);
       this.view.splice(best, 2, parent);
     }
     this.events.emit('change');
@@ -140,11 +159,14 @@ export class Memory {
     const first = this.view.find(p => !this.node(p));
     const boundary = first ? start(first) : total;
     for (let l = 0; 2 ** l <= total; l++) {
-      for (let i = 0; (i + 1) * 2 ** l <= total; i++) {
+      let low = this.low[l] ?? 0;
+      while (this.node({ l, i: low })) low++;
+      this.low[l] = low;
+      for (let i = low; (i + 1) * 2 ** l <= total; i++) {
         if (this.busy.size >= this.jobs) return;
         const part = { l, i }, id = key(part);
+        if ((l === 0 ? i : end(part)) > boundary) break;
         if (this.node(part) || this.busy.has(id) || (this.retryAt.get(id) ?? 0) > Date.now()) continue;
-        if ((l === 0 ? i : end(part)) > boundary) continue;
         if (l && (!this.node({ l: l - 1, i: 2 * i }) || !this.node({ l: l - 1, i: 2 * i + 1 }))) continue;
         const promise = this.build(part).catch(error => {
           if (this.stopped) return;
@@ -173,6 +195,8 @@ export class Memory {
     const node = { ...part, text, size: bytes(text) };
     appendJson(join(this.directory, 'tree', `${localDay()}.jsonl`), node);
     this.tree.set(key(part), node); this.retryAt.delete(key(part));
+    // A leaf is usually still in the view when built, but after a damaged tree file a saved parent can already hide it.
+    if (part.l === 0) { this.leaves++; if (this.visible(part)) this.viewBytes += node.size - UNBUILT_BYTES; }
     if (!this.retryAt.size) this.lastError = undefined;
     this.fit();
   }

package/src/report-message.ts

@@ -21,12 +21,14 @@ function darkBackground(theme: Theme) {
 }
 
 /** Background traffic: a dark neutral box with dim text, so it never looks like something the user typed. */
+export function reportBox(text: string, outputPad: number, theme: Theme) {
+  const { label, body } = reportParts(text);
+  const box = new Box(outputPad, 1, darkBackground(theme));
+  box.addChild(new Text(theme.fg('dim', `↳ ${label}`), 0, 0));
+  box.addChild(new Markdown(body.trim(), 0, 0, getMarkdownTheme(), { color: text => theme.fg('muted', text) }));
+  return box;
+}
+export const isReport = (text: string) => HEAD.test(text);
 export function registerReportRenderer(pi: ExtensionAPI) {
-  pi.registerMessageRenderer(REPORT_TYPE, (message, { outputPad }, theme) => {
-    const { label, body } = reportParts(textContent(message.content));
-    const box = new Box(outputPad, 1, darkBackground(theme));
-    box.addChild(new Text(theme.fg('dim', `↳ ${label}`), 0, 0));
-    box.addChild(new Markdown(body.trim(), 0, 0, getMarkdownTheme(), { color: text => theme.fg('muted', text) }));
-    return box;
-  });
+  pi.registerMessageRenderer(REPORT_TYPE, (message, { outputPad }, theme) => reportBox(textContent(message.content), outputPad, theme));
 }

package/src/title.ts

@@ -0,0 +1,31 @@
+/** Terminal tab titles: `● π personal · 2 agents` in the main window, `● ↳ personal` in a connected window. */
+export type StatusState = 'waiting' | 'working';
+export type WindowState = StatusState | 'done' | 'disconnected';
+
+const agents = (count: number) => count > 0 ? ` · ${count} ${count === 1 ? 'agent' : 'agents'}` : '';
+export const mainTitle = (profile: string, working: boolean, running: number) => `${working ? '● ' : ''}π ${profile}${agents(running)}`;
+export const windowTitle = (profile: string, state: WindowState) =>
+  `${state === 'working' ? '● ' : ''}↳ ${profile}${state === 'done' || state === 'disconnected' ? ` · ${state}` : ''}`;
+/** A connected window's agent is working while it runs or stops, or waits on agents of its own; waiting with none means waiting for you. */
+export const statusState = (state: string, agents = 0): StatusState =>
+  state === 'running' || state === 'stopping' || state === 'waiting' && agents > 0 ? 'working' : 'waiting';
+
+/**
+ * Pi writes its own "π - <cwd>" title after binding a session (startup, reload, profile switch) and on
+ * session renames, so the last title is kept and re-applied at those points.
+ */
+export class TabTitle {
+  private title: string | undefined;
+  private set: ((title: string) => void) | undefined;
+  show(set: (title: string) => void, title: string) {
+    this.set = set;
+    if (title === this.title) return;
+    this.title = title; this.apply();
+  }
+  reapply() { this.apply(); }
+  clear() { this.title = undefined; this.set = undefined; }
+  private apply() {
+    if (!this.title || !this.set) return;
+    try { this.set(this.title); } catch { /* A ctx captured before a session replacement is stale; the next session sets its own. */ }
+  }
+}

package/src/transcript.ts

@@ -8,16 +8,22 @@ export const RUN_BOUNDARY = 'optchat.run';
 /** Subagent traffic to the main agent: a custom message on screen, a plain user message to the model and memory. */
 export const REPORT_TYPE = 'optchat-report';
 
-export function textContent(content: unknown): string {
+export function textContent(content: unknown, images = true): string {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';
   return content.map((part: unknown) => {
     if (typeof part !== 'object' || part === null) return '';
     if ('type' in part && part.type === 'text' && 'text' in part && typeof part.text === 'string') return part.text;
-    if ('type' in part && part.type === 'image') return '[image attachment: available in Pi session; text memory does not preserve image bytes]';
+    if (images && 'type' in part && part.type === 'image') return '[image attachment: available in Pi session; text memory does not preserve image bytes]';
     return '';
   }).filter(Boolean).join('\n');
 }
+/** What the user typed, as Pi's input event (and so the inbox) saw it: no image placeholders, and without the
+ * `[Image …]` notes Pi appends after the text when it resizes, converts or omits an attached image. */
+export function typedText(content: unknown) {
+  const text = textContent(content, false);
+  return { text, bare: text.replace(/\n\n\[Image[ :][^\n]*\](?:\n\[Image[ :][^\n]*\])*$/, '') };
+}
 /** Reports reach the model, memory and the previous-exchange replay exactly as the user messages they used to be. */
 export function asUser(message: AgentMessage): AgentMessage {
   if (message.role !== 'custom' || message.customType !== REPORT_TYPE) return message;

package/src/window-bridge.ts

@@ -5,19 +5,36 @@ import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { record } from './cache.ts';
 import { profileSocket } from './profiles.ts';
 import { textContent } from './transcript.ts';
+import { isActiveRun } from './runs.ts';
 
 type Action = 'start' | 'say' | 'tell-main' | 'complete';
 interface Request { kind: 'request'; id: number; action: Action; text?: string; cwd?: string }
 interface Reply { kind: 'reply'; id: number; error?: string }
-/** `from` marks the conversation itself (your messages and the agent's replies); other messages have no `from`. */
-export interface WindowEvent { kind: 'event'; name: 'started' | 'message' | 'status' | 'finished'; text: string; from?: 'user' | 'agent' }
+/** A tool the subagent is running right now, with its streamed output so far. */
+export interface LiveTool { id: string; name: string; args: unknown; output?: unknown; started: number }
+/** What the subagent is doing between finished messages: its streaming reply and running tools. */
+export interface LiveState { state: string; model: string; streaming?: AgentMessage; tools: LiveTool[]; agents?: number }
+/**
+ * `from` marks the conversation itself (your messages and the agent's replies); other messages have no `from`.
+ * `message` carries the agent's own messages (replies with tool calls, tool results) so the window can draw them with Pi's components.
+ */
+export interface WindowEvent {
+  kind: 'event'; name: 'started' | 'message' | 'status' | 'finished'; text: string; from?: 'user' | 'agent';
+  message?: AgentMessage; live?: LiveState;
+}
 type Frame = Request | Reply | WindowEvent;
 const errorText = (error: unknown) => error instanceof Error ? error.message : String(error);
+const isMessage = (value: unknown): value is AgentMessage => record(value) && (value.role === 'assistant' || value.role === 'toolResult') && Array.isArray(value.content);
+const isLive = (value: unknown): value is LiveState => record(value) && typeof value.state === 'string' && typeof value.model === 'string'
+  && (value.streaming === undefined || isMessage(value.streaming))
+  && Array.isArray(value.tools) && value.tools.every(t => record(t) && typeof t.id === 'string' && typeof t.name === 'string' && typeof t.started === 'number')
+  && (value.agents === undefined || typeof value.agents === 'number');
 function parse(value: unknown): Frame {
   if (!record(value)) throw new Error('Invalid window message');
   const name = value.name, action = value.action, from = value.from;
   if (value.kind === 'event' && (name === 'started' || name === 'message' || name === 'status' || name === 'finished') && typeof value.text === 'string')
-    return { kind: 'event', name, text: value.text, from: from === 'user' || from === 'agent' ? from : undefined };
+    return { kind: 'event', name, text: value.text, from: from === 'user' || from === 'agent' ? from : undefined,
+      message: isMessage(value.message) ? value.message : undefined, live: isLive(value.live) ? value.live : undefined };
   if (typeof value.id !== 'number' || !Number.isSafeInteger(value.id)) throw new Error('Invalid request ID');
   if (value.kind === 'reply' && (value.error === undefined || typeof value.error === 'string')) return { kind: 'reply', id: value.id, error: value.error };
   if (value.kind === 'request' && (action === 'start' || action === 'say' || action === 'tell-main' || action === 'complete')
@@ -25,6 +42,23 @@ function parse(value: unknown): Frame {
     return { kind: 'request', id: value.id, action, text: value.text, cwd: value.cwd };
   throw new Error('Invalid window message');
 }
+const SHORTENED = '\n[Display shortened; full text is saved in the transcript.]';
+const shorten = (text: string, limit: number) => text.length > limit ? `${text.slice(0, limit)}${SHORTENED}` : text;
+/** Long text parts are cut and images dropped: the window only draws them, the owner keeps the full transcript. */
+function clipContent(content: unknown): unknown {
+  if (!Array.isArray(content)) return content;
+  return content.map(part => !record(part) ? part : part.type === 'text' && typeof part.text === 'string' ? { ...part, text: shorten(part.text, 50_000) }
+    : part.type === 'image' ? { type: 'text', text: '[image]' } : part);
+}
+const clip = (message: AgentMessage) => ({ ...message, content: clipContent('content' in message ? message.content : []) }) as AgentMessage;
+const clipOutput = (output: unknown) => record(output) ? { ...output, content: clipContent(output.content) } : output;
+/**
+ * Huge tool arguments (a large file write) would choke the socket; the window then falls back to text.
+ * Partial tool output comes from any extension and may not serialize (a cycle, a BigInt); that falls back too
+ * instead of throwing inside the status timer, which would take the owner's Pi down with it.
+ */
+const fits = (value: unknown) => { try { return JSON.stringify(value).length < 1_000_000; } catch { return false; } };
+
 /** Local JSONL protocol, bounded before parsing; the socket is accessible only by its OS user. */
 function wire(socket: Socket, receive: (frame: Frame) => void) {
   let buffer = '';
@@ -94,13 +128,15 @@ export async function serveWindows(directory: string, children: Children, availa
       track(queue);
     });
     const drainMessages = (messages: AgentMessage[], task: string) => {
-      const displayable = messages.filter(message => message.role === 'user' || message.role === 'assistant');
+      const displayable = messages.filter(message => message.role === 'user' || message.role === 'assistant' || message.role === 'toolResult');
       while (cursor < displayable.length) {
         const message = displayable[cursor++];
-        let text = textContent(message.content);
+        let text = message.role === 'toolResult' ? '' : textContent(message.content);
         if (message.role === 'user' && firstUser) { text = task; firstUser = false; said.add(task.trim()); }
-        const from = message.role === 'assistant' ? 'agent' : said.has(text.trim()) ? 'user' : undefined;
-        if (text) send({ kind: 'event', name: 'message', from, text: `${text.slice(0, 200_000)}${text.length > 200_000 ? '\n[Display shortened; full text is saved in the transcript.]' : ''}` });
+        if (message.role === 'user') { if (text) send({ kind: 'event', name: 'message', from: said.has(text.trim()) ? 'user' : undefined, text: shorten(text, 200_000) }); continue; }
+        const clipped = clip(message);
+        if (fits(clipped)) send({ kind: 'event', name: 'message', from: message.role === 'assistant' ? 'agent' : undefined, text: shorten(text, 200_000), message: clipped });
+        else if (text) send({ kind: 'event', name: 'message', from: 'agent', text: shorten(text, 200_000) });
       }
     };
     const timer = setInterval(() => {
@@ -109,8 +145,14 @@ export async function serveWindows(directory: string, children: Children, availa
       if (!info) return;
       if (live) drainMessages(live.session.messages, info.task);
       const preview = live?.streaming && 'content' in live.streaming ? textContent(live.streaming.content).slice(-2000) : '';
-      const status = `${info.state === 'waiting' ? 'Awaiting user or child reports' : info.state} · ${info.model}\n${live ? [...live.tools.values()].map(t => t.name).join(', ') : ''}\n${preview}`;
-      if (status !== lastStatus) { lastStatus = status; send({ kind: 'event', name: 'status', text: status }); }
+      const text = `${info.state === 'waiting' ? 'Awaiting user or child reports' : info.state} · ${info.model}\n${live ? [...live.tools.values()].map(t => t.name).join(', ') : ''}\n${preview}`;
+      let state: LiveState = { state: info.state, model: info.model,
+        streaming: live?.streaming?.role === 'assistant' ? clip(live.streaming) : undefined,
+        tools: live ? [...live.tools].map(([id, t]) => ({ id, name: t.name, args: t.args, output: clipOutput(t.output), started: t.started })) : [],
+        agents: [...children.history.records.values()].filter(run => run.parentId === child && isActiveRun(run)).length };
+      if (!fits(state)) state = { ...state, streaming: undefined, tools: state.tools.map(t => ({ ...t, args: {}, output: undefined })) };
+      const status = JSON.stringify(state);
+      if (status !== lastStatus) { lastStatus = status; send({ kind: 'event', name: 'status', text, live: state }); }
       if (!live && info.handoff?.delivered) {
         try { drainMessages(children.messages(child), info.task); }
         catch (error) { send({ kind: 'event', name: 'message', text: `Could not read the final transcript: ${errorText(error)}` }); }