pi-optchat 0.5.1 → 0.6.1

package/README.md

@@ -5,7 +5,7 @@ A Pi extension that implements [Victor Taelin's OptChat recipe](https://gist.git
 - **Memory**: every message is logged and summarized into a binary tree. Each turn starts from a fresh context holding a bounded memory view; the agent uses `zoom` and `date` to read originals.
 - **Profiles**: separate memories and instructions, such as `work` and `personal`.
 - **Subagents**: delegate tasks to background agents, inspect them live, and send them guidance.
-- **Import**: bring in history from Claude Code, Codex, or ChatGPT.
+- **Import**: bring in history from Claude Code (conversations and memories), Codex, or ChatGPT.
 - **Connected windows**: a second Pi window on the same profile becomes a subagent you talk to directly.
 
 It runs inside ordinary Pi, with no fork or separate launcher.
@@ -46,7 +46,7 @@ For headless use, pass `--optchat-profile work`.
 | `/optchat agents model` | Subagent model and effort for this profile. |
 | `/optchat usage` | Token usage and cost estimates. |
 | `/optchat instructions` | Edit this profile's `AGENTS.md`. |
-| `/optchat browse` | Open an HTML snapshot of memory: current view, every tree level, original messages. Run again to refresh. |
+| `/optchat browse` | Open a readable snapshot of memory: the shape of what the model sees, summaries you can open down to the original messages, and search that shows where each message is folded. Run again to refresh. |
 | `/optchat import` | Import history, or resume/discard a paused import. |
 | `/complete` | In a connected window: end the conversation and hand off to the main agent. |
 | `/tell-main <message>` | In a connected window: message the main agent. |
@@ -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.
 
@@ -112,8 +113,8 @@ Guidance shows as queued until delivered, or undelivered if the child stops firs
 
 Pick the destination profile, then run `/optchat import`.
 
-1. **Source**: Claude Code (`~/.claude/projects`), Codex (`~/.codex/sessions`, `~/.codex/archived_sessions`), or a ChatGPT export (ZIP, folder, or `conversations.json`; ZIP needs `unzip`). Scanning is local and makes no model calls.
-2. **Select**: for Claude Code and Codex, pick projects (busiest first), optionally filter by start date, then take all conversations or pick some. **Space** toggles, **Enter** continues, type to filter, **Ctrl+A**/**Ctrl+D** select/clear matches, **Esc** cancels. Nothing is classified as work or personal for you.
+1. **Source**: Claude Code (`~/.claude/projects`), Claude Code memories, Codex (`~/.codex/sessions`, `~/.codex/archived_sessions`), or a ChatGPT export (ZIP, folder, or `conversations.json`; ZIP needs `unzip`). Scanning is local and makes no model calls.
+2. **Select**: for Claude Code, its memories, and Codex, pick projects (busiest first), optionally filter by start date, then take all conversations or pick some. **Space** toggles, **Enter** continues, type to filter, **Ctrl+A**/**Ctrl+D** select/clear matches, **Esc** cancels. Nothing is classified as work or personal for you.
 3. **Mode** (only if the profile already has history):
    - **Append**: keep existing summaries and add the import. Faster and cheaper.
    - **Rebuild by conversation start date**: regenerate the whole tree, ordered by conversation start.
@@ -121,6 +122,8 @@ Pick the destination profile, then run `/optchat import`.
 
 **What gets imported**: user messages and final assistant replies, with original dates and source labels, as in Victor's recipe. Tool calls and results, intermediate commentary, reasoning, subagent transcripts, replayed context, and image/audio/file bytes are left out. ChatGPT alternate branches are labelled as alternatives. Imported records are marked as historical so old requests are not treated as new instructions.
 
+**Claude Code memories**: the auto-memory topic files in `~/.claude/projects/*/memory/` (not `MEMORY.md`, which only indexes them), picked by project. Each file becomes one dated note in the memory tree, not part of the prompt. An edited file comes in again as a newer note.
+
 **Duplicates**: re-importing skips messages already present, even if titles or paths changed. Changed source messages can appear as a separate historical version.
 
 **Pausing**: **Pause import** (or Escape) saves progress, and so does restarting Pi. `/optchat import` then offers **Resume** or **Discard staged import**. While an import is pending, chat in that profile is blocked; other profiles still work. Imports need the main agent and its subagents to be idle.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-optchat",
-  "version": "0.5.1",
+  "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/browser.ts

@@ -2,21 +2,230 @@ import { join } from 'node:path';
 import { atomicWrite } from './profiles.ts';
 import { type Memory } from './memory.ts';
 
+// One self-contained, read-only HTML snapshot of a profile's memory.
 export function exportBrowser(memory: Memory, profile: string, directory = memory.directory) {
-  const data = JSON.stringify({ profile, root: memory.root, tree: [...memory.tree.values()], view: memory.view }).replace(/</g, '\\u003c');
-  const html = `<!doctype html><html lang="en"><meta charset="utf-8"><title>OptChat memory</title>
-<style>body{font:16px system-ui;max-width:1100px;margin:40px auto;padding:0 24px;background:#f6f5f1;color:#20231e}h1{font-size:32px}details{margin:8px 0;padding:12px;border:1px solid #d8dbd0;border-radius:8px;background:white}summary{cursor:pointer;white-space:pre-wrap}pre{white-space:pre-wrap;overflow-wrap:anywhere;font:14px ui-monospace,monospace}small{color:#647057}button{padding:10px;margin:8px 8px 8px 0;cursor:pointer}</style>
-<h1 id="title"></h1><p id="info"></p><button id="view">Current view</button><button id="all">All original messages</button><label>Tree level <select id="level"><option value="">Choose…</option></select></label><main id="memory"></main>
-<script type="application/json" id="data">${data}</script><script>
-const d=JSON.parse(document.getElementById('data').textContent), nodes=new Map(d.tree.map(n=>[n.l+':'+n.i,n]));
-document.getElementById('title').textContent='OptChat · '+d.profile;
-document.getElementById('info').textContent=d.root.length+' messages · '+d.tree.length+' summaries · Snapshot '+new Date().toLocaleString()+'. Open a line to zoom.';
-const main=document.getElementById('memory');
-function raw(i){const r=d.root[i],p=document.createElement('pre');p.textContent=r? r.i+' · '+r.date+' · '+r.kind+'\\n\\n'+r.text:'Message unavailable';return p;}
-function node(l,i){const first=i*2**l,n=nodes.get(l+':'+i),el=document.createElement('details'),s=document.createElement('summary'),meta=document.createElement('small');s.textContent=first+'+'+2**l+' | '+(n?n.text:'Not summarized yet');meta.textContent=(n?n.size+' bytes · ':'')+(d.root[first]?.date||'')+' — '+(d.root[first+2**l-1]?.date||'');el.append(s,meta);let built=false;el.addEventListener('toggle',()=>{if(!el.open||built)return;built=true;if(l===0)el.append(raw(i));else el.append(node(l-1,i*2),node(l-1,i*2+1));});return el;}
-function view(){main.replaceChildren(...d.view.map(p=>node(p.l,p.i)));}
-document.getElementById('view').onclick=view;document.getElementById('all').onclick=()=>main.replaceChildren(...d.root.map(r=>{const e=document.createElement('details'),s=document.createElement('summary');s.textContent=r.i+' · '+r.date+' · '+r.kind+' · '+r.size+' bytes';e.append(s);e.addEventListener('toggle',()=>{if(e.open&&e.children.length===1)e.append(raw(r.i));});return e;}));
-const levels=document.getElementById('level');for(const l of [...new Set(d.tree.map(n=>n.l))].sort((a,b)=>b-a)){const o=document.createElement('option');o.value=l;o.textContent='Level '+l+' ('+2**l+' messages/node)';levels.append(o);}levels.onchange=()=>{if(levels.value!=='')main.replaceChildren(...d.tree.filter(n=>n.l===Number(levels.value)).sort((a,b)=>a.i-b.i).map(n=>node(n.l,n.i)));};view();
-</script></html>`;
-  const path = join(directory, 'memory.html'); atomicWrite(path, html); return path;
+  const data = JSON.stringify({
+    profile, budget: memory.budget, size: memory.size, view: memory.view,
+    root: memory.root.map(({ i, kind, text, date, origin }) => ({ i, kind, text, date, ...(origin ? { origin: { source: origin.source, title: origin.title } } : {}) })),
+    tree: [...memory.tree.values()].map(({ l, i, text }) => ({ l, i, text })),
+  }).replace(/</g, '\\u003c');
+  const path = join(directory, 'memory.html'); atomicWrite(path, PAGE.replace('__DATA__', () => data)); return path;
+}
+
+// Client code avoids backticks and template placeholders so it can live in String.raw.
+const PAGE = String.raw`<!doctype html><html lang="en"><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1"><title>OptChat memory</title>
+<style>
+:root{--bg:#f7f3ea;--paper:#fffdf8;--ink:#2a2723;--muted:#6b6357;--rule:#e4dccd;--accent:#7d5630;--bar:#d5c7ad;--you:#3f6380;--talk:#2a2723;--work:#4c6a41;--tool:#6b6357;--note:#80601f;--hl:#f6e7c1}
+*{box-sizing:border-box}
+body{margin:0;background:var(--bg);color:var(--ink);font:16px/1.6 -apple-system,BlinkMacSystemFont,"Segoe UI",system-ui,sans-serif;-webkit-font-smoothing:antialiased}
+.wrap{max-width:780px;margin:0 auto;padding:64px 28px 160px}
+h1{font:400 36px/1.15 "Iowan Old Style",Charter,Georgia,serif;margin:0 0 4px}
+h1 small{font-size:18px;color:var(--muted);margin-left:10px}
+.lede{color:var(--muted);margin:0 0 4px}
+.explain{font-size:14px;color:var(--muted);margin:16px 0 0;max-width:620px}
+.shape{display:flex;align-items:flex-end;gap:1px;height:84px;margin:36px 0 6px}
+.shape.dense{gap:0}
+.shape button{flex:1 1 0;min-width:0;border:0;padding:0;background:var(--bar);border-radius:1px;cursor:pointer}
+.shape button:hover,.shape button:focus-visible{background:var(--accent);outline:none}
+.axis{display:flex;justify-content:space-between;font-size:12px;color:var(--muted)}
+nav{display:flex;gap:28px;margin:48px 0 8px;border-bottom:1px solid var(--rule)}
+nav button{background:none;border:0;border-bottom:2px solid transparent;margin-bottom:-1px;padding:0 0 10px;font:inherit;color:var(--muted);cursor:pointer}
+nav button.on{color:var(--ink);border-color:var(--ink)}
+h2.day{font-size:12px;font-weight:600;line-height:1;letter-spacing:.08em;text-transform:uppercase;color:var(--muted);margin:44px 0 0;padding-bottom:10px;border-bottom:1px solid var(--rule)}
+.block,.msg{padding:18px 0;border-bottom:1px solid var(--rule)}
+.children .block,.children .msg{border-bottom:0;padding:12px 0}
+.meta,.who{font-size:13px;color:var(--muted)}
+.who b{font-weight:600;letter-spacing:.04em;text-transform:uppercase;font-size:11.5px}
+.msg.you .who b{color:var(--you)}.msg.talk .who b{color:var(--talk)}.msg.work .who b{color:var(--work)}.msg.tool .who b{color:var(--tool)}.msg.note .who b{color:var(--note)}
+.summary{margin:6px 0 8px}
+.pending{color:var(--muted);font-style:italic}
+.text{margin-top:4px;white-space:pre-wrap;overflow-wrap:anywhere}
+.clamp{display:-webkit-box;-webkit-line-clamp:7;-webkit-box-orient:vertical;overflow:hidden}
+.children{margin:4px 0 0 2px;padding-left:20px;border-left:1px solid var(--rule)}
+button.link{background:none;border:0;padding:0;font:inherit;font-size:14px;color:var(--accent);cursor:pointer}
+button.link:hover{text-decoration:underline}
+.target{background:var(--hl);box-shadow:-12px 0 0 var(--hl),12px 0 0 var(--hl)}
+input[type=search]{width:100%;margin:24px 0 8px;padding:12px 16px;font:inherit;border:1px solid var(--rule);border-radius:10px;background:var(--paper);color:var(--ink);outline:none}
+input[type=search]:focus{border-color:var(--bar)}
+.count{font-size:14px;color:var(--muted);margin:0 0 8px}
+mark{background:var(--hl);color:inherit;border-radius:2px;padding:0 1px}
+.path{margin-top:10px;font-size:13px;color:var(--muted)}
+.path .steps{display:flex;flex-wrap:wrap;align-items:center;gap:4px;margin-top:6px}
+.path .steps button{font:inherit;font-size:12px;padding:2px 9px;border:1px solid var(--rule);border-radius:99px;background:var(--paper);color:var(--ink);cursor:pointer}
+.path .steps button.on{border-color:var(--accent);color:var(--accent)}
+.peek{margin:8px 0 0;padding:10px 14px;background:var(--paper);border:1px solid var(--rule);border-radius:8px;font-size:14px;color:var(--ink)}
+.empty{color:var(--muted);margin-top:40px}
+</style>
+<div class="wrap">
+<header><h1>Memory <small id="profile"></small></h1><p class="lede" id="lede"></p>
+<p class="explain">Recent messages are kept one by one. Older ones are folded into summaries of 2, 4, 8 or more messages, so the whole history fits in what the model reads each turn. Open a summary to see the two halves it was made from, down to the original messages.</p>
+<div class="shape" id="shape"></div><div class="axis"><span id="from"></span><span>Each bar is one block the model sees. Taller bars fold more messages.</span><span>now</span></div></header>
+<nav><button id="tab-view" class="on">What the model sees</button><button id="tab-search">Search</button></nav>
+<main id="view"></main>
+<main id="search" hidden><input type="search" id="q" placeholder="Search every message" autocomplete="off"><p class="count" id="count"></p><div id="hits"></div></main>
+</div>
+<script type="application/json" id="data">__DATA__</script>
+<script>
+const D = JSON.parse(document.getElementById('data').textContent);
+const nodes = new Map(D.tree.map(n => [n.l + ':' + n.i, n]));
+const $ = (tag, cls, text) => { const e = document.createElement(tag); if (cls) e.className = cls; if (text != null) e.textContent = text; return e; };
+const first = p => p.i * 2 ** p.l, count = p => 2 ** p.l;
+const year = new Date().getFullYear();
+const day = d => d.toLocaleDateString(undefined, Object.assign({ weekday: 'short', day: 'numeric', month: 'short' }, d.getFullYear() !== year ? { year: 'numeric' } : {}));
+const time = d => d.toLocaleTimeString(undefined, { hour: '2-digit', minute: '2-digit' });
+const times = D.root.map(e => new Date(e.date).getTime()), at = i => new Date(times[i]);
+// Imported history is not always in date order, so a range shows its earliest and latest message.
+function when(a, b) {
+  let lo = times[a], hi = times[a];
+  for (let k = a + 1; k <= b; k++) { lo = Math.min(lo, times[k]); hi = Math.max(hi, times[k]); }
+  const x = new Date(lo), y = new Date(hi);
+  if (lo === hi) return day(x) + ', ' + time(x);
+  return x.toDateString() === y.toDateString() ? day(x) + ', ' + time(x) + '–' + time(y) : day(x) + ' ' + time(x) + ' – ' + day(y) + ' ' + time(y);
+}
+const SOURCE = { claude: 'Claude Code', 'claude-memory': 'Claude Code memory', codex: 'Codex', chatgpt: 'ChatGPT' };
+// Imported text starts with a "[Historical …]" line for the model; the meta line already says it.
+const body = e => { const j = e.origin && e.text.startsWith('[Historical ') ? e.text.indexOf(']\n') : -1; return j < 0 ? e.text : e.text.slice(j + 2); };
+const short = (s, n) => { s = s.replace(/\s+/g, ' ').trim(); return s.length > n ? s.slice(0, n - 1) + '…' : s; };
+function who(e) {
+  if (e.kind === 'user') return /^\[[0-9a-f]{6,}\] /.test(e.text) ? ['Subagent', 'work', 'subagent report'] : ['You', 'you', 'from you'];
+  if (e.kind === 'talk') return ['OptChat', 'talk', 'reply'];
+  if (e.kind === 'tool') return ['Tool call', 'tool', 'tool step'];
+  if (e.kind === 'echo') return ['Tool result', 'tool', 'tool step'];
+  return ['Note', 'note', 'note'];
+}
+function mix(a, b) {
+  const c = new Map();
+  for (let k = a; k < b; k++) { const w = who(D.root[k])[2]; c.set(w, (c.get(w) || 0) + 1); }
+  return [...c].map(([w, n]) => n.toLocaleString() + ' ' + (n === 1 || w === 'from you' ? w : w === 'reply' ? 'replies' : w + 's')).join(', ');
+}
+function head(e) {
+  const [label] = who(e), h = $('div', 'who');
+  h.append($('b', null, label), ' · ' + when(e.i, e.i));
+  if (e.origin) h.append(' · imported from ' + SOURCE[e.origin.source] + (e.origin.title ? ': ' + short(e.origin.title, 60) : ''));
+  return h;
+}
+function message(e) {
+  const text = body(e), el = $('div', 'msg ' + who(e)[1]), t = $('div', 'text clamp', text);
+  el.dataset.k = '0:' + e.i; el.append(head(e), t);
+  if (text.length > 600 || text.split('\n').length > 7) {
+    const b = $('button', 'link', 'Show all');
+    b.onclick = () => { b.textContent = t.classList.toggle('clamp') ? 'Show all' : 'Show less'; };
+    el.append(b);
+  } else t.classList.remove('clamp');
+  return el;
+}
+// The model sees a large message as its shortened node, so the view shows that and keeps the original one click away.
+function leaf(p) {
+  const e = D.root[p.i], n = nodes.get('0:' + p.i);
+  if (!n || n.text === e.text) return message(e);
+  const el = $('article', 'block'), kids = $('div', 'children'), b = $('button', 'link', 'Show the original');
+  el.dataset.k = '0:' + p.i; kids.hidden = true;
+  el.append($('div', 'meta', who(e)[0] + ' · ' + when(p.i, p.i) + ' · shortened for the model'), $('p', 'summary', n.text), b, kids);
+  b.onclick = () => { if (!kids.childElementCount) kids.append(message(e)); kids.hidden = !kids.hidden; b.textContent = kids.hidden ? 'Show the original' : 'Close'; };
+  return el;
+}
+function block(p) {
+  if (p.l === 0) return message(D.root[p.i]);
+  const a = first(p), n = nodes.get(p.l + ':' + p.i), el = $('article', 'block');
+  el.dataset.k = p.l + ':' + p.i;
+  el.append($('div', 'meta', when(a, a + count(p) - 1) + ' · ' + count(p).toLocaleString() + ' messages: ' + mix(a, a + count(p))));
+  el.append(n ? $('p', 'summary', n.text) : $('p', 'summary pending', 'Not summarized yet.'));
+  const b = $('button', 'link', 'Open the two halves'), kids = $('div', 'children');
+  kids.hidden = true; b.onclick = () => open(el); el.append(b, kids);
+  return el;
+}
+function open(el, force) {
+  const [l, i] = el.dataset.k.split(':').map(Number), kids = el.querySelector(':scope > .children'), b = el.querySelector(':scope > button.link');
+  if (!kids.childElementCount) kids.append(block({ l: l - 1, i: 2 * i }), block({ l: l - 1, i: 2 * i + 1 }));
+  kids.hidden = force === undefined ? !kids.hidden : !force;
+  b.textContent = kids.hidden ? 'Open the two halves' : 'Close';
+  return kids;
 }
+const view = document.getElementById('view'), search = document.getElementById('search');
+function show(tab) {
+  view.hidden = tab !== 'view'; search.hidden = tab !== 'search';
+  document.getElementById('tab-view').classList.toggle('on', tab === 'view');
+  document.getElementById('tab-search').classList.toggle('on', tab === 'search');
+  if (tab === 'search') document.getElementById('q').focus();
+}
+document.getElementById('tab-view').onclick = () => show('view');
+document.getElementById('tab-search').onclick = () => show('search');
+function target(el) { document.querySelectorAll('.target').forEach(x => x.classList.remove('target')); el.classList.add('target'); el.scrollIntoView({ block: 'center' }); }
+const holder = m => D.view.find(p => first(p) <= m && m < first(p) + count(p));
+function reveal(m) {
+  show('view');
+  const p = holder(m); let el = view.querySelector('[data-k="' + p.l + ':' + p.i + '"]');
+  for (let k = p.l; k > 0; k--) el = open(el, true).querySelector(':scope > [data-k="' + (k - 1) + ':' + Math.floor(m / 2 ** (k - 1)) + '"]');
+  if (el.matches('article')) { const b = el.querySelector(':scope > button.link'); if (b.textContent !== 'Close') b.click(); el = el.querySelector('.children > .msg'); }
+  target(el);
+}
+
+document.getElementById('profile').textContent = D.profile;
+if (!D.root.length) { document.getElementById('lede').textContent = 'No messages yet.'; document.querySelector('.shape').remove(); document.querySelector('.axis').remove(); }
+else {
+  const kb = n => Math.round(n / 1000).toLocaleString() + ' KB';
+  document.getElementById('lede').textContent = D.root.length.toLocaleString() + ' messages since ' + day(at(0)) + '. The model sees them as ' + D.view.length.toLocaleString() + ' blocks, using ' + kb(D.size) + ' of its ' + kb(D.budget) + ' memory view.';
+  document.getElementById('from').textContent = day(at(0));
+  const shape = document.getElementById('shape'), top = Math.max(1, ...D.view.map(p => p.l));
+  shape.classList.toggle('dense', D.view.length > 250);
+  for (const p of D.view) {
+    const s = $('button'), a = first(p);
+    s.style.height = (6 + 78 * p.l / top) + 'px';
+    s.title = when(a, a + count(p) - 1) + ' · ' + count(p).toLocaleString() + (count(p) === 1 ? ' message' : ' messages');
+    s.onclick = () => { show('view'); target(view.querySelector('[data-k="' + p.l + ':' + p.i + '"]')); };
+    s.setAttribute('aria-label', s.title);
+    shape.append(s);
+  }
+  let last = '';
+  for (const p of D.view) {
+    const d = at(first(p));
+    if (d.toDateString() !== last) { view.append($('h2', 'day', day(d))); last = d.toDateString(); }
+    view.append(p.l ? block(p) : leaf(p));
+  }
+}
+
+const q = document.getElementById('q'), hits = document.getElementById('hits'), counter = document.getElementById('count');
+const lower = D.root.map(e => body(e).toLowerCase());
+function snippet(text, j, len) {
+  const a = Math.max(0, j - 140), b = Math.min(text.length, j + len + 220), el = $('div', 'text');
+  el.append((a ? '…' : '') + text.slice(a, j), $('mark', null, text.slice(j, j + len)), text.slice(j + len, b) + (b < text.length ? '…' : ''));
+  return el;
+}
+function path(m) {
+  const p = holder(m), wrap = $('div', 'path'), steps = $('div', 'steps'), peek = $('div', 'peek');
+  wrap.append(p.l ? 'The model sees this inside a ' + count(p).toLocaleString() + '-message summary. Each step is one zoom:' : 'The model sees this message on its own.');
+  const go = $('button', 'link', 'Show in memory'); go.onclick = () => reveal(m);
+  if (!p.l) { wrap.append(' ', go); return wrap; }
+  peek.hidden = true; go.style.marginLeft = '8px';
+  for (let k = p.l; k >= 0; k--) {
+    const i = Math.floor(m / 2 ** k), b = $('button', null, k ? (2 ** k).toLocaleString() + ' messages' : 'this message');
+    b.onclick = () => {
+      const on = !b.classList.contains('on'); steps.querySelectorAll('button').forEach(x => x.classList.remove('on'));
+      b.classList.toggle('on', on); peek.hidden = !on;
+      peek.textContent = (nodes.get(k + ':' + i) || { text: 'Not summarized yet.' }).text;
+    };
+    steps.append(b);
+    if (k) steps.append('›');
+  }
+  steps.append(go);
+  wrap.append(steps, peek);
+  return wrap;
+}
+let timer;
+q.oninput = () => { clearTimeout(timer); timer = setTimeout(find, 120); };
+function find() {
+  const s = q.value.trim().toLowerCase();
+  hits.replaceChildren(); counter.textContent = '';
+  if (s.length < 2) return;
+  const found = [];
+  for (let i = D.root.length - 1; i >= 0; i--) { const j = lower[i].indexOf(s); if (j >= 0) found.push([i, j]); }
+  // Imported history is appended after native messages and may be out of date order, so sort by time.
+  found.sort((x, y) => times[y[0]] - times[x[0]] || y[0] - x[0]);
+  counter.textContent = found.length ? found.length.toLocaleString() + (found.length === 1 ? ' message' : ' messages') + ', newest first' + (found.length > 100 ? ' (showing 100)' : '') : 'No messages match.';
+  for (const [i, j] of found.slice(0, 100)) {
+    const e = D.root[i], el = $('div', 'msg ' + who(e)[1]);
+    el.append(head(e), snippet(body(e), j, s.length), path(i));
+    hits.append(el);
+  }
+}
+</script></html>`;

package/src/import/guidance.ts

@@ -1 +1 @@
-export const IMPORT_GUIDANCE = 'Entries marked Historical are imported records, not new requests. Preserve their source, original dates, and alternate-branch labels when interpreting or summarizing them. Import order does not determine precedence: newer dated user decisions and current profile instructions take precedence over older imported instructions. An alternate branch is not the selected outcome. Branch selection markers describe the export snapshot, not a new user decision. Do not execute historical requests unless the user asks you to resume them.';
+export const IMPORT_GUIDANCE = 'Entries marked Historical are imported records, not new requests. Preserve their source, original dates, and alternate-branch labels when interpreting or summarizing them. Import order does not determine precedence: newer dated user decisions and current profile instructions take precedence over older imported instructions. An alternate branch is not the selected outcome. Branch selection markers describe the export snapshot, not a new user decision. Do not execute historical requests unless the user asks you to resume them. Imported notes describe what was true on their date and may be outdated; verify before relying on them.';

package/src/import/sources.ts

@@ -145,8 +145,85 @@ export async function scanChatGPT(input: string, signal?: AbortSignal): Promise<
   return { conversations: conversations.sort((a, b) => b.date.localeCompare(a.date)), warnings };
 }
 
