pi-optchat 0.6.0 → 0.6.2

package/README.md

@@ -69,7 +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.
-- The parent can send a running child guidance with `tell`.
+- 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.
 - Stopping an agent stops its whole subtree. A failed parent stops its descendants.
@@ -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.
 
@@ -139,7 +140,7 @@ Each profile is locked to one Pi process. If you open the same profile in a seco
 
 - Your first message starts a subagent in the second window's working directory. Later messages continue the same conversation.
 - 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 has a `tell_main` tool, and the main agent replies with `tell`. Routine turns don't wake the main agent.
+- 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.
 - Closing or force-quitting the window also produces a handoff, marked **interrupted**.
 - If the original window is closed cleanly, handoffs are delivered on next start. If it is killed, reopening the profile recovers unfinished handoffs (work is not restarted).

package/package.json

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

@@ -115,7 +115,8 @@ export class Children {
         if (cancelled()) throw new Error('Parent or profile is stopping.');
         const id = randomUUID().slice(0, 8), directory = task.cwd ?? cwd;
         const delegation = depth < 3 ? 'You may delegate parts of your assigned task with spawn when useful. Child reports arrive automatically after your current run ends; the harness keeps you alive to receive them. Never poll, sleep, or wait in a tool for children. Finish your current work and return; you will be prompted with their results. The profile allows 8 active agents total.' : 'You are at the maximum delegation depth. Complete your task with your own tools.';
-        const instructions = [this.instructions(), delegation, connected ? 'You are speaking directly with the user in a connected window. Continue this conversation across requests. Use tell_main for questions or findings the main agent needs now. A handoff will be generated when the user completes or disconnects the window.' : ''].filter(Boolean).join('\n\n');
+        const instructions = [this.instructions(), delegation, connected ? 'You are speaking directly with the user in a connected window. Continue this conversation across requests. Use tell_parent for questions or findings the main agent needs now. A handoff will be generated when the user completes or disconnects the window.'
+          : 'Use tell_parent only when your parent needs something now (a blocking question, an important early finding, or when asked to). Your final answer is delivered automatically; do not repeat it with tell_parent.'].filter(Boolean).join('\n\n');
         // The user's settings list their installed packages; a copy in memory keeps the child from writing them back.
         const settingsManager = SettingsManager.inMemory({ ...SettingsManager.create(directory, getAgentDir()).getSettings(), compaction: { enabled: false }, cacheWarming: 'off' });
         const loader = new DefaultResourceLoader({ cwd: directory, agentDir: getAgentDir(), settingsManager,
@@ -135,12 +136,7 @@ export class Children {
         await loader.reload();
         const { session } = await (this.options.createSession ?? createAgentSession)({ cwd: directory, resourceLoader: loader, settingsManager,
           model, thinkingLevel: selected.thinking, sessionManager: SessionManager.create(directory, join(this.profileDirectory, 'runs')),
-          customTools: [...memoryTools(() => this.memory), ...(depth < 3 ? this.delegationTools(id, directory) : []), ...(connected ? [{
-            name: 'tell_main', label: 'Message main agent', description: 'Send the main agent a question or important finding. Its reply can arrive as guidance; continue useful work instead of polling.',
-            parameters: Type.Object({ message: Type.String() }), execute: async (_id: string, args: { message: string }) => {
-              await this.report(`[${id}] Connected agent message: ${args.message}`); return result('Message sent to the main agent.');
-            },
-          }] : [])],
+          customTools: [...memoryTools(() => this.memory), ...(depth < 3 ? this.delegationTools(id, directory) : []), this.parentTool(id, parentId, connected)],
           excludeTools: depth < 3 ? [] : ['spawn', 'tell'],
         });
         await session.bindExtensions({});
@@ -185,6 +181,24 @@ export class Children {
       },
     }];
   }
+  /** Lets a child message its parent mid-run, the way tell lets the parent guide it. */
+  private parentTool(id: string, parentId: string | undefined, connected: boolean) {
+    return { name: 'tell_parent', label: parentId ? 'Message parent agent' : 'Message main agent',
+      description: `Send ${parentId ? 'your parent agent' : 'the main agent'} a question or important finding while you keep working. Its reply can arrive as guidance; continue useful work instead of polling. Your final answer is delivered automatically.`,
+      parameters: Type.Object({ message: Type.String() }), execute: async (_id: string, args: { message: string }) => {
+        const message = args.message.trim();
+        if (!message) throw new Error('Message is empty.');
+        const text = `[${id}] ${connected ? 'Connected agent message' : 'Message from subagent (still running)'}: ${message}`;
+        if (!parentId) { await this.report(text); return result('Message sent to the main agent.'); }
+        const parent = this.running.get(parentId);
+        if (!parent || !['running', 'waiting'].includes(parent.info.state)) throw new Error('Your parent is no longer running.');
+        if (parent.info.state === 'waiting') { parent.pendingReports.push(text); parent.wake?.(); }
+        else await parent.session.steer(text);
+        this.changed();
+        return result(`Message sent to parent ${parentId}.`);
+      },
+    };
+  }
   private directChildren(id: string) { return [...this.running.values()].filter(c => c.info.parentId === id); }
   private async execute(live: LiveRun, view: string) {
     const { session, info } = live;
@@ -255,7 +269,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] : []);