pi-optchat 0.7.0 → 0.7.1

package/README.md

@@ -48,6 +48,7 @@ For headless use, pass `--optchat-profile work`.
 | `/optchat agents` | Live agent tree and saved run history. |
 | `/optchat agents model` | Subagent model and effort for this profile. |
 | `/optchat usage` | Token usage and cost estimates. |
+| `/optchat activity` | Memory gauge: view size, summaries catching up, running agents. |
 | `/optchat instructions` | Edit this profile's `AGENTS.md`. |
 | `/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. |
@@ -103,9 +104,9 @@ Ask in plain words, for example: "Spawn an agent to investigate this repository
 - Stopping an agent stops its whole subtree. A failed parent stops its descendants.
 - Agents run inside the Pi process. Closing Pi stops them; there is no detached mode.
 
-## Agents and usage inspector
+## Agents, usage and activity inspector
 
-An **Agents | Usage** bar sits below the input.
+An **Agents | Usage | Activity** bar sits below the input.
 
 | Key | Action |
 | --- | --- |
@@ -113,7 +114,7 @@ An **Agents | Usage** bar sits below the input.
 | **Left/Right**, **Enter** | Pick and open a section |
 | **Escape**, **Up**, or typing | Back to the editor |
 | **F6** | Open Agents directly, keeping your draft |
-| **Tab** | Switch between Agents and Usage |
+| **Tab** | Cycle Agents, Usage and Activity |
 
 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.
 
@@ -123,17 +124,23 @@ Set a different shortcut with `OPTCHAT_INSPECT_KEY=ctrl+shift+a pi`. If another
 
 | Key | Action |
 | --- | --- |
-| **Escape** or **Ctrl+C** | Clear a draft, else back to the main chat |
-| **Ctrl+X** twice | Stop this agent and the agents it started |
+| **Escape** | Clear a draft, else back to the main chat |
+| **Ctrl+C** | Clear a draft, else interrupt the agent's current step. Never ends the agent: queued messages go to it at once and it carries on; with none queued it waits for you (**interrupted · waiting for you**) until your next message, or a `tell` from the main agent, resumes it |
+| **Up** (empty input) | Take your newest queued message back to edit; send it again, or clear it to drop it |
+| **Ctrl+X** twice | Stop this agent and the agents it started (the only key that ends it) |
 | **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.
+Guidance shows as queued until delivered, or undelivered if the child stops first. When you interrupt an agent with nothing queued, the agent that started it gets a one-line note instead of a report, so it isn't left waiting. 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.
 
 **Usage** shows this session, last hour, today, last 7 days, or all time (**Left/Right**): one row per role and model (main agent, subagents, compactor, imports) with estimated cost, share of the total, output tokens, and how much input came from the cache. Costs are API prices, not your subscription bill.
 
 ![Usage page](docs/screenshots/usage.png)
 
+**Activity** is a memory gauge: how many messages the profile holds and how much of the 128 KB view they fill, then either **Settled** or **Catching up · 12 of 40 summaries** with a progress bar counted from when the backlog last grew from empty. If summarizing keeps failing, the last error and the retry countdown show under it. It also counts running agents, and interrupted ones waiting for you; their list is on Agents. While summaries or agents are at work, the bar's Activity item gets a **●**.
+
+![Activity page](docs/screenshots/activity.png)
+
 - Costs are API-rate estimates, not your subscription bill. Unknown rates show zero.
 - Record counts are not request counts; retries and tool overhead can add records.
 - Main-agent tracking starts with v0.3.0 (resumed sessions are backfilled). Older records without a parent session are left out of **This session**.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-optchat",
-  "version": "0.7.0",
+  "version": "0.7.1",
   "type": "module",
   "pi": {
     "extensions": [

package/src/agent-view.ts

@@ -167,6 +167,7 @@ const statusOf = (run: RunInfo, children: Children) => {
   if (!live) return run.state;
   if (run.state === 'stopping') return 'stopping';
   if (run.state === 'waiting') return 'waiting for its agents';
+  if (run.state === 'paused') return 'interrupted · waiting for you';
   const tools = [...live.tools.values()].map(t => t.name);
   return tools.length ? `running ${tools.join(', ')}` : live.streaming ? 'writing' : 'working';
 };
@@ -207,7 +208,9 @@ export class AgentView implements Component, Focusable {
   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 get state() { return this.options.children.live(this.options.id)?.info.state ?? ''; }
+  private get canMessage() { return ['running', 'waiting', 'paused'].includes(this.state); }
+  private get canInterrupt() { return ['running', 'waiting'].includes(this.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 {
@@ -226,12 +229,19 @@ export class AgentView implements Component, Focusable {
     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();
+    const escape = matchesKey(data, 'escape') && !this.editor.isShowingAutocomplete(), interrupt = matchesKey(data, 'ctrl+c');
+    if ((escape || interrupt) && this.editor.getText()) {
       this.editor.setText(''); // First press clears a draft, as in the main editor.
       return this.options.redraw();
     }
-    if (matchesKey(data, 'ctrl+x')) {
+    if (escape || interrupt && !this.canInterrupt) return this.close();
+    // Up on an empty input pulls the newest queued message back to edit: sending it queues the new text, clearing it drops it.
+    const pulled = matchesKey(data, 'up') && !this.editor.getText() && this.canMessage ? children.withdraw(id) : undefined;
+    if (pulled !== undefined) this.editor.setText(pulled);
+    else if (interrupt) {
+      children.interrupt(id).catch((error: unknown) => { this.notice = `Could not interrupt: ${error instanceof Error ? error.message : String(error)}`; })
+        .finally(() => { if (!this.ended) this.options.redraw(); });
+    } else 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;
@@ -287,9 +297,12 @@ export class AgentView implements Component, Focusable {
     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 editable = this.canMessage && run?.guidance.some(g => g.state === 'queued' && g.from === 'user');
+    const keys = [...this.editor.getText() ? ['Esc clear'] : ['Esc back to main', ...this.canInterrupt ? ['Ctrl+C interrupt'] : [], ...editable ? ['↑ edit queued'] : []],
+      ...live ? ['Ctrl+X stop'] : [], ...this.overflow ? [this.back ? 'PgDn newer' : 'PgUp older'] : []];
     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' : ''}`);
+      : color('dim', ` ${keys.join(' · ')}`);
     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.

package/src/agents.ts

@@ -23,6 +23,10 @@ export interface LiveRun {
   session: AgentSession; info: RunInfo; updated: number; streaming?: AgentMessage;
   tools: Map<string, { name: string; args: unknown; output?: unknown; started: number }>;
   pendingReports: string[]; pendingGuidance: string[]; wake?: () => void; completion?: Promise<void>;
+  /** Set by the user's interrupt: the queued guidance the run continues with once its current step is aborted; with none, it pauses. */
+  interruption?: RunInfo['guidance'];
+  /** Messages being steered back into Pi's queue after it was cleared; other queue changes wait for it. */
+  requeueing?: Promise<void>;
   /** Shared by the children of one spawn whose reports are delivered together, in spawn order. */
   batch?: { ids: string[]; reports: Map<string, string> };
 }
@@ -51,6 +55,8 @@ export const taskDirectory = (cwd: string, path = '.', windows = process.platfor
   resolve(cwd, path.replace(windows ? /^~(?=$|[\\/])/ : /^~(?=$|\/)/, homedir()));
 export const CWD_DOC = 'Project directory the subagent works in (~ allowed); its AGENTS.md files load from there. Defaults to your current directory.';
 const isOptchat = (path: string) => packageName(path) === 'pi-optchat';
+/** Pi hands steering to a run only between tool calls, so one long command keeps the parent and the user from reaching it. */
+export const STEERABLE = 'Never block in a single command for more than about 60 seconds. To wait for something, poll in short separate tool calls (for example one `sleep 30` per call), so messages from your parent or the user can reach you between calls.';
 
 // Pi's CLI adds its built-in extensions (MCP, codemode, tool search) to its own session; SDK sessions such as
 // subagents must add them. Pi versions that do not export a factory simply do not get that extension.
@@ -211,7 +217,7 @@ export class Children {
     const { id, directory, depth, parentId, connected } = o;
     const { subagentLevels, maxAgents, memorySearch } = this.settings, delegates = depth < subagentLevels;
     const delegation = delegates ? `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 ${maxAgents} 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_parent for questions or findings the main agent needs now. A handoff will be generated when the user completes or disconnects the window.'
+    const instructions = [this.instructions(), delegation, STEERABLE, 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' });
@@ -260,16 +266,21 @@ export class Children {
         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}.`);
+        if (!await this.toParent(parentId, text)) throw new Error('Your parent is no longer running.');
+        return result(parentId ? `Message sent to parent ${parentId}.` : 'Message sent to the main agent.');
       },
     };
   }
+  /** A mid-run message to a child's parent: false if that parent is no longer running. */
+  private async toParent(parentId: string | undefined, text: string) {
+    if (!parentId) { await this.report(text); return true; }
+    const parent = this.running.get(parentId);
+    if (!parent || !['running', 'waiting', 'paused'].includes(parent.info.state)) return false;
+    if (parent.info.state === 'running') await parent.session.steer(text);
+    else { parent.pendingReports.push(text); parent.wake?.(); } // A paused parent keeps it until the user resumes it.
+    this.changed();
+    return true;
+  }
   private async shutdown(session: AgentSession) {
     try { await session.extensionRunner.emit({ type: 'session_shutdown', reason: 'quit' }); }
     catch (error) { this.warn(`Subagent cleanup failed: ${String(error)}`); }
@@ -287,8 +298,36 @@ export class Children {
       if (this.closing || info.handoff || state === 'stopping') throw new Error('Stopped before its first request.');
       await session.prompt(prompt);
       while (info.state !== 'stopping') {
+        if (live.interruption) {
+          const guidance = live.interruption.filter(g => g.state === 'queued');
+          // Read Pi's queue only once a rebuild has landed, and take the interrupt's messages off it so they arrive once.
+          // Until this is done, tell() holds new messages in pendingGuidance, where the turn below or a pause picks them up.
+          await live.requeueing;
+          const texts = new Set(guidance.map(g => g.text));
+          await this.requeue(live, session.clearQueue().steering.filter(text => !texts.has(text)));
+          live.interruption = undefined;
+          if (!guidance.length) {
+            // Nothing to hand over: the run waits for its next message instead of ending, and whoever waits on its report hears why.
+            if (transition(info, 'paused')) {
+              this.save(info);
+              if (!info.connected) await this.toParent(info.parentId, `[${info.id}] Interrupted by the user; it waits for their next message, so no report until then.`)
+                .catch(error => this.warn(`Could not tell the parent about the interrupt: ${String(error)}`));
+            }
+            continue;
+          }
+          if (!transition(info, 'running')) continue; // A stop during the cleanup wins.
+          for (const g of guidance) g.state = 'delivered';
+          this.save(info);
+          await session.prompt(`Interrupted by the user:\n\n${guidance.map(g => g.text).join('\n\n')}`);
+          continue;
+        }
+        const paused = info.state === 'paused';
+        if (paused && !live.pendingGuidance.length) {
+          await new Promise<void>(resolve => { live.wake = resolve; }); live.wake = undefined;
+          continue;
+        }
         const last = session.messages.findLast(m => m.role === 'assistant');
-        if (last?.role === 'assistant' && (last.stopReason === 'error' || last.stopReason === 'aborted')) break;
+        if (!paused && last?.role === 'assistant' && (last.stopReason === 'error' || last.stopReason === 'aborted')) break;
         if (live.pendingGuidance.length) {
           transition(info, 'running'); this.save(info);
           await session.prompt(live.pendingGuidance.shift()!);
@@ -357,20 +396,66 @@ export class Children {
   async tell(id: string, message: string, source: 'manager' | 'user' = 'manager', caller?: string) {
     const live = this.running.get(id);
     if (!live && source === 'manager' && this.history.records.has(id)) return this.track(this.resume(id, message, caller));
-    if (live && !['running', 'waiting'].includes(live.info.state)) throw new Error(`${id} is finishing. Its report will arrive on its own${live.info.connected || source === 'user' ? '' : '; tell it again after that to resume it'}.`);
+    if (live && !['running', 'waiting', 'paused'].includes(live.info.state)) throw new Error(`${id} is finishing. Its report will arrive on its own${live.info.connected || source === 'user' ? '' : '; tell it again after that to resume it'}.`);
     if (!live) 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', from: source };
     live.info.guidance.push(guidance); this.save(live.info);
     try {
-      if (live.info.state === 'waiting') { live.pendingGuidance.push(text); live.wake?.(); }
-      else await live.session.steer(text);
+      await live.requeueing; // Keeps the queue in the order messages were sent.
+      if (live.info.state === 'running' && !live.interruption) await live.session.steer(text);
+      else { live.pendingGuidance.push(text); live.wake?.(); } // Waiting, paused or being interrupted: this message starts its next turn.
     }
     catch (error) { guidance.state = 'undelivered'; this.save(live.info); throw error; }
     if (guidance.state === 'undelivered') throw new Error(`${id} finished before it read the message. Tell it again to resume it.`);
     return 'Message queued for the next tool boundary.';
   }
+  /**
+   * The user's Ctrl+C, never destructive: aborts the current step. With guidance queued, the run continues at once with it;
+   * with none, it pauses until the next message (from the user or a tell). Only stop() ends a run.
+   */
+  async interrupt(id: string): Promise<'continued' | 'paused'> {
+    const live = this.running.get(id);
+    if (live?.info.state === 'paused') return 'paused';
+    if (!live || !['running', 'waiting'].includes(live.info.state)) throw new Error(`No running subagent ${id}.`);
+    const guidance = live.info.guidance.filter(g => g.state === 'queued');
+    // Nothing yields before the abort starts, so the run cannot finish in between and drop the messages.
+    // They leave pendingGuidance here and Pi's steering queue in execute(), which then sends them in one prompt.
+    const texts = new Set(guidance.map(g => g.text));
+    live.pendingGuidance = live.pendingGuidance.filter(text => !texts.has(text));
+    live.interruption = guidance;
+    live.wake?.();
+    await live.session.abort();
+    return guidance.length ? 'continued' : 'paused';
+  }
+  /** Takes the user's newest undelivered message back off the queue, to edit it; undefined when there is none left to take. */
+  withdraw(id: string) {
+    const live = this.running.get(id);
+    const text = live?.info.guidance.findLast(g => g.state === 'queued' && g.from === 'user')?.text;
+    if (!live || text === undefined || live.requeueing || live.interruption) return undefined;
+    // The queue holds only texts, so of equal ones the last is taken back, record and queue entry alike.
+    const guidance = live.info.guidance.findLast(g => g.state === 'queued' && g.text === text)!;
+    const pending = live.pendingGuidance.lastIndexOf(guidance.text);
+    if (pending >= 0) live.pendingGuidance.splice(pending, 1);
+    else {
+      const steering = live.session.getSteeringMessages();
+      const at = steering.lastIndexOf(guidance.text);
+      if (at < 0) return undefined; // Already on its way to the agent.
+      // Pi cannot drop a single queued message: clear the queue and steer the rest back in order.
+      void this.requeue(live, live.session.clearQueue().steering.filter((_, i) => i !== at));
+    }
+    live.info.guidance.splice(live.info.guidance.indexOf(guidance), 1); this.save(live.info);
+    return guidance.text;
+  }
+  private requeue(live: LiveRun, texts: string[]) {
+    const work: Promise<void> = (async () => {
+      try { for (const text of texts) await live.session.steer(text); }
+      catch (error) { this.warn(`Could not requeue a message for ${live.info.id}: ${String(error)}`); }
+    })().finally(() => { if (live.requeueing === work) live.requeueing = undefined; });
+    live.requeueing = work;
+    return work;
+  }
   /** Reopens a finished child from its saved transcript, same ID, parent and model, and gives it a new message. */
   private async resume(id: string, message: string, caller: string | undefined) {
     const run = this.history.records.get(id)!, text = message.trim();
@@ -380,7 +465,7 @@ export class Children {
     if (run.parentId !== caller) {
       if (!run.parentId) throw new Error(`Only the main agent can resume ${id}.`);
       const parent = this.running.get(run.parentId);
-      throw new Error(parent && ['running', 'waiting'].includes(parent.info.state) ? `Only ${id}'s parent ${run.parentId} can resume it. Ask ${run.parentId} with tell.`
+      throw new Error(parent && ['running', 'waiting', 'paused'].includes(parent.info.state) ? `Only ${id}'s parent ${run.parentId} can resume it. Ask ${run.parentId} with tell.`
         : `Only ${id}'s parent ${run.parentId} can resume it, and that parent is no longer running. Resume ${run.parentId} instead, or spawn a new subagent.`);
     }
     if (this.closing) throw new Error('Profile is closing.');
@@ -399,7 +484,7 @@ export class Children {
       const session = await this.open({ id, directory: run.cwd, depth: run.depth, parentId: run.parentId, connected: false, provider, model, sessionManager: manager });
       // stop() cannot see this child until it is registered, so a parent stopped meanwhile must cancel it here.
       const parent = run.parentId ? this.running.get(run.parentId) : undefined;
-      if (this.closing || run.parentId && (!parent || !['running', 'waiting'].includes(parent.info.state))) {
+      if (this.closing || run.parentId && (!parent || !['running', 'waiting', 'paused'].includes(parent.info.state))) {
         await this.shutdown(session); this.dispose(session); throw new Error('Parent or profile is stopping.');
       }
       // The finished record stays untouched (and resumable) unless the new one is saved.

package/src/index.ts

@@ -176,7 +176,7 @@ export default function optchat(pi: ExtensionAPI) {
       atomicWrite(pending, JSON.stringify(reports));
       rememberProfile(name);
       active = { name, dir, config, memory, inbox, children, usage, unlock }; fault = undefined;
-      if (ctx.mode === 'tui') unmountNavigation = mountNavigation(ctx, children, shortcut, page => { void inspect(ctx, page); });
+      if (ctx.mode === 'tui') unmountNavigation = mountNavigation(ctx, children, memory, shortcut, page => { void inspect(ctx, page); });
       closeWindows = await serveWindows(dir, children, () => !stopping && !importing && !pendingImport(dir), deliverReport);
       untitle = children.subscribe(() => showTitle(ctx)); showTitle(ctx);
       status(ctx);
@@ -381,7 +381,7 @@ export default function optchat(pi: ExtensionAPI) {
       if (importing) throw new Error('Close the import dialog before opening the inspector.');
       inspectorController = controller;
       const signal = inspectorController.signal;
-      const action = await showInspector(ctx, { profile: a.name, session: ctx.sessionManager.getSessionId(), children: a.children, usage: a.usage, page, signal,
+      const action = await showInspector(ctx, { profile: a.name, session: ctx.sessionManager.getSessionId(), children: a.children, usage: a.usage, memory: a.memory, page, signal,
         refreshUsage: () => { collectUsage(ctx); try { a.children.collectUsage(); } catch (error) { ctx.ui.notify(`Could not save child usage: ${errorText(error)}`, 'error'); } },
       });
       if (signal.aborted) return;
@@ -390,7 +390,7 @@ export default function optchat(pi: ExtensionAPI) {
     } catch (error) { ctx.ui.notify(errorText(error), 'error'); }
     finally { if (inspectorController === controller) inspectorController = undefined; }
   };
-  pi.registerShortcut(shortcut, { description: 'Inspect OptChat agents and usage', handler: ctx => inspect(ctx, 'agents') });
+  pi.registerShortcut(shortcut, { description: 'Inspect OptChat agents, usage and background activity', handler: ctx => inspect(ctx, 'agents') });
   const command = async (args: string, ctx: ExtensionCommandContext): Promise<void> => {
     if (remote) { ctx.ui.notify('Manage this profile in its original window. Here use /tell-main or /complete.', 'info'); return; }
     if (importing) throw new Error('Close the import dialog before changing profile settings.');
@@ -398,7 +398,7 @@ export default function optchat(pi: ExtensionAPI) {
     if (!action) {
       const a = active;
       const info = a ? `${a.name} · ${a.memory.root.length} messages · ${a.memory.pending} pending\nCompactor: ${a.config.compactor.model} (${a.config.compactor.thinking})\nAgents: ${a.config.subagent.model} (${a.config.subagent.thinking})\n${a.memory.lastError ?? ''}` : 'No active profile';
-      action = await ctx.ui.select(`OptChat\n${info}`, ['profile', 'settings', 'model', 'agents', 'usage', 'instructions', 'browse', 'import']) ?? '';
+      action = await ctx.ui.select(`OptChat\n${info}`, ['profile', 'settings', 'model', 'agents', 'usage', 'activity', 'instructions', 'browse', 'import']) ?? '';
     }
     if (action === 'import') {
       const a = required();
@@ -456,7 +456,7 @@ export default function optchat(pi: ExtensionAPI) {
     }
     if (action === 'model') return pickModel(ctx, 'compactor');
     if (action === 'agents model') return pickModel(ctx, 'subagent');
-    if (action === 'agents' || action === 'usage') return inspect(ctx, action);
+    if (action === 'agents' || action === 'usage' || action === 'activity') return inspect(ctx, action);
     if (action === 'instructions') {
       const a = required();
       const edited = await ctx.ui.editor(`${a.name} · AGENTS.md`, instructions(a.dir));
@@ -468,7 +468,7 @@ export default function optchat(pi: ExtensionAPI) {
       if (ctx.hasUI) execFile(process.platform === 'darwin' ? 'open' : 'xdg-open', [file], error => { if (error) ctx.ui.notify(`Open ${file}`, 'info'); });
       ctx.ui.notify(file, 'info'); return;
     }
-    if (action) throw new Error('Use /optchat [profile|settings|model|agents|usage|instructions|browse|import].');
+    if (action) throw new Error('Use /optchat [profile|settings|model|agents|usage|activity|instructions|browse|import].');
   };
   pi.registerCommand('complete', { description: 'End this connected conversation and hand off to the main agent', handler: async (_args, ctx) => {
     if (!remote) { ctx.ui.notify('/complete is for connected subagent windows.', 'info'); return; }
@@ -479,7 +479,7 @@ export default function optchat(pi: ExtensionAPI) {
     try { await remote.tell(args); } catch (error) { ctx.ui.notify(errorText(error), 'error'); }
   } });
   pi.registerCommand('optchat', { description: 'OptChat profiles, settings, models, agents, instructions, memory browser, and imports',
-    getArgumentCompletions: prefix => ['profile', 'settings', 'model', 'agents', 'agents model', 'usage', 'instructions', 'browse', 'import'].filter(s => s.startsWith(prefix)).map(value => ({ value, label: value })),
+    getArgumentCompletions: prefix => ['profile', 'settings', 'model', 'agents', 'agents model', 'usage', 'activity', 'instructions', 'browse', 'import'].filter(s => s.startsWith(prefix)).map(value => ({ value, label: value })),
     handler: async (args, ctx) => { try { await command(args, ctx); } catch (error) { ctx.ui.notify(errorText(error), 'error'); } },
   });
 }

package/src/inspector.ts

@@ -1,7 +1,8 @@
 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 { Children } from './agents.ts';
-import { isActiveRun } from './runs.ts';
+import type { Memory } from './memory.ts';
+import { isActiveRun, isRunning } from './runs.ts';
 import type { Usage } from '@earendil-works/pi-ai';
 import { ranges, summarizeUsage, type UsageLedger, type UsageRange, type UsageRole } from './usage.ts';
 
@@ -32,12 +33,16 @@ const spread = (left: string, right: string, width: number) => {
   const gap = width - visibleWidth(left) - visibleWidth(right);
   return gap >= 2 ? `${left}${' '.repeat(gap)}${right}` : left;
 };
-export type InspectorPage = 'agents' | 'usage';
+const pages = ['agents', 'usage', 'activity'] as const;
+export type InspectorPage = typeof pages[number];
+const pageNames: Record<InspectorPage, string> = { agents: 'Agents', usage: 'Usage', activity: 'Activity' };
+/** Tab order, wrapping around: Agents, Usage, Activity. */
+export const nextPage = (page: InspectorPage, delta = 1) => pages[(pages.indexOf(page) + delta + pages.length) % pages.length];
 /** 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' | 'warning' | 'border';
 interface Options {
-  profile: string; session: string; children: Children; usage: UsageLedger; page: InspectorPage;
+  profile: string; session: string; children: Children; usage: UsageLedger; memory: Pick<Memory, 'root' | 'size' | 'budget' | 'lastError' | 'progress' | 'onChange'>; page: InspectorPage;
   rows: () => number; redraw: () => void; done: (action?: InspectorAction) => void;
   color: (tone: Tone, text: string) => string;
   context: () => number | null | undefined;
@@ -56,12 +61,12 @@ export class Inspector implements Component, Focusable {
   private hintLines = 1;
   private range: UsageRange = 'This session';
   private ended = false;
-  private readonly unsubscribe: () => void;
+  private readonly unsubscribe: (() => void)[];
   private readonly timer: ReturnType<typeof setInterval>;
   constructor(private readonly options: Options) {
     this.page = options.page;
     this.selected = options.children.history.list()[0]?.id;
-    this.unsubscribe = options.children.subscribe(() => options.redraw());
+    this.unsubscribe = [options.children.subscribe(() => options.redraw()), options.memory.onChange(() => options.redraw())];
     this.timer = setInterval(() => { options.refreshUsage?.(); options.redraw(); }, 1000); this.timer.unref();
     options.signal?.addEventListener('abort', this.abort, { once: true });
     if (options.signal?.aborted) queueMicrotask(this.abort);
@@ -69,7 +74,7 @@ export class Inspector implements Component, Focusable {
   private readonly abort = () => this.finish();
   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);
+    this.ended = true; clearInterval(this.timer); this.unsubscribe.forEach(stop => stop()); this.options.signal?.removeEventListener('abort', this.abort);
   }
   invalidate() {}
   /** Body rows left after the rules, title, hint and spacing; the rest of the screen keeps the footer visible. */
@@ -82,9 +87,10 @@ export class Inspector implements Component, Focusable {
   handleInput(data: string) {
     if (this.ended) return;
     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, 'tab')) {
+      this.page = nextPage(this.page); this.scroll = 0;
+    } else if (this.page === 'activity') this.scrollInput(data);
+    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;
@@ -137,17 +143,29 @@ export class Inspector implements Component, Focusable {
     lines.push('', color('dim', 'Estimated at API prices, not your subscription bill.'), ...usage.warnings.map(w => color('warning', w)));
     return lines.flatMap(l => l ? wrapTextWithAnsi(l, width) : ['']);
   }
+  /** Memory as a gauge: how full the view is, whether summaries are catching up, and how many agents run (their list is one Tab away). */
+  private activityLines(width: number) {
+    const { memory, children, color } = this.options;
+    const { done, total, retryIn } = memory.progress();
+    const list = children.history.list(), agents = list.filter(isRunning).length, paused = list.filter(r => r.state === 'paused').length;
+    const filled = total ? Math.floor(10 * done / total) : 0;
+    const lines = [`${color('muted', 'Memory')} · ${count(memory.root.length)} messages · view ${Math.round(memory.size / 1000)} KB / ${Math.round(memory.budget / 1000)} KB`,
+      total ? `Catching up · ${count(done)} of ${count(total)} summaries  ${color('accent', '█'.repeat(filled))}${color('dim', '░'.repeat(10 - filled))}` : color('dim', 'Settled')];
+    if (memory.lastError) lines.push(color('dim', `${oneLine(memory.lastError)}${retryIn === undefined ? '' : ` · retry in ${elapsed(retryIn)}`}`));
+    lines.push('', `${color('muted', 'Agents')} · ${agents} running${paused ? ` · ${paused} interrupted` : ''}`);
+    return lines.flatMap(l => l ? wrapTextWithAnsi(l, width) : ['']);
+  }
   render(width: number): string[] {
     const { color, children, profile } = this.options;
     const inner = Math.max(1, width - 2);
-    let title = `OptChat · ${profile} · ${this.page === 'usage' ? 'Usage' : 'Agents'}`;
+    let title = `OptChat · ${profile} · ${pageNames[this.page]}`;
     let info: string, body: string[], hint: string;
-    if (this.page === 'usage') {
-      const lines = this.usageLines(inner); this.lineCount = lines.length;
+    if (this.page !== 'agents') {
+      const lines = this.page === 'usage' ? this.usageLines(inner) : this.activityLines(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}`;
-      hint = '←→ period · ↑↓ scroll · Tab agents · Esc close';
+      info = this.page === 'usage' || lines.length > this.height ? `${this.scroll + 1}–${Math.min(this.scroll + this.height, lines.length)} / ${lines.length}` : '';
+      hint = this.page === 'usage' ? '←→ period · ↑↓ scroll · Tab activity · Esc close' : '↑↓ scroll · Tab agents · Esc close';
     } else {
       const list = children.history.list();
       if (!this.selected) this.selected = list[0]?.id;
@@ -157,7 +175,7 @@ export class Inspector implements Component, Focusable {
       if (cursor >= this.top + this.height) this.top = cursor - this.height + 1;
       const rows = list.slice(this.top, this.top + this.height).map(run => {
         const live = children.live(run.id), tools = live ? [...live.tools.values()].map(t => t.name).join(', ') : '';
-        const status = live ? `${run.state === 'stopping' ? 'stopping' : run.state === 'waiting' ? 'waiting for children' : tools || (live.streaming ? 'responding' : 'working')} · ${elapsed(Date.now() - live.updated)} ago` : run.state;
+        const status = live ? `${run.state === 'stopping' ? 'stopping' : run.state === 'waiting' ? 'waiting for children' : run.state === 'paused' ? 'interrupted · waiting for you' : tools || (live.streaming ? 'responding' : 'working')} · ${elapsed(Date.now() - live.updated)} ago` : run.state;
         return { run, task: `${'  '.repeat(run.depth - 1)}${run.parentId ? '↳ ' : ''}${oneLine(run.task)}`, status, time: elapsed((run.ended ?? Date.now()) - run.started) };
       });
       // Columns: task (flexible) · status · duration (right-aligned); status yields first on narrow screens.

package/src/memory.ts

@@ -89,6 +89,8 @@ export class Memory {
   /** Per level, every node below this index is built. */
   private readonly low: number[] = [];
   private retryTimer?: ReturnType<typeof setTimeout>;
+  /** The most summaries owed at once since none were last owed. */
+  private peak = 0;
   private scheduled = false;
   private stopped = false;
   lastError?: string;
@@ -134,6 +136,13 @@ export class Memory {
   get pending() { return this.root.length - this.leaves; }
   get active() { return this.busy.size; }
   get size() { return this.viewBytes; }
+  /** Summaries built out of the backlog since it was last empty, and when the next failed one is retried. */
+  progress(now = Date.now()) {
+    const due = Math.min(...[...this.retryAt.values()].filter(t => t > now));
+    return { done: this.peak - this.owed(), total: this.peak, retryIn: Number.isFinite(due) ? due - now : undefined };
+  }
+  private owed() { return this.expectedNodes() - this.tree.size; }
+  onChange(listener: () => void) { this.events.on('change', listener); return () => { this.events.off('change', listener); }; }
   /** The view line covering message `at`. The view tiles the log in order, so a binary search finds it. */
   covering(at: number): Part | undefined {
     for (let lo = 0, hi = this.view.length - 1; lo <= hi;) {
@@ -159,6 +168,8 @@ export class Memory {
       this.viewBytes += this.partBytes(parent) - this.partBytes(a) - this.partBytes(b);
       this.view.splice(best, 2, parent);
     }
+    const owed = this.owed();
+    this.peak = owed > 0 ? Math.max(this.peak, owed) : 0;
     this.events.emit('change');
   }
   private schedule() {

package/src/navigation.ts

@@ -1,8 +1,9 @@
 import { CustomEditor, type ExtensionContext } from '@earendil-works/pi-coding-agent';
 import { matchesKey, truncateToWidth, visibleWidth, type KeyId } from '@earendil-works/pi-tui';
 import type { Children } from './agents.ts';
-import { inspectorShowing, type InspectorPage } from './inspector.ts';
-import { isActiveRun } from './runs.ts';
+import type { Memory } from './memory.ts';
+import { inspectorShowing, nextPage, type InspectorPage } from './inspector.ts';
+import { isRunning } from './runs.ts';
 
 /** Configured before extension registration; this also works in legacy terminals with F6. */
 export function inspectorShortcut(value = process.env.OPTCHAT_INSPECT_KEY ?? 'f6'): KeyId {
@@ -22,7 +23,7 @@ export class BarNavigation {
     }
     if (matchesKey(data, 'escape') || matchesKey(data, 'up')) { this.selected = undefined; return true; }
     if (matchesKey(data, 'left') || matchesKey(data, 'right') || matchesKey(data, 'tab')) {
-      this.selected = this.selected === 'agents' ? 'usage' : 'agents'; return true;
+      this.selected = nextPage(this.selected, matchesKey(data, 'left') ? -1 : 1); return true;
     }
     if (matchesKey(data, 'return')) { const page = this.selected; this.selected = undefined; open(page); return true; }
     if (matchesKey(data, 'down')) return true;
@@ -30,7 +31,7 @@ export class BarNavigation {
   }
 }
 
-export function mountNavigation(ctx: ExtensionContext, children: Children, shortcut: string, open: (page: InspectorPage) => void) {
+export function mountNavigation(ctx: ExtensionContext, children: Children, memory: Pick<Memory, 'progress' | 'onChange'>, shortcut: string, open: (page: InspectorPage) => void) {
   const navigation = new BarNavigation();
   const previous = ctx.ui.getEditorComponent();
   let redraw = () => {};
@@ -51,18 +52,18 @@ export function mountNavigation(ctx: ExtensionContext, children: Children, short
       invalidate() {},
       render(width: number) {
         if (inspectorShowing()) return []; // The open panel replaces the editor and this bar.
-        const list = children.history.list(), running = list.filter(isActiveRun).length;
+        const list = children.history.list(), running = list.filter(isRunning).length, paused = list.filter(r => r.state === 'paused').length;
         const label = (page: InspectorPage, text: string) => navigation.selected === page ? theme.fg('accent', `› ${text}`) : theme.fg('muted', text);
-        const left = `${label('agents', `Agents: ${running} running · ${list.length - running} saved`)}   ${label('usage', 'Usage')}`;
+        const left = `${label('agents', `Agents: ${running} running${paused ? ` · ${paused} interrupted` : ''} · ${list.length - running - paused} saved`)}   ${label('usage', 'Usage')}   ${memory.progress().total || running ? theme.fg('accent', '● ') : ''}${label('activity', 'Activity')}`;
         const hint = theme.fg('dim', navigation.selected ? '←→ select · Enter open · Esc input' : `${previous ? '' : '↓ select · '}${shortcut} inspect`);
         const gap = width - visibleWidth(left) - visibleWidth(hint);
         return [truncateToWidth(gap >= 3 ? `${left}${' '.repeat(gap)}${hint}` : `${left}   ${hint}`, width)];
       },
     };
   }, { placement: 'belowEditor' });
-  const unsubscribe = children.subscribe(() => redraw());
+  const unsubscribe = [children.subscribe(() => redraw()), memory.onChange(() => redraw())];
   return () => {
-    unsubscribe(); ctx.ui.setWidget('optchat-agents', undefined);
+    unsubscribe.forEach(stop => stop()); ctx.ui.setWidget('optchat-agents', undefined);
     if (!previous && ctx.ui.getEditorComponent() === factory) ctx.ui.setEditorComponent(undefined);
   };
 }

package/src/runs.ts

@@ -6,7 +6,8 @@ import { atomicWrite } from './profiles.ts';
 import { record } from './cache.ts';
 import { textContent } from './transcript.ts';
 
-export const runStates = ['running', 'waiting', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'] as const;
+/** `paused`: interrupted by the user with nothing queued, alive and waiting for its next message. `interrupted` is a finished run cut off by Pi closing or a connected window ending. */
+export const runStates = ['running', 'waiting', 'stopping', 'completed', 'failed', 'stopped', 'interrupted', 'paused'] as const;
 export type RunState = typeof runStates[number];
 export type FinishReason = 'complete' | 'disconnected' | 'owner-stopped' | 'failed';
 export interface RunInfo {
@@ -20,8 +21,9 @@ export interface RunInfo {
   guidance: { text: string; date: number; state: 'queued' | 'delivered' | 'undelivered'; from?: 'user' | 'manager' }[];
 }
 const moves: Record<RunState, readonly RunState[]> = {
-  running: ['waiting', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'],
-  waiting: ['running', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'],
+  running: ['waiting', 'paused', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'],
+  waiting: ['running', 'paused', 'stopping', 'completed', 'failed', 'stopped', 'interrupted'],
+  paused: ['running', 'stopping', 'failed', 'stopped', 'interrupted'],
   stopping: ['stopped', 'failed', 'interrupted'],
   // A finished run only takes the outcome of a connected handoff.
   completed: ['interrupted'], failed: ['completed', 'interrupted'], stopped: ['completed', 'interrupted'], interrupted: ['completed'],
@@ -31,7 +33,9 @@ export function transition(run: RunInfo, to: RunState) {
   if (run.state !== to && !moves[run.state].includes(to)) return false;
   run.state = to; return true;
 }
-export const isActiveRun = (run: RunInfo) => run.state === 'running' || run.state === 'waiting' || run.state === 'stopping';
+export const isActiveRun = (run: RunInfo) => run.state === 'running' || run.state === 'waiting' || run.state === 'stopping' || run.state === 'paused';
+/** Live and working: a paused run is neither running nor finished. */
+export const isRunning = (run: RunInfo) => isActiveRun(run) && run.state !== 'paused';
 function isRun(value: unknown): value is RunInfo {
   return record(value) && ['id', 'task', 'cwd', 'model', 'thinking', 'parentSession'].every(k => typeof value[k] === 'string')
     && typeof value.id === 'string' && /^[a-zA-Z0-9-]+$/.test(value.id)