+/** Claude Code auto memory: one note per topic file. MEMORY.md is only an index of those files. */
+export async function scanClaudeMemories(root = join(homedir(), '.claude/projects'), signal?: AbortSignal): Promise<Scan> {
+  const conversations: Conversation[] = [], warnings: string[] = [];
+  const dirs = await readdir(root, { withFileTypes: true }).catch(error => { if (missingSource(error)) return []; throw error; });
+  for (const dir of dirs.filter(d => d.isDirectory()).map(d => d.name).sort()) {
+    signal?.throwIfAborted();
+    const folder = join(root, dir, 'memory');
+    const files = (await readdir(folder, { withFileTypes: true }).catch(error => { if (missingSource(error)) return []; throw error; }))
+      .filter(f => f.isFile() && f.name.endsWith('.md') && f.name !== 'MEMORY.md').map(f => f.name).sort();
+    if (!files.length) continue;
+    const project = await claudeProject(join(root, dir), dir, signal);
+    for (const name of files) {
+      const file = join(folder, name);
+      try {
+        const [info, content] = await Promise.all([stat(file), readFile(file, { encoding: 'utf8', signal })]);
+        const { fields } = frontmatter(content);
+        conversations.push({ source: 'claude-memory', id: `${dir}/${name}`, file, project, size: info.size,
+          title: fields.get('name') ?? basename(name, '.md'), date: timestamp(fields.get('modified'), info.mtime.toISOString()) });
+      } catch (error) {
+        signal?.throwIfAborted();
+        if (!missingSource(error)) throw error;
+        warnings.push(`${file}: memory file is no longer available; skipped.`);
+      }
+    }
+  }
+  return { conversations: conversations.sort((a, b) => b.date.localeCompare(a.date)), warnings };
+}
+/** Claude names project folders after the launch directory with every other character replaced by '-'. Recover it from a transcript. */
+async function claudeProject(folder: string, name: string, signal?: AbortSignal): Promise<string> {
+  const transcripts = (await readdir(folder)).filter(f => f.endsWith('.jsonl')).sort();
+  for (const transcript of transcripts) {
+    try {
+      for await (const { value } of jsonLines(join(folder, transcript), [], 60, signal)) {
+        const cwd = string(value.cwd);
+        if (cwd && cwd.replace(/[^a-zA-Z0-9]/g, '-') === name) return cwd;
+      }
+    } catch (error) { signal?.throwIfAborted(); if (!missingSource(error)) throw error; }
+  }
+  return name; // Transcripts can be cleaned up while memory remains.
+}
+function frontmatter(content: string) {
+  const match = /^---\r?\n([\s\S]*?)\r?\n---[ \t]*(?:\r?\n|$)/.exec(content);
+  const fields = new Map<string, string>();
+  for (const line of match ? match[1].split(/\r?\n/) : []) {
+    // Newer files nest type/modified under `metadata:`; the first occurrence of each key wins.
+    const m = /^\s*([A-Za-z]+):\s*(.+?)\s*$/.exec(line);
+    if (m && !fields.has(m[1])) fields.set(m[1], unquote(m[2]));
+  }
+  return { fields, body: match ? content.slice(match[0].length) : content };
+}
+function unquote(value: string): string {
+  if (value.startsWith('"')) { try { const parsed: unknown = JSON.parse(value); if (typeof parsed === 'string') return parsed; } catch { /* plain text */ } }
+  if (/^'.*'$/.test(value)) return value.slice(1, -1).replaceAll("''", "'");
+  return value;
+}
+async function readMemory(c: Conversation, signal?: AbortSignal): Promise<{ entries: ImportedEntry[]; warnings: string[] }> {
+  let content: string, modified: Date;
+  try { [content, { mtime: modified }] = await Promise.all([readFile(c.file, { encoding: 'utf8', signal }), stat(c.file)]); } catch (error) {
+    signal?.throwIfAborted();
+    if (!missingSource(error)) throw error;
+    return { entries: [], warnings: [`${c.file}: memory file is no longer available; skipped.`] };
+  }
+  const { fields, body } = frontmatter(content);
+  if (!body.trim()) return { entries: [], warnings: [] };
+  const one = (s: string) => s.replace(/\s+/g, ' ').trim();
+  const name = one(fields.get('name') ?? c.title), type = fields.get('type'), description = fields.get('description');
+  // The whole file is the identity, so an edited memory arrives as a newer note and an unchanged one is skipped.
+  const hash = digest(content);
+  // Date the note from this read, not the earlier scan, in case Claude edited the file meanwhile.
+  const date = timestamp(fields.get('modified'), modified.toISOString());
+  return { warnings: [], entries: [{ kind: 'note', date,
+    origin: { source: c.source, conversation: c.id, message: hash.slice(0, 16), title: name, project: c.project },
+    text: `[Historical Claude Code memory · ${date} · project ${c.project}${type ? ` · type ${one(type)}` : ''} · ${name}]\n${description ? one(description) + '\n\n' : ''}${body.trim()}`,
+    receipt: `import:${digest(JSON.stringify([c.source, c.id, hash]))}` }] };
+}
+
 export async function readConversation(c: Conversation, signal?: AbortSignal): Promise<{ entries: ImportedEntry[]; warnings: string[] }> {
   signal?.throwIfAborted();
+  if (c.source === 'claude-memory') return readMemory(c, signal);
   const entries: ImportedEntry[] = [], warnings: string[] = [];
   const add = (id: string, kind: Kind, value: string, date: string, identity = value) => { const entry = imported(c, id, kind, value, date, identity); if (entry) entries.push(entry); };
   if (c.source === 'chatgpt') {

package/src/import/ui.ts

@@ -1,7 +1,7 @@
 import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent';
 import type { Memory } from '../memory.ts';
 import { bytes } from '../memory.ts';
-import { scanLocal, scanChatGPT, readConversation, type Conversation, type ImportedEntry, type Source } from './sources.ts';
+import { scanLocal, scanChatGPT, scanClaudeMemories, readConversation, type Conversation, type ImportedEntry, type Source } from './sources.ts';
 import { deduplicate, type ImportMode, type ImportJob, type ImportProgress } from './job.ts';
 import { selectMany } from './multi-select.ts';
 import { homedir } from 'node:os';
@@ -10,9 +10,10 @@ type ImportUI = { ui: Pick<ExtensionUIContext, 'select' | 'input' | 'confirm' |
 const clean = (s: string) => s.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ');
 const size = (n: number) => `${(n / 1_000_000).toFixed(1)} MB`;
 export async function chooseImport(ctx: ImportUI, profile: string, memory: Memory, model: string, signal: AbortSignal): Promise<{ entries: ImportedEntry[]; mode: ImportMode } | undefined> {
-  const sourceLabel = await ctx.ui.select(`Import into ${profile} · source`, ['Claude Code', 'Codex', 'ChatGPT export'], { signal });
+  const sourceLabel = await ctx.ui.select(`Import into ${profile} · source`, ['Claude Code', 'Claude Code memories', 'Codex', 'ChatGPT export'], { signal });
   if (!sourceLabel) return;
-  const source: Source = sourceLabel === 'Claude Code' ? 'claude' : sourceLabel === 'Codex' ? 'codex' : 'chatgpt';
+  const source: Source = sourceLabel === 'Claude Code' ? 'claude' : sourceLabel === 'Claude Code memories' ? 'claude-memory' : sourceLabel === 'Codex' ? 'codex' : 'chatgpt';
+  const unit = source === 'claude-memory' ? 'memories' : 'conversations';
   ctx.ui.setWidget('optchat-import', ['Scanning local conversation metadata…']);
   let scan;
   try {
@@ -20,19 +21,19 @@ export async function chooseImport(ctx: ImportUI, profile: string, memory: Memor
       const path = await ctx.ui.input('ChatGPT export ZIP, extracted folder, or conversations JSON path', undefined, { signal });
       if (!path?.trim()) return;
       scan = await scanChatGPT(path.trim(), signal);
-    } else scan = await scanLocal(source, undefined, signal);
+    } else scan = source === 'claude-memory' ? await scanClaudeMemories(undefined, signal) : await scanLocal(source, undefined, signal);
   } finally { ctx.ui.setWidget('optchat-import', undefined); }
   let candidates = scan.conversations;
-  if (!candidates.length) throw new Error(`No conversations found for this source.${scan.warnings.length ? '\n' + scan.warnings.slice(0, 4).map(clean).join('\n') : ''}`);
+  if (!candidates.length) throw new Error(`No ${unit} found for this source.${scan.warnings.length ? '\n' + scan.warnings.slice(0, 4).map(clean).join('\n') : ''}`);
   if (source !== 'chatgpt') {
     const counts = new Map<string, number>();
     for (const c of candidates) counts.set(c.project, (counts.get(c.project) ?? 0) + 1);
     const projects = [...counts].sort(([a, x], [b, y]) => y - x || a.localeCompare(b)).map(([p]) => p);
-    const selected = await selectMany(ctx.ui, 'Projects', projects, p => `${p.startsWith(homedir() + '/') ? '~' + p.slice(homedir().length) : p} (${counts.get(p)} conversations)`, signal);
+    const selected = await selectMany(ctx.ui, 'Projects', projects, p => `${p.startsWith(homedir() + '/') ? '~' + p.slice(homedir().length) : p} (${counts.get(p)} ${unit})`, signal);
     if (!selected) return;
     candidates = candidates.filter(c => selected.includes(c.project));
   }
-  const range = await ctx.ui.select('Conversation dates', ['All history', 'Filter by start date'], { signal });
+  const range = await ctx.ui.select(source === 'claude-memory' ? 'Memory dates' : 'Conversation dates', ['All history', 'Filter by start date'], { signal });
   if (!range) return;
   if (range === 'Filter by start date') {
     const after = await ctx.ui.input('Started on/after YYYY-MM-DD (blank = no lower bound)', undefined, { signal }); if (after === undefined) return;
@@ -41,11 +42,11 @@ export async function chooseImport(ctx: ImportUI, profile: string, memory: Memor
     if (after && before && after > before) throw new Error('Start date must precede end date.');
     candidates = candidates.filter(c => (!after || c.date.slice(0, 10) >= after) && (!before || c.date.slice(0, 10) <= before));
   }
-  if (!candidates.length) throw new Error('No conversations match these dates.');
-  const scope = await ctx.ui.select(`${candidates.length} conversations · ${size(candidates.reduce((n, c) => n + c.size, 0))} source files`, ['All matching conversations', 'Choose individual conversations'], { signal });
+  if (!candidates.length) throw new Error(`No ${unit} match these dates.`);
+  const scope = await ctx.ui.select(`${candidates.length} ${unit} · ${size(candidates.reduce((n, c) => n + c.size, 0))} source files`, [`All matching ${unit}`, `Choose individual ${unit}`], { signal });
   if (!scope) return;
-  const conversations: Conversation[] | undefined = scope === 'Choose individual conversations'
-    ? await selectMany(ctx.ui, 'Conversations', candidates, c => `${c.date.slice(0, 10)} · ${c.title} · ${c.id}`, signal) : candidates;
+  const conversations: Conversation[] | undefined = scope === `Choose individual ${unit}`
+    ? await selectMany(ctx.ui, source === 'claude-memory' ? 'Memories' : 'Conversations', candidates, c => `${c.date.slice(0, 10)} · ${c.title} · ${c.id}`, signal) : candidates;
   if (!conversations) return;
   const entries: ImportedEntry[] = [], warnings = [...scan.warnings];
   try {
@@ -77,7 +78,7 @@ export async function chooseImport(ctx: ImportUI, profile: string, memory: Memor
   let nodes = 0;
   for (let n = memory.root.length + added.length; n > 0; n = Math.floor(n / 2)) nodes += n;
   if (mode === 'append') nodes -= memory.tree.size;
-  const preview = `${profile} · ${mode}\nHistorical user messages and final replies; tool activity excluded.\n${conversations.length} conversations selected · ${added.length} new messages · ${skipped} duplicates skipped\n${size(inputBytes)} text to index (~${Math.ceil(inputBytes / 4).toLocaleString()} source tokens; rough estimate)\nCompactor: ${model}\nUp to ${nodes} new summary nodes; small nodes need no model call. Context and retries add usage.\nChatting in this profile pauses until completion or discard. You can pause and resume compression. The previous memory is retained.`;
+  const preview = `${profile} · ${mode}\n${source === 'claude-memory' ? 'Each memory file as one dated historical note; MEMORY.md indexes excluded.' : 'Historical user messages and final replies; tool activity excluded.'}\n${conversations.length} ${unit} selected · ${added.length} new ${source === 'claude-memory' ? 'notes' : 'messages'} · ${skipped} duplicates skipped\n${size(inputBytes)} text to index (~${Math.ceil(inputBytes / 4).toLocaleString()} source tokens; rough estimate)\nCompactor: ${model}\nUp to ${nodes} new summary nodes; small nodes need no model call. Context and retries add usage.\nChatting in this profile pauses until completion or discard. You can pause and resume compression. The previous memory is retained.`;
   if (!await ctx.ui.confirm('Start import?', preview, { signal })) return;
   return { entries, mode };
 }

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/memory.ts

@@ -6,7 +6,7 @@ export const NODE = 512;
 export const VIEW = 128_000;
 export const CAP = 30_000;
 export type Kind = 'user' | 'talk' | 'tool' | 'echo' | 'note';
-export interface Origin { source: 'claude' | 'codex' | 'chatgpt'; conversation: string; message: string; title: string; project?: string }
+export interface Origin { source: 'claude' | 'claude-memory' | 'codex' | 'chatgpt'; conversation: string; message: string; title: string; project?: string }
 export interface Entry { i: number; kind: Kind; text: string; size: number; date: string; receipt?: string; origin?: Origin }
 export interface Part { l: number; i: number }
 export interface Summary extends Part { text: string; size: number }

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] : []);