pi-optchat 0.6.3 → 0.6.4

package/README.md

@@ -140,6 +140,7 @@ See OpenAI's guides on [exporting ChatGPT data](https://help.openai.com/en/artic
 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.
 
 - 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,6 +175,7 @@ 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.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-optchat",
-  "version": "0.6.3",
+  "version": "0.6.4",
   "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

@@ -203,7 +203,7 @@ export class Children {
   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') {

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/index.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,6 +111,7 @@ 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 chooseProfile = async (ctx: ExtensionContext): Promise<string | undefined> => {
@@ -146,6 +155,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 +163,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;
@@ -175,14 +186,17 @@ export default function optchat(pi: ExtensionAPI) {
       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;
+        remote = await openConnectedWindow(pi, ctx, name, text => title.show(t => ctx.ui.setTitle(t), text)); fault = undefined;
       }
       if (!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 +222,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();
@@ -274,6 +291,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'));

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/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)}` }); }