pi-optchat 0.6.0 → 0.6.1

package/README.md

@@ -89,15 +89,16 @@ An **Agents | Usage** bar sits below the input.
 
 Set a different shortcut with `OPTCHAT_INSPECT_KEY=ctrl+shift+a pi`. If another extension supplies a custom editor, OptChat leaves its Down key alone; use the shortcut or commands instead.
 
-**Agents** lists runs as a tree with state, elapsed time, current tool, and last activity. Navigate with **Up/Down**, **Page Up/Down**, **Home/End**, open with **Enter**, and press **M** to pick the subagent model. Inside a transcript:
+**Agents** lists runs as a tree with state, elapsed time, current tool, and last activity. Navigate with **Up/Down**, **Page Up/Down**, **Home/End**, and press **M** to pick the subagent model.
+
+**Enter** swaps the screen to that agent's conversation, drawn with Pi's own chat components, so it reads like the main chat: its task, replies, and collapsed tool calls, following live output. Typing and **Enter** send it guidance. Guidance from the main agent and reports from the agent's own agents show in labelled boxes, so only your own messages look typed. **Escape** goes back to the main chat.
 
 | Key | Action |
 | --- | --- |
-| **T** | Expand tool arguments and results |
-| **F** | Follow live output (scrolling pauses it) |
-| **S** | Send guidance |
-| **X** | Stop this agent and its subtree |
-| **Escape** | Back |
+| **Escape** or **Ctrl+C** | Clear a draft, else back to the main chat |
+| **Ctrl+X** twice | Stop this agent and the agents it started |
+| **Page Up/Down**, mouse wheel | Scroll; back at the bottom it follows again. The wheel needs Pi's default fullscreen mode |
+| **Ctrl+O** | Expand tool output (Pi's own toggle) |
 
 Guidance shows as queued until delivered, or undelivered if the child stops first. Guidance you send is also saved in main memory. Reasoning is not shown. Transcripts stay browsable after restart, and browsing them makes no model calls.
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-optchat",
-  "version": "0.6.0",
+  "version": "0.6.1",
   "type": "module",
   "pi": {
     "extensions": [
@@ -52,7 +52,7 @@
   },
   "files": [
     "src",
-    "docs",
+    "docs/*.md",
     "README.md",
     "LICENSE",
     "THIRD_PARTY_NOTICES.md"

package/src/agent-view.ts

@@ -0,0 +1,305 @@
+import {
+  AssistantMessageComponent, CustomMessageComponent, ToolExecutionComponent, UserMessageComponent, getMarkdownTheme, getSelectListTheme,
+  createBashToolDefinition, createEditToolDefinition, createFindToolDefinition, createGrepToolDefinition, createLsToolDefinition, createReadToolDefinition, createWriteToolDefinition,
+  type ExtensionContext,
+} from '@earendil-works/pi-coding-agent';
+import { Editor, Spacer, matchesKey, truncateToWidth, visibleWidth, type Component, type Focusable, type TUI, type TuiMouseEvent, type TuiMouseEventResult } from '@earendil-works/pi-tui';
+import type { AgentMessage } from '@earendil-works/pi-agent-core';
+import type { Children } from './agents.ts';
+import type { RunInfo } from './runs.ts';
+import { textContent } from './transcript.ts';
+import { record } from './cache.ts';
+import { elapsed, fit, oneLine } from './inspector.ts';
+
+export type ViewTone = 'accent' | 'muted' | 'dim' | 'error' | 'warning' | 'success' | 'borderMuted';
+type ToolResult = Parameters<ToolExecutionComponent['updateResult']>[0];
+type Renderers = ConstructorParameters<typeof ToolExecutionComponent>[4];
+type Guidance = RunInfo['guidance'];
+type Running = Map<string, { output?: unknown; started: number }>;
+
+/** Pi's own renderers for its built-in tools, so saved runs draw like the main chat. */
+const builtIns: Record<string, (cwd: string) => Renderers> = {
+  bash: createBashToolDefinition, read: createReadToolDefinition, edit: createEditToolDefinition, write: createWriteToolDefinition,
+  grep: createGrepToolDefinition, find: createFindToolDefinition, ls: createLsToolDefinition,
+};
+
+/** Reports from the child's own agents start with their id, e.g. "[1a2b3c4d] ...". */
+const REPORT = /^\[[0-9a-f]{8}\] /;
+/** Connected windows prefix the main agent's guidance with this line. */
+const MAIN_PREFIX = '[Main agent guidance]\n';
+
+/** Who a user-role message in the child's conversation came from. Runs saved before senders were recorded count as the user's. */
+export function senderOf(text: string, guidance: Guidance = []): 'user' | 'manager' | 'report' {
+  if (REPORT.test(text)) return 'report';
+  if (text.startsWith(MAIN_PREFIX)) return 'manager';
+  return guidance.findLast(g => g.text === text)?.from === 'manager' ? 'manager' : 'user';
+}
+
+/** Background traffic gets Pi's labelled box, as extension messages do in the main chat; only the user's own words look typed. */
+const boxed = (label: string, text: string, timestamp: number) =>
+  new CustomMessageComponent({ role: 'custom', customType: label, content: text, display: true, timestamp }, undefined, getMarkdownTheme());
+
+function toolResult(value: unknown, isError = false): ToolResult | undefined {
+  if (!record(value) || !Array.isArray(value.content)) return undefined;
+  const content = value.content.flatMap((part: unknown) => record(part) && typeof part.type === 'string'
+    ? [{ type: part.type, ...(typeof part.text === 'string' ? { text: part.text } : {}), ...(typeof part.data === 'string' ? { data: part.data } : {}), ...(typeof part.mimeType === 'string' ? { mimeType: part.mimeType } : {}) }] : []);
+  return { content, details: value.details, isError };
+}
+
+/**
+ * Builds the child's conversation from Pi's chat components and keeps them between frames,
+ * so streaming text and running tools update in place like in the main chat.
+ */
+export class TranscriptView {
+  private readonly messages = new WeakMap<AgentMessage, Component>();
+  private readonly tools = new Map<string, ToolExecutionComponent>();
+  private readonly settled = new Set<string>();
+  private readonly partials = new Map<string, unknown>();
+  private readonly starts = new Map<string, number>();
+  private readonly ends = new Map<string, number>();
+  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); }
+  private tool(id: string, name: string, args: unknown) {
+    let tool = this.tools.get(id);
+    if (!tool) {
+      tool = new ToolExecutionComponent(name, id, args, { showImages: false }, this.renderers(id, name), this.tui, this.cwd);
+      tool.setExpanded(this.expanded); this.tools.set(id, tool);
+    }
+    return tool;
+  }
+  /**
+   * Pi's shell renderer times a command from the moment it is first drawn, so opening the view would restart the clock.
+   * Hand it the real start and end instead; unknown starts (runs finished before the view saw them) show no time.
+   */
+  private renderers(id: string, name: string): Renderers {
+    const base = builtIns[name]?.(this.cwd);
+    if (!base) return this.definition(name);
+    const { renderCall, renderResult } = base;
+    const stamp = (state: unknown) => {
+      if (!record(state)) return;
+      const started = this.starts.get(id), ended = this.ends.get(id);
+      if (started !== undefined) state.startedAt = started;
+      if (ended !== undefined) state.endedAt = ended;
+      // The view redraws every second itself; the renderer's own timer would keep redrawing Pi after the view closes.
+      state.interval ??= 'view';
+    };
+    return {
+      ...base,
+      ...(renderCall ? { renderCall: (args, theme, context) => { stamp(context.state); return renderCall.call(base, args, theme, context); } } : {}),
+      ...(renderResult ? { renderResult: (result, options, theme, context) => { stamp(context.state); return renderResult.call(base, result, options, theme, context); } } : {}),
+    };
+  }
+  /** `task` replaces the first prompt, which also carries the memory view the child got as context. */
+  build(task: string, messages: AgentMessage[], streaming?: AgentMessage, running?: Running, guidance?: Guidance): Component[] {
+    const parts: Component[] = [];
+    let first = true;
+    for (const message of messages) {
+      if (message.role === 'user') {
+        const opening = first; first = false;
+        const text = opening ? task : textContent(message.content).trim();
+        if (!text) continue;
+        let component = this.messages.get(message);
+        if (!component) {
+          const sender = opening ? 'user' : senderOf(text, guidance);
+          component = sender === 'manager' ? boxed('main agent', text.startsWith(MAIN_PREFIX) ? text.slice(MAIN_PREFIX.length) : text, message.timestamp)
+            : sender === 'report' ? boxed('agent report', text, message.timestamp)
+            : new UserMessageComponent(text, getMarkdownTheme());
+          this.messages.set(message, component);
+        }
+        if (parts.length && component instanceof UserMessageComponent) parts.push(new Spacer(1)); // Boxes bring their own.
+        parts.push(component);
+      } else if (message.role === 'assistant') {
+        const live = message === streaming;
+        let component: Component | undefined;
+        if (live) { this.streaming ??= new AssistantMessageComponent(undefined, true, getMarkdownTheme()); this.streaming.updateContent(message, true); component = this.streaming; }
+        else {
+          component = this.messages.get(message);
+          if (!component) { component = new AssistantMessageComponent(message, true, getMarkdownTheme()); this.messages.set(message, component); }
+        }
+        parts.push(component);
+        for (const part of message.content) {
+          if (part.type !== 'toolCall') continue;
+          const tool = this.tool(part.id, part.name, part.arguments);
+          if (live) { if (this.partials.get(`args:${part.id}`) !== part.arguments) { tool.updateArgs(part.arguments); this.partials.set(`args:${part.id}`, part.arguments); } }
+          else if (!this.settled.has(`args:${part.id}`)) {
+            tool.updateArgs(part.arguments); tool.setArgsComplete(); this.settled.add(`args:${part.id}`);
+            if ((message.stopReason === 'aborted' || message.stopReason === 'error') && !this.settled.has(part.id)) {
+              tool.updateResult({ content: [{ type: 'text', text: message.errorMessage || (message.stopReason === 'aborted' ? 'Operation aborted' : 'Error') }], isError: true });
+              this.settled.add(part.id);
+            }
+          }
+          parts.push(tool);
+        }
+      } else if (message.role === 'toolResult' && !this.settled.has(message.toolCallId)) {
+        const result = toolResult(message, message.isError);
+        const tool = this.tools.get(message.toolCallId);
+        if (result && tool) { this.ends.set(message.toolCallId, message.timestamp); tool.updateResult(result); this.settled.add(message.toolCallId); }
+      }
+    }
+    if (!streaming) this.streaming = undefined;
+    // Each call below redraws, so only pass on what changed since the last frame.
+    for (const [id, run] of running ?? []) {
+      const tool = this.tools.get(id);
+      if (!tool || this.settled.has(id)) continue;
+      if (!this.settled.has(`started:${id}`)) { this.starts.set(id, run.started); tool.markExecutionStarted(); this.settled.add(`started:${id}`); }
+      const partial = run.output !== this.partials.get(id) ? toolResult(run.output) : undefined;
+      if (partial) { tool.updateResult(partial, true); this.partials.set(id, run.output); }
+      else tool.invalidate(); // Ticks the running time.
+    }
+    return parts;
+  }
+}
+
+export interface AgentViewOptions {
+  id: string; children: Children; tui: TUI;
+  rows: () => number; redraw: () => void; done: () => void;
+  color: (tone: ViewTone, text: string) => string;
+  /** Pi's tool-output toggle (Ctrl+O by default), so tool calls expand the same way as in the main chat. */
+  isExpandKey?: (data: string) => boolean;
+  signal?: AbortSignal;
+}
+
+const statusOf = (run: RunInfo, children: Children) => {
+  const live = children.live(run.id);
+  if (!live) return run.state;
+  if (run.state === 'stopping') return 'stopping';
+  if (run.state === 'waiting') return 'waiting for its agents';
+  const tools = [...live.tools.values()].map(t => t.name);
+  return tools.length ? `running ${tools.join(', ')}` : live.streaming ? 'writing' : 'working';
+};
+
+/**
+ * The subagent's conversation in place of the main one: same message components, one header line,
+ * an input that guides the agent, and Esc back to the main chat. A UI projection only.
+ */
+export class AgentView implements Component, Focusable {
+  private readonly editor: Editor;
+  private readonly transcript: TranscriptView;
+  private back = 0; // Lines scrolled up from the newest; 0 follows live output.
+  private bodyHeight = 1;
+  private overflow = 0;
+  private drawn = { lines: 0, width: 0 }; // Last frame, so new output doesn't move what you're reading while scrolled up.
+  private saved?: AgentMessage[];
+  private wasLive = false;
+  private confirmStop = false;
+  private notice = '';
+  private ended = false;
+  private hasFocus = true;
+  private readonly unsubscribe: () => void;
+  private readonly timer: ReturnType<typeof setInterval>;
+  constructor(private readonly options: AgentViewOptions) {
+    const { children, id, tui, color } = options;
+    const run = children.history.records.get(id);
+    this.transcript = new TranscriptView(tui, run?.cwd ?? process.cwd(), name => children.live(id)?.session.getToolDefinition(name));
+    this.editor = new Editor(tui, { borderColor: text => color('borderMuted', text), selectList: getSelectListTheme() });
+    this.editor.onSubmit = text => this.send(text);
+    this.editor.focused = true;
+    this.unsubscribe = children.subscribe(() => options.redraw());
+    this.timer = setInterval(() => options.redraw(), 1000); this.timer.unref();
+    options.signal?.addEventListener('abort', this.close, { once: true });
+    if (options.signal?.aborted) queueMicrotask(this.close);
+  }
+  get focused() { return this.hasFocus; }
+  set focused(value: boolean) { this.hasFocus = value; this.editor.focused = value; }
+  private readonly close = () => { if (!this.ended) { this.dispose(); this.options.done(); } };
+  dispose() { this.ended = true; clearInterval(this.timer); this.unsubscribe(); this.options.signal?.removeEventListener('abort', this.close); }
+  invalidate() { this.editor.invalidate(); }
+  private get canMessage() { return ['running', 'waiting'].includes(this.options.children.live(this.options.id)?.info.state ?? ''); }
+  private scroll(lines: number) { this.back = Math.max(0, Math.min(this.overflow, this.back + lines)); }
+  /** Wheel scrolling, in Pi's default fullscreen mode; in "regular" mode the terminal keeps the wheel. */
+  handleMouse(event: TuiMouseEvent): TuiMouseEventResult | undefined {
+    if (this.ended || event.type !== 'wheel' || !event.wheelDelta) return undefined;
+    this.scroll(-event.wheelDelta);
+    return { handled: true };
+  }
+  private send(text: string) {
+    const message = text.trim(), { children, id } = this.options;
+    if (!message) return;
+    children.tell(id, message, 'user').then(() => { this.notice = ''; }, (error: unknown) => {
+      this.editor.setText(text); this.notice = `Not sent: ${error instanceof Error ? error.message : String(error)}`;
+    }).finally(() => { if (!this.ended) this.options.redraw(); });
+  }
+  handleInput(data: string) {
+    if (this.ended) return;
+    const { children, id } = this.options;
+    const stopping = this.confirmStop; this.confirmStop = false; this.notice = '';
+    if ((matchesKey(data, 'escape') && !this.editor.isShowingAutocomplete()) || matchesKey(data, 'ctrl+c')) {
+      if (!this.editor.getText()) return this.close();
+      this.editor.setText(''); // First press clears a draft, as in the main editor.
+      return this.options.redraw();
+    }
+    if (matchesKey(data, 'ctrl+x')) {
+      if (!children.live(id)) this.notice = 'This agent has already finished.';
+      else if (stopping) children.stop(id).catch((error: unknown) => { this.notice = `Could not stop: ${String(error)}`; this.options.redraw(); });
+      else this.confirmStop = true;
+    } else if (matchesKey(data, 'pageUp')) this.scroll(Math.max(1, this.bodyHeight - 2));
+    else if (matchesKey(data, 'pageDown')) this.scroll(-Math.max(1, this.bodyHeight - 2));
+    else if (this.options.isExpandKey?.(data)) this.transcript.toggleTools();
+    else if (this.canMessage) this.editor.handleInput(data);
+    this.options.redraw();
+  }
+  private messages(run: RunInfo) {
+    const { children } = this.options, live = children.live(run.id);
+    // Saved transcripts are read once; live ones come from memory each frame, plus one final read when the run ends.
+    if (live || this.wasLive || !this.saved) {
+      try { this.saved = children.messages(run.id); }
+      catch (error) { this.notice = `Transcript unavailable: ${String(error)}`; this.saved = []; }
+    }
+    this.wasLive = !!live;
+    return this.saved;
+  }
+  private header(run: RunInfo | undefined, width: number) {
+    const { color, children, id } = this.options;
+    if (!run) return color('error', ` ${id} · run not found`);
+    const live = children.live(run.id);
+    const dot = live ? color('accent', '●') : run.state === 'completed' ? color('success', '✓') : run.state === 'failed' ? color('error', '✗') : color('muted', '■');
+    const right = `${statusOf(run, children)} · ${elapsed((run.ended ?? Date.now()) - run.started)} · ${run.model.slice(run.model.indexOf('/') + 1)}`;
+    const left = ` ${dot} ${color('accent', run.id)}  `;
+    const room = width - visibleWidth(left) - visibleWidth(right) - 3;
+    if (room < 8) return truncateToWidth(`${left}${color('dim', right)}`, width);
+    const task = fit(oneLine(run.task), room);
+    return `${left}${task}${' '.repeat(Math.max(2, width - visibleWidth(left) - visibleWidth(task) - visibleWidth(right) - 1))}${color('dim', right)} `;
+  }
+  render(width: number): string[] {
+    const { color, children, id, rows } = this.options;
+    const run = children.history.records.get(id), live = children.live(id);
+    const height = Math.max(1, rows());
+    const top = [this.header(run, width), color('borderMuted', '─'.repeat(width))];
+    let input: string[];
+    if (this.canMessage) input = this.editor.render(width);
+    else if (live) input = [color('dim', ' Stopping…')];
+    else input = run ? [color('borderMuted', '─'.repeat(width)), color('dim', ` ${run.state === 'completed' ? 'Finished' : `Ended (${run.state})`}. ${run.parentId ? 'Its report went to the agent that started it.' : 'Its report went to the main agent.'}`)] : [];
+    const pending = (run?.guidance ?? []).filter(g => g.state !== 'delivered');
+    // Only the conversation gives way to the controls: at most three pending lines, then a count.
+    const queued = pending.slice(-3).map(g => color(g.state === 'queued' ? 'muted' : 'warning',
+      ` ${g.state === 'queued' ? 'Queued' : 'Not delivered'}${g.from === 'manager' ? ' (main agent)' : ''}: ${oneLine(g.text)}`));
+    if (pending.length > 3) queued.unshift(color('muted', ` +${pending.length - 3} more not yet delivered`));
+    this.bodyHeight = Math.max(0, height - top.length - input.length - 1 - queued.length); // One footer line.
+    const parts = run ? this.transcript.build(run.task, this.messages(run), live?.streaming, live?.tools, run.guidance) : [];
+    const lines = parts.flatMap(part => part.render(width));
+    if (this.back && this.drawn.width === width) this.back += Math.max(0, lines.length - this.drawn.lines);
+    this.drawn = { lines: lines.length, width };
+    this.overflow = Math.max(0, lines.length - this.bodyHeight);
+    this.back = Math.min(this.back, this.overflow);
+    const end = lines.length - this.back;
+    const body = lines.slice(Math.max(0, end - this.bodyHeight), end);
+    while (body.length < this.bodyHeight) body.push('');
+    const hint = this.confirmStop ? color('warning', ' Press Ctrl+X again to stop this agent and the agents it started')
+      : this.notice ? color('error', ` ${this.notice}`)
+      : color('dim', ` ${this.editor.getText() ? 'Esc clear' : 'Esc back to main'}${live ? ' · Ctrl+X stop' : ''}${this.overflow ? this.back ? ' · PgDn newer' : ' · PgUp older' : ''}`);
+    const scrolled = this.back ? color('warning', `↑ ${this.back} lines up `) : '';
+    const footer = [visibleWidth(hint) + visibleWidth(scrolled) < width ? `${hint}${' '.repeat(width - visibleWidth(hint) - visibleWidth(scrolled))}${scrolled}` : hint];
+    // On a terminal too short for everything, the header goes first; the input and footer stay.
+    return [...top, ...body, ...queued, ...input, ...footer].slice(-height).map(line => truncateToWidth(line, width));
+  }
+}
+
+/** Swaps the whole screen to the subagent's conversation; Pi restores the main chat on close. */
+export function showAgentView(ctx: ExtensionContext, options: { id: string; children: Children; signal?: AbortSignal }) {
+  return ctx.ui.custom<void>((tui, theme, keybindings, done) => new AgentView({ ...options, tui,
+    rows: () => tui.terminal.rows, redraw: () => tui.requestRender(), done: () => done(undefined),
+    color: (tone, text) => theme.fg(tone, text), isExpandKey: data => keybindings.matches(data, 'app.tools.expand'),
+  }), { overlay: true, overlayOptions: { width: '100%', maxHeight: '100%', row: 0, col: 0 } });
+}

package/src/agents.ts

@@ -255,7 +255,7 @@ export class Children {
     if (!live || !['running', 'waiting'].includes(live.info.state)) throw new Error(`No running subagent ${id}.`);
     const text = live.info.connected && source === 'manager' ? `[Main agent guidance]\n${message.trim()}` : message.trim(); if (!message.trim()) throw new Error('Message is empty.');
     if (source === 'user') this.memory.append('user', `Direct guidance to subagent [${id}]: ${text}`);
-    const guidance: RunInfo['guidance'][number] = { text, date: Date.now(), state: 'queued' };
+    const guidance: RunInfo['guidance'][number] = { text, date: Date.now(), state: 'queued', from: source };
     live.info.guidance.push(guidance); this.save(live.info);
     try {
       if (live.info.state === 'waiting') { live.pendingGuidance.push(text); live.wake?.(); }

package/src/index.ts

@@ -22,6 +22,7 @@ import { chooseImport, showProgress } from './import/ui.ts';
 import { IMPORT_GUIDANCE } from './import/guidance.ts';
 import { UsageLedger } from './usage.ts';
 import { showInspector, type InspectorPage } from './inspector.ts';
+import { showAgentView } from './agent-view.ts';
 import { inspectorShortcut, mountNavigation } from './navigation.ts';
 import { serveWindows } from './window-bridge.ts';
 import { openConnectedWindow, registerConnectedRenderer } from './connected-window.ts';
@@ -305,7 +306,9 @@ export default function optchat(pi: ExtensionAPI) {
       const action = await showInspector(ctx, { profile: a.name, session: ctx.sessionManager.getSessionId(), children: a.children, usage: a.usage, page, signal,
         refreshUsage: () => { collectUsage(ctx); try { a.children.collectUsage(); } catch (error) { ctx.ui.notify(`Could not save child usage: ${errorText(error)}`, 'error'); } },
       });
-      if (action === 'model' && !signal.aborted) await pickModel(ctx, 'subagent');
+      if (signal.aborted) return;
+      if (action === 'model') await pickModel(ctx, 'subagent');
+      else if (action) await showAgentView(ctx, { id: action.open, children: a.children, signal });
     } catch (error) { ctx.ui.notify(errorText(error), 'error'); }
     finally { if (inspectorController === controller) inspectorController = undefined; }
   };

package/src/inspector.ts

@@ -1,11 +1,8 @@
-import { Input, matchesKey, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component, type Focusable } from '@earendil-works/pi-tui';
+import { matchesKey, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithAnsi, type Component, type Focusable } from '@earendil-works/pi-tui';
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
-import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { Children } from './agents.ts';
-import { isActiveRun, type RunInfo } from './runs.ts';
+import { isActiveRun } from './runs.ts';
 import { ranges, summarizeUsage, type UsageLedger, type UsageRange } from './usage.ts';
-import { textContent } from './transcript.ts';
-import { record } from './cache.ts';
 
 export const clean = (text: string) => text.replace(/[\x00-\x08\x0b-\x1f\x7f-\x9f]/g, '').replace(/\t/g, '  ');
 export const oneLine = (text: string) => clean(text).replace(/\n/g, ' ');
@@ -24,10 +21,12 @@ const spread = (left: string, right: string, width: number) => {
   return gap >= 2 ? `${left}${' '.repeat(gap)}${right}` : left;
 };
 export type InspectorPage = 'agents' | 'usage';
+/** Closing the panel either picks the subagent model or opens one agent's conversation. */
+export type InspectorAction = 'model' | { open: string };
 type Tone = 'accent' | 'muted' | 'dim' | 'error' | 'border';
 interface Options {
   profile: string; session: string; children: Children; usage: UsageLedger; page: InspectorPage;
-  rows: () => number; redraw: () => void; done: (action?: 'model') => void;
+  rows: () => number; redraw: () => void; done: (action?: InspectorAction) => void;
   color: (tone: Tone, text: string) => string;
   context: () => number | null | undefined;
   refreshUsage?: () => void;
@@ -39,20 +38,12 @@ export class Inspector implements Component, Focusable {
   focused = true;
   private page: InspectorPage;
   private selected?: string;
-  private opened?: string;
   private top = 0;
   private scroll = 0;
   private lineCount = 0;
   private hintLines = 1;
-  private follow = true;
-  private details = false;
   private range: UsageRange = 'This session';
-  private composer?: Input;
-  private error = '';
-  private busy = false;
   private ended = false;
-  private savedMessages?: AgentMessage[];
-  private liveTranscript = false;
   private readonly unsubscribe: () => void;
   private readonly timer: ReturnType<typeof setInterval>;
   constructor(private readonly options: Options) {
@@ -64,50 +55,28 @@ export class Inspector implements Component, Focusable {
     if (options.signal?.aborted) queueMicrotask(this.abort);
   }
   private readonly abort = () => this.finish();
-  private finish(action?: 'model') { if (!this.ended) { this.dispose(); this.options.done(action); } }
+  private finish(action?: InspectorAction) { if (!this.ended) { this.dispose(); this.options.done(action); } }
   dispose() {
     this.ended = true; clearInterval(this.timer); this.unsubscribe(); this.options.signal?.removeEventListener('abort', this.abort);
   }
-  invalidate() { this.composer?.invalidate(); }
-  /** Body rows left after the rules, title, hint, spacing and composer; the rest of the screen keeps the footer visible. */
-  private get height() { return Math.max(1, Math.floor(this.options.rows() * 0.8) - (this.composer ? 7 : 6) - (this.hintLines - 1)); }
+  invalidate() {}
+  /** Body rows left after the rules, title, hint and spacing; the rest of the screen keeps the footer visible. */
+  private get height() { return Math.max(1, Math.floor(this.options.rows() * 0.8) - 6 - (this.hintLines - 1)); }
   private select(delta: number) {
     const list = this.options.children.history.list();
     const index = Math.max(0, list.findIndex(r => r.id === this.selected));
     this.selected = list[Math.max(0, Math.min(list.length - 1, index + delta))]?.id;
   }
-  private async act(action: () => Promise<unknown>) {
-    this.busy = true;
-    try { await action(); } catch (error) { this.error = String(error); }
-    finally { this.busy = false; if (!this.ended) this.options.redraw(); }
-  }
   handleInput(data: string) {
     if (this.ended) return;
-    this.error = '';
-    if (this.composer) {
-      if (matchesKey(data, 'escape')) this.composer = undefined;
-      else if (matchesKey(data, 'return') && !this.busy) {
-        const text = this.composer.getValue().trim(), id = this.opened;
-        if (text && id) { this.composer = undefined; void this.act(() => this.options.children.tell(id, text, 'user')); }
-      } else this.composer.handleInput(data);
-    } else if (matchesKey(data, 'escape') || matchesKey(data, 'ctrl+c')) {
-      if (this.opened) { this.opened = undefined; this.savedMessages = undefined; this.scroll = 0; }
-      else return this.finish();
-    } else if (data === 'u' || matchesKey(data, 'tab')) {
-      this.page = this.page === 'agents' ? 'usage' : 'agents'; this.opened = undefined; this.scroll = 0; this.follow = true;
+    if (matchesKey(data, 'escape') || matchesKey(data, 'ctrl+c')) return this.finish();
+    if (data === 'u' || matchesKey(data, 'tab')) {
+      this.page = this.page === 'agents' ? 'usage' : 'agents'; this.scroll = 0;
     } else if (this.page === 'usage') {
       if (matchesKey(data, 'left') || matchesKey(data, 'right')) {
         const delta = matchesKey(data, 'left') ? -1 : 1;
         this.range = ranges[(ranges.indexOf(this.range) + delta + ranges.length) % ranges.length]; this.scroll = 0;
       } else this.scrollInput(data);
-    } else if (this.opened) {
-      if (data === 's' && !this.busy && ['running', 'waiting'].includes(this.options.children.live(this.opened)?.info.state ?? '')) {
-        this.composer = new Input({ prompt: 'Message: ', placeholder: 'guidance for this child' }); this.composer.focused = this.focused;
-      } else if (data === 'x' && !this.busy && this.options.children.live(this.opened)) {
-        const id = this.opened; void this.act(() => this.options.children.stop(id));
-      } else if (data === 't') this.details = !this.details;
-      else if (data === 'f' || matchesKey(data, 'end')) { this.follow = true; this.scroll = Math.max(0, this.lineCount - this.height); }
-      else this.scrollInput(data);
     } else {
       if (matchesKey(data, 'up')) this.select(-1);
       else if (matchesKey(data, 'down')) this.select(1);
@@ -116,62 +85,17 @@ export class Inspector implements Component, Focusable {
       else if (matchesKey(data, 'home')) this.select(-Infinity);
       else if (matchesKey(data, 'end')) this.select(Infinity);
       else if (data === 'm') return this.finish('model');
-      else if (matchesKey(data, 'return') && this.selected) {
-        try {
-          this.savedMessages = this.options.children.messages(this.selected); this.opened = this.selected;
-          this.liveTranscript = !!this.options.children.live(this.selected);
-          this.follow = true; this.scroll = 0;
-        } catch (error) { this.error = `Transcript unavailable: ${String(error)}`; }
-      }
+      else if (matchesKey(data, 'return') && this.selected) return this.finish({ open: this.selected });
     }
     this.options.redraw();
   }
   private scrollInput(data: string) {
     const delta = matchesKey(data, 'up') ? -1 : matchesKey(data, 'down') ? 1 : matchesKey(data, 'pageUp') ? -this.height : matchesKey(data, 'pageDown') ? this.height : 0;
     if (delta || matchesKey(data, 'home') || matchesKey(data, 'end')) {
-      this.follow = false;
       this.scroll = matchesKey(data, 'home') ? 0 : matchesKey(data, 'end') ? this.lineCount : this.scroll + delta;
       this.scroll = Math.max(0, Math.min(this.scroll, this.lineCount - this.height));
     }
   }
-  private transcript(run: RunInfo) {
-    const live = this.options.children.live(run.id);
-    if (live || this.liveTranscript) {
-      try { this.savedMessages = this.options.children.messages(run.id); }
-      catch (error) { this.error = `Transcript unavailable: ${String(error)}`; }
-      this.liveTranscript = !!live;
-    }
-    const messages = this.savedMessages ?? [];
-    const usage = summarizeUsage(this.options.usage.entries.filter(e => e.runId === run.id)).total;
-    const blocks = [`Task: ${run.task}`, `Directory: ${run.cwd}`, `Model: ${run.model} · effort ${run.thinking}`, `Depth: ${run.depth}/3 · parent: ${run.parentId ?? 'main agent'}`,
-      `Usage: ${count(usage.totalTokens)} tokens · ${count(usage.input)} input · ${count(usage.output)} output · ${count(usage.cacheRead)}/${count(usage.cacheWrite)} cache read/write · $${usage.cost.total.toFixed(4)} API-equivalent`];
-    let initialUser = true;
-    for (const message of messages) {
-      if (message.role === 'user') {
-        if (initialUser) { initialUser = false; continue; } // The initial memory view is context, not work output.
-        blocks.push(`You / manager: ${textContent(message.content)}`);
-      } else if (message.role === 'assistant') {
-        for (const part of message.content) {
-          if (part.type === 'text') blocks.push(part.text);
-          else if (part.type === 'toolCall') blocks.push(`Tool: ${part.name}${this.details ? `\n${JSON.stringify(part.arguments, null, 2)}` : ''}`);
-        }
-        if (message.errorMessage) blocks.push(`Error: ${message.errorMessage}`);
-      } else if (message.role === 'toolResult') {
-        const output = textContent(message.content);
-        blocks.push(`${message.isError ? 'Error' : 'Result'}: ${message.toolName}\n${this.details ? output : `${oneLine(output).slice(0, 160)}${output.length > 160 ? '… [t expands]' : ''}`}`);
-      }
-    }
-    for (const tool of live?.tools.values() ?? []) {
-      blocks.push(`Running: ${tool.name} · ${elapsed(Date.now() - tool.started)}\n${JSON.stringify(tool.args)}`);
-      if (tool.output) {
-        const output = record(tool.output) ? textContent(tool.output.content) : String(tool.output);
-        blocks.push(this.details ? output : output.slice(-500));
-      }
-    }
-    if (run.report && !live) blocks.push(`Final report: ${run.report}`);
-    for (const g of run.guidance) if (g.state !== 'delivered') blocks.push(`Message ${g.state}: ${g.text}`);
-    return blocks.filter(Boolean).map(clean).join('\n\n');
-  }
   private usageLines() {
     const { usage, session, context } = this.options;
     const entries = usage.select(this.range, session);
@@ -194,18 +118,14 @@ export class Inspector implements Component, Focusable {
   render(width: number): string[] {
     const { color, children, profile } = this.options;
     const inner = Math.max(1, width - 2);
-    const inspected = this.opened ? children.history.records.get(this.opened) : undefined;
-    let title = `OptChat · ${profile} · ${inspected ? `${inspected.state}: ${oneLine(inspected.task)}` : this.page === 'usage' ? 'Usage' : 'Agents'}`;
+    let title = `OptChat · ${profile} · ${this.page === 'usage' ? 'Usage' : 'Agents'}`;
     let info: string, body: string[], hint: string;
-    if (this.page === 'usage' || this.opened) {
-      const run = this.opened ? children.history.records.get(this.opened) : undefined;
-      const text = this.page === 'usage' ? this.usageLines() : run ? `${run.state} · ${elapsed((run.ended ?? Date.now()) - run.started)} · ${run.id}\n\n${this.transcript(run)}` : 'Run unavailable.';
-      const lines = wrapTextWithAnsi(clean(text), inner); this.lineCount = lines.length;
-      if (this.opened && this.follow) this.scroll = Math.max(0, lines.length - this.height);
+    if (this.page === 'usage') {
+      const lines = wrapTextWithAnsi(clean(this.usageLines()), inner); this.lineCount = lines.length;
       this.scroll = Math.max(0, Math.min(this.scroll, lines.length - this.height));
       body = lines.slice(this.scroll, this.scroll + this.height);
-      info = `${this.scroll + 1}–${Math.min(this.scroll + this.height, lines.length)} / ${lines.length}${this.opened ? this.follow ? ' · following' : ' · scroll paused' : ''}`;
-      hint = this.page === 'usage' ? '←→ period · ↑↓/PgUp/PgDn scroll · Tab agents · Esc close' : '↑↓/PgUp/PgDn scroll · t tools · f follow · s message · x stop tree · Esc back';
+      info = `${this.scroll + 1}–${Math.min(this.scroll + this.height, lines.length)} / ${lines.length}`;
+      hint = '←→ period · ↑↓/PgUp/PgDn scroll · Tab agents · Esc close';
     } else {
       const list = children.history.list();
       if (!this.selected) this.selected = list[0]?.id;
@@ -231,11 +151,10 @@ export class Inspector implements Component, Focusable {
       });
       if (!body.length) body.push(color('muted', 'No agents yet. Ask the main agent to delegate a task.'));
       info = `${list.filter(isActiveRun).length} active · ${list.length} saved${list.length ? ` · ${cursor + 1}/${list.length}` : ''}`;
-      hint = '↑↓ select · Enter inspect · m model · Tab usage · Esc close';
+      hint = '↑↓ select · Enter open · m model · Tab usage · Esc close';
     }
-    if (this.composer) { this.composer.focused = this.focused; body.push(...this.composer.render(inner)); hint = 'Enter sends guidance · Esc cancels message'; }
     title = fit(title, Math.max(1, inner - visibleWidth(info) - 2));
-    const footer = wrapTextWithAnsi(this.error || (this.busy ? 'Updating agent…' : hint), inner).map(line => color(this.error ? 'error' : 'dim', line));
+    const footer = wrapTextWithAnsi(hint, inner).map(line => color('dim', line));
     this.hintLines = footer.length;
     const rule = color('border', '─'.repeat(Math.max(1, width)));
     // Same layout as Pi's own selectors: rules above and below, content indented by one column.
@@ -249,7 +168,7 @@ let showing = false;
 export const inspectorShowing = () => showing;
 /** Takes the editor's place, like Pi's own selectors; Pi restores the editor and its draft on close. */
 export function showInspector(ctx: ExtensionContext, options: Omit<Options, 'rows' | 'redraw' | 'done' | 'color' | 'context'>) {
-  return ctx.ui.custom<'model' | undefined>((tui, theme, _keys, done) => {
+  return ctx.ui.custom<InspectorAction | undefined>((tui, theme, _keys, done) => {
     showing = true;
     return new Inspector({ ...options,
       rows: () => tui.terminal.rows, redraw: () => tui.requestRender(), done: action => { showing = false; done(action); },

package/src/runs.ts

@@ -16,7 +16,8 @@ export interface RunInfo {
   state: RunState; report?: string;
   connected?: boolean;
   handoff?: { reason: FinishReason; text?: string; delivered?: boolean };
-  guidance: { text: string; date: number; state: 'queued' | 'delivered' | 'undelivered' }[];
+  /** `from` is missing on runs saved before senders were recorded. */
+  guidance: { text: string; date: number; state: 'queued' | 'delivered' | 'undelivered'; from?: 'user' | 'manager' }[];
 }
 export const isActiveRun = (run: RunInfo) => run.state === 'running' || run.state === 'waiting' || run.state === 'stopping';
 function isRun(value: unknown): value is RunInfo {
@@ -32,7 +33,7 @@ function isRun(value: unknown): value is RunInfo {
       && (value.handoff.delivered === undefined || typeof value.handoff.delivered === 'boolean'))
     && typeof value.depth === 'number' && Number.isInteger(value.depth) && value.depth >= 1 && value.depth <= 3
     && (value.parentId === undefined || typeof value.parentId === 'string')
-    && Array.isArray(value.guidance) && value.guidance.every(g => record(g) && typeof g.text === 'string' && typeof g.date === 'number' && ['queued', 'delivered', 'undelivered'].includes(String(g.state)));
+    && Array.isArray(value.guidance) && value.guidance.every(g => record(g) && typeof g.text === 'string' && typeof g.date === 'number' && ['queued', 'delivered', 'undelivered'].includes(String(g.state)) && (g.from === undefined || g.from === 'user' || g.from === 'manager'));
 }
 export function sessionMessages(file: string): AgentMessage[] {
   return SessionManager.open(file).getEntries().flatMap(e => e.type === 'message' ? [e.message] : []);