pi-optchat 0.6.2 → 0.6.4

package/README.md

@@ -69,6 +69,7 @@ Ask in plain words, for example: "Spawn an agent to investigate this repository
 
 - Children get the profile's memory view (frozen at launch), its instructions, read-only `zoom`/`date`, and normal coding tools plus your installed extensions.
 - Each child reports back on its own when it finishes. The parent stays alive to receive reports; it never polls.
+- In the main chat, subagent messages and reports appear in a dark grey box labelled `↳ subagent <id> · still running` or `· report`, so they don't look like something you typed. The model still receives them as ordinary user messages. (One exception: reports recovered at startup, before your first message in the session, still show as plain user messages.)
 - The parent can send a running child guidance with `tell`, and the child can message its parent mid-run with `tell_parent` (a question, an early finding). It reaches the parent like a report, marked "still running": between tool calls if the parent is busy, or waking it if it's waiting.
 - Delegation goes up to three levels below the main agent (child, grandchild, great-grandchild).
 - At most 8 agents can be active per profile, including parents waiting on descendants. Going over a limit returns an error; there is no queue.
@@ -139,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.
@@ -173,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.2",
+  "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

@@ -11,7 +11,8 @@ 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 { boundedMessage, buildContext, logMessage, previousExchange, RUN_BOUNDARY, textContent } from './transcript.ts';
+import { asUser, boundedMessage, buildContext, logMessage, previousExchange, REPORT_TYPE, RUN_BOUNDARY, textContent } from './transcript.ts';
+import { registerReportRenderer } from './report-message.ts';
 import { memoryTools, result } from './tools.ts';
 import { Children } from './agents.ts';
 import { exportBrowser } from './browser.ts';
@@ -27,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> }
@@ -53,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' });
@@ -76,10 +85,16 @@ export default function optchat(pi: ExtensionAPI) {
       }
     }
   };
+  // Shown as a dark background box, not as the user's own message. Before this profile has run once there is no
+  // built system prompt to reuse, so that rare case still goes through Pi's normal prompt path as a user message.
+  const sendReport = (text: string) => {
+    if (prompt) pi.sendMessage({ customType: REPORT_TYPE, content: text, display: true }, { triggerTurn: true, deliverAs: 'steer' });
+    else pi.sendUserMessage(text, { deliverAs: 'steer', expandPromptTemplates: false });
+  };
   const deliverReport = async (text: string, once = false) => {
     if (once && (active?.memory.root.some(e => e.receipt === reportReceipt(text)) || reports.includes(text))) return;
     reports.push(text); saveReports();
-    if (!stopping) pi.sendUserMessage(text, { deliverAs: 'steer', expandPromptTemplates: false });
+    if (!stopping) sendReport(text);
   };
   const stop = async () => {
     remote?.close(); remote = undefined;
@@ -95,7 +110,8 @@ export default function optchat(pi: ExtensionAPI) {
       await checkpoint(old.dir);
     } finally {
       await old.memory.close(); await old.unlock(); active = undefined;
-      run = []; previous = []; logged = 0; view = undefined; runStarted = false; receipts.clear();
+      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> => {
@@ -139,13 +155,15 @@ 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];
       if (!pendingImport(dir)) recovery = children.recoverHandoffs().catch(error => ctx.ui.notify(`Handoff recovery: ${errorText(error)}`, 'error'));
-      setImmediate(() => { if (active?.memory === memory && !pendingImport(dir)) for (const text of queuedReports) pi.sendUserMessage(text, { deliverAs: 'steer', expandPromptTemplates: false }); });
+      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;
@@ -168,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);
@@ -195,10 +216,18 @@ export default function optchat(pi: ExtensionAPI) {
     }
     return { action: 'continue' };
   });
-  pi.on('before_agent_start', (event, ctx) => {
+  const startRun = (ctx: ExtensionContext) => {
     flush(); run = []; logged = 0; view = undefined; runStarted = true;
     previous = previousExchange(ctx.sessionManager.getBranch());
     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) => {
+    working = true; showTitle(ctx);
+    if (active && !runStarted) startRun(ctx);
+  });
+  pi.on('before_agent_start', (event, ctx) => {
+    startRun(ctx);
     const a = required();
     // Pi's own prompt sections (AGENTS.md files, skills, cwd) stay; the profile's instructions go last.
     event.systemPromptOptions.customPrompt = `${MASTER}\n\n${VIEW_DOC}\n\nFor conversational continuity, the memory view may be followed by the immediately preceding completed exchange (its user requests and final answer, in full text), then the new input. Use that exact wording to understand follow-ups; older exchanges and previous tool output remain accessible through memory and zoom.`;
@@ -207,7 +236,8 @@ export default function optchat(pi: ExtensionAPI) {
   });
   pi.on('message_end', (event, ctx) => {
     if (!active || !runStarted) return;
-    const message = boundedMessage(event.message);
+    const bounded = boundedMessage(event.message);
+    const message = asUser(bounded);
     if (message.role === 'user') {
       try {
         const text = textContent(message.content);
@@ -223,7 +253,7 @@ export default function optchat(pi: ExtensionAPI) {
     if (view !== undefined) {
       try { flush(); } catch (error) { ctx.abort(); fault = errorText(error); ctx.ui.notify(fault, 'error'); }
     }
-    if (message !== event.message) return { message };
+    if (bounded !== event.message) return { message: bounded };
   });
   pi.on('context_with_system', async (event, ctx) => {
     try {
@@ -261,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'));
@@ -268,6 +299,7 @@ export default function optchat(pi: ExtensionAPI) {
     }
   });
   registerConnectedRenderer(pi);
+  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.',

package/src/report-message.ts

@@ -0,0 +1,34 @@
+import { getMarkdownTheme, type ExtensionAPI, type Theme } from '@earendil-works/pi-coding-agent';
+import { Box, Markdown, Text } from '@earendil-works/pi-tui';
+import { REPORT_TYPE, textContent } from './transcript.ts';
+
+const HEAD = /^\[([0-9a-f]{8})\] (?:(Message from subagent \(still running\)|Connected agent message): )?/;
+
+/** Split "[id] Message from subagent (still running): body" into a short label and the body. */
+export function reportParts(text: string) {
+  const match = HEAD.exec(text);
+  if (!match) return { label: 'subagent', body: text };
+  const kind = match[2] === undefined ? 'report' : match[2].startsWith('Message') ? 'still running' : 'connected window';
+  return { label: `subagent ${match[1]} · ${kind}`, body: text.slice(match[0].length) };
+}
+
+/** The theme's neutral grey, darkened on dark themes so the box recedes behind the conversation. */
+function darkBackground(theme: Theme) {
+  const rgb = /^\x1b\[48;2;(\d+);(\d+);(\d+)m$/.exec(theme.getBgAnsi('toolPendingBg'))?.slice(1).map(Number);
+  if (!rgb || rgb[0] + rgb[1] + rgb[2] > 3 * 128) return (text: string) => theme.bg('toolPendingBg', text);
+  const open = `\x1b[48;2;${rgb.map(c => Math.round(c * 0.7)).join(';')}m`;
+  return (text: string) => `${open}${text}\x1b[49m`;
+}
+
+/** 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) => 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

@@ -5,6 +5,8 @@ import { cap, type Memory } from './memory.ts';
 import { record } from './cache.ts';
 
 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 {
   if (typeof content === 'string') return content;
@@ -16,6 +18,11 @@ export function textContent(content: unknown): string {
     return '';
   }).filter(Boolean).join('\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;
+  return { role: 'user', content: textContent(message.content), timestamp: message.timestamp };
+}
 export function logMessage(memory: Memory, message: AgentMessage, receipt?: string) {
   const date = new Date(message.timestamp).toISOString();
   if (message.role === 'user') memory.append('user', textContent(message.content), date, receipt);
@@ -54,7 +61,7 @@ function completedExchange(history: readonly AgentMessage[]) {
 export function previousExchange(branch: readonly SessionEntry[]) {
   let end = -1;
   let legacyEnd = branch.length;
-  const messages = (entries: readonly SessionEntry[]) => entries.flatMap(entry => entry.type === 'message' ? [entry.message] : []);
+  const messages = (entries: readonly SessionEntry[]) => entries.flatMap(entry => entry.type === 'message' ? [asUser(entry.message)] : entry.type === 'custom_message' && entry.customType === REPORT_TYPE ? [asUser({ role: 'custom', customType: entry.customType, content: entry.content, display: entry.display, timestamp: Date.parse(entry.timestamp) })] : []);
   for (let i = branch.length - 1; i >= 0; i--) {
     const entry = branch[i];
     if (entry.type !== 'custom' || entry.customType !== RUN_BOUNDARY || !record(entry.data)) continue;

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