pi-optchat 0.8.5 → 0.8.7

package/src/inspector.ts

@@ -2,7 +2,7 @@ import { matchesKey, sliceByColumn, truncateToWidth, visibleWidth, wrapTextWithA
 import type { ExtensionContext } from '@earendil-works/pi-coding-agent';
 import type { Children } from './agents.ts';
 import type { Memory } from './memory.ts';
-import { isActiveRun, isRunning } from './runs.ts';
+import { isActiveRun, isHandingOff, isRunning } from './runs.ts';
 import type { Usage } from '@earendil-works/pi-ai';
 import { ranges, summarizeUsage, type UsageLedger, type UsageRange, type UsageRole } from './usage.ts';
 
@@ -162,12 +162,12 @@ export class Inspector implements Component, Focusable {
   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 list = children.history.list(), agents = list.filter(isRunning).length, paused = list.filter(r => r.state === 'paused').length, handingOff = list.filter(isHandingOff).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` : ''}`);
+    lines.push('', `${color('muted', 'Agents')} · ${agents} running${paused ? ` · ${paused} interrupted` : ''}${handingOff ? ` · ${handingOff} handing off` : ''}`);
     return lines.flatMap(l => l ? wrapTextWithAnsi(l, width) : ['']);
   }
   render(width: number): string[] {
@@ -190,7 +190,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' : run.state === 'paused' ? 'interrupted · waiting for you' : 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` : isHandingOff(run) ? 'handing off' : 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

@@ -4,6 +4,8 @@ import { FileStore, storeFor, type Saved, type Store } from './store.ts';
 export const NODE = 512;
 export const VIEW = 128_000;
 export const CAP = 30_000;
+/** The most characters of one message a leaf sends the compactor, so a huge paste can't overflow it; zoom still pages through all of it. */
+export const SOURCE = 100_000;
 /** The most characters one zoom into a message returns, so a page stays under the tool output CAP instead of losing its middle. */
 export const PAGE = 25_000;
 export const KINDS = ['user', 'talk', 'tool', 'echo', 'note', 'work'] as const;
@@ -16,13 +18,19 @@ export interface Summary extends Part { text: string; size: number }
  * answers, raw, since its own line is often not built yet (#153). */
 export interface Compression { context: string; source: string; part: Part; historical?: boolean; call?: { i: number; text: string } }
 export type Compressor = (input: Compression, signal: AbortSignal) => Promise<string>;
+/** A compressor throws this when the model itself gives no line for an input (a refusal, an empty reply, 5 cut-off replies):
+ * asked again it fails alike, so the node keeps the start of its source instead of being retried forever (#193). */
+export class Refused extends Error {}
 const key = ({ l, i }: Part) => l * 2 ** 40 + i;
 const UNBUILT = '(not summarized yet: zoom it)';
+const CLIPPED = '(not summarized: zoom it)';
 export const start = ({ l, i }: Part) => i * 2 ** l;
 export const end = (part: Part) => start(part) + 2 ** part.l;
 export const bytes = (s: string) => Buffer.byteLength(s, 'utf8');
 const UNBUILT_BYTES = bytes(UNBUILT);
 export const flat = (s: string) => s.replace(/[\r\n]+/g, ' ');
+/** The first NODE bytes, without a split character at the end. */
+export const cut = (s: string) => Buffer.from(s).subarray(0, NODE).toString('utf8').replace(/\uFFFD+$/, '');
 const lineBytes = (s: string) => bytes(flat(s));
 const notice = (omitted: number) => `\n[${omitted} characters omitted; head and tail retained]\n`;
 const VIEW_OPEN = '<chat>\n';
@@ -130,7 +138,7 @@ export class Memory {
     return new Memory({ directory, store, saved: await store.load() }, compress, warn, budget, jobs);
   }
   /** A directory alone opens a FileStore there. `jobs`: summaries built at once, and how many unbuilt lines a new message's node
-   * waits behind. Chat keeps 8; imports pass the "Import: summaries at once" setting. */
+   * waits behind. Chat and imports pass the "Summaries at once" setting. */
   constructor(source: string | { directory: string; store: Store; saved: Saved }, private readonly compress: Compressor,
     private readonly warn: (s: string) => void = console.error,
     readonly budget = VIEW, private readonly jobs = 8, private readonly retryMs = 10_000) {
@@ -150,10 +158,8 @@ export class Memory {
     }
     for (const node of this.tree.values()) this.queueParent(node);
     for (let i = 0; i < this.root.length; i++) if (!this.node({ l: 0, i })) this.unbuilt.add(i);
-    // Refolding the log gives a different view than the live one, and every cache entry would miss, so the view is saved.
+    // Refolding the log gives different views than the live ones, and every cache entry would miss, so the views are saved.
     const loaded = this.load(saved.view);
-    for (const part of this.view) this.compaction.push(part);
-    this.compaction.fit(loaded, true);
     for (let i = loaded; i < this.root.length; i++) { this.push(i); this.fit(i + 1); }
     this.fit(); this.save(); this.schedule();
   }
@@ -182,33 +188,43 @@ export class Memory {
     this.writing = tail;
     return settled;
   }
-  /** Takes the saved view if it still tiles the log from the start, and returns how many messages it covers. */
+  /** Takes the saved views if they still tile the log from the start, and returns how many messages they cover. */
   private load(view: string | undefined) {
     if (view === undefined) return 0;
-    const rebuild = () => { this.warn('Rebuilt the memory view: the saved one does not match the log.'); return 0; };
     let saved: unknown;
-    try { saved = JSON.parse(view); } catch { return rebuild(); }
+    try { saved = JSON.parse(view); } catch { saved = undefined; }
+    const chat = this.tiling(saved);
+    if (!chat) { this.warn('Rebuilt the memory view: the saved one does not match the log.'); return 0; }
+    for (const part of chat.parts) this.chat.push(part);
+    this.chat.merging = chat.merging;
+    // An older view.json has only the chat's view: the compactions' is refolded from it, a cold prefix once.
+    const compaction = object(saved) ? this.tiling(saved.compaction) : undefined;
+    if (compaction?.covered === chat.covered) { for (const part of compaction.parts) this.compaction.push(part); this.compaction.merging = compaction.merging; }
+    else { for (const part of chat.parts) this.compaction.push(part); this.compaction.fit(chat.covered, true); }
+    return chat.covered;
+  }
+  /** A saved view, `{ parts, merging }` or an older bare list of parts, if it tiles the log from the start. */
+  private tiling(saved: unknown) {
     const merging = object(saved) && saved.merging === true;
     if (object(saved) && typeof saved.merging === 'boolean') saved = saved.parts;
-    if (!Array.isArray(saved)) return rebuild();
+    if (!Array.isArray(saved)) return;
     const parts: Part[] = [];
     let covered = 0;
     for (const value of saved) {
       const [l, i] = Array.isArray(value) ? value : [];
       const part = { l, i };
       if (!Number.isSafeInteger(l) || !Number.isSafeInteger(i) || l < 0 || start(part) !== covered || end(part) > this.root.length || (l > 0 && !this.node(part)))
-        return rebuild();
+        return;
       parts.push(part); covered = end(part);
     }
-    for (const part of parts) this.chat.push(part);
-    this.chat.merging = merging;
-    return covered;
+    return { parts, merging, covered };
   }
-  /** Saved when it merges or changes batch state: a view that only grew is the saved one plus later messages, as `load` replays it.
-   * The log stays authoritative, so a failed save only warns. */
+  /** Saved when either view merges or changes batch state: a view that only grew is the saved one plus later messages, as `load`
+   * replays it. The log stays authoritative, so a failed save only warns. */
   private save() {
     const failed = (error: unknown) => { this.warn(`Could not save the memory view: ${error instanceof Error ? error.message : String(error)}`); };
-    try { void this.enqueue(() => this.store.saveView(JSON.stringify({ parts: this.view.map(p => [p.l, p.i]), merging: this.chat.merging })), failed); }
+    const saved = ({ parts, merging }: Sawtooth) => ({ parts: parts.map(p => [p.l, p.i]), merging });
+    try { void this.enqueue(() => this.store.saveView(JSON.stringify({ ...saved(this.chat), compaction: saved(this.compaction) })), failed); }
     catch (error) { failed(error); }
   }
   private push(i: number) {
@@ -231,15 +247,15 @@ export class Memory {
   onChange(listener: () => void) { this.events.on('change', listener); return () => { this.events.off('change', listener); }; }
   /** The view line covering message `at`. */
   covering(at: number) { return this.chat.covering(at); }
-  /** Returns whether the chat's view or batch state changed. */
+  /** Returns whether either view, or its batch state, changed. */
   private fit(total = this.root.length) {
-    const merging = this.chat.merging;
+    const merging = [this.chat.merging, this.compaction.merging];
     const merged = this.chat.fit(total);
-    this.compaction.fit(total, merged);
+    const compacted = this.compaction.fit(total, merged);
     const owed = this.owed();
     this.peak = owed > 0 ? Math.max(this.peak, owed) : 0;
     this.events.emit('change');
-    return merged || merging !== this.chat.merging;
+    return merged || compacted || merging[0] !== this.chat.merging || merging[1] !== this.compaction.merging;
   }
   private schedule() {
     if (this.scheduled || this.stopped) return;
@@ -286,11 +302,18 @@ export class Memory {
       : [0, 1].map(offset => this.text({ l: part.l - 1, i: 2 * part.i + offset })).join('\n');
     const mergeSource = part.l > 0 ? [0, 1].map(offset => flat(this.text({ l: part.l - 1, i: 2 * part.i + offset }))).join('\n') : source;
     const call = part.l === 0 ? this.callOf(part.i) : undefined;
-    const text = bytes(source) <= NODE ? source : (await this.compress({ context: this.compactionView(part), source: mergeSource, part,
-      historical: this.root.slice(start(part), end(part)).some(entry => !!entry.origin),
-      ...(call ? { call: { i: call.i, text: cap(`tool: ${call.text}`, 4000) } } : {}) }, this.controller.signal)).trim();
+    let text = source;
+    if (bytes(source) > NODE) try {
+      text = (await this.compress({ context: this.compactionView(part), source: cap(mergeSource, SOURCE), part,
+        historical: this.root.slice(start(part), end(part)).some(entry => !!entry.origin),
+        ...(call ? { call: { i: call.i, text: cap(`tool: ${call.text}`, 4000) } } : {}) }, this.controller.signal)).trim();
+      if (!text) throw new Refused('Compactor returned an empty summary.');
+    } catch (error) {
+      if (!(error instanceof Refused) || this.stopped) throw error;
+      text = cut(`${CLIPPED} ${flat(mergeSource)}`);
+      this.warn(`Compactor ${start(part)}+${2 ** part.l}: ${error.message} (kept its start instead)`);
+    }
     if (this.stopped) return;
-    if (!text) throw new Error('Compactor returned an empty summary.');
     const node = { ...part, text, size: lineBytes(text) };
     // A failed node write fails the build, which is retried.
     const written = this.enqueue(() => this.store.appendNode(node), error => { throw error; });
@@ -349,7 +372,7 @@ export class Memory {
    * Paging a message that fits in one page is allowed, but the page says so. */
   zoom(id: number, n: number, offset?: number, limit?: number) {
     if (!Number.isSafeInteger(id) || id < 0 || !Number.isSafeInteger(n) || n < 1 || !Number.isInteger(Math.log2(n)) || id % n || id + n > this.root.length)
-      throw new Error(`No line ${id}+${n}.`);
+      throw new Error(`No line ${id}+${n}: n is a power of 2, id a multiple of n. The tree's roots: ${this.roots() || 'none, the chat is empty'}.`);
     if (n === 1) {
       const { kind, text } = this.root[id], page = Math.min(limit ?? PAGE, PAGE);
       if (!Number.isSafeInteger(page) || page < 1) throw new Error('limit must be a positive integer.');
@@ -366,12 +389,19 @@ export class Memory {
     }
     if (offset !== undefined) throw new Error('offset and limit page one message: use them with n = 1.');
     const l = Math.log2(n) - 1, i = 2 * id / n;
+    // A half not built yet shows as in the view, so the other half still comes back.
     return [0, 1].map(offset => {
-      const part = { l, i: i + offset }, node = this.node(part);
-      if (!node) throw new Error('This range is not summarized yet.');
-      return `${start(part)}+${2 ** l}|${flat(node.text)}`;
+      const part = { l, i: i + offset };
+      return `${start(part)}+${2 ** l}|${flat(this.text(part))}`;
     }).join('\n');
   }
+  /** The largest whole lines covering the chat, oldest first: one per power of two in the message count. */
+  private roots() {
+    const lines: string[] = [];
+    for (let id = 0, n = 2 ** Math.floor(Math.log2(this.root.length || 1)); n >= 1; n /= 2)
+      if (id + n <= this.root.length) { lines.push(`${id}+${n}`); id += n; }
+    return lines.join(', ');
+  }
   /** Original messages containing `text`, ignoring case, newest first, older than message `before`. Never summaries,
    * nor the logged zoom/search calls and results, which only copy memory. */
   search(text: string, before = this.root.length) {

package/src/navigation.ts

@@ -3,7 +3,7 @@ import { matchesKey, truncateToWidth, visibleWidth, type KeyId } from '@earendil
 import type { Children } from './agents.ts';
 import type { Memory } from './memory.ts';
 import { inspectorShowing, nextPage, type InspectorPage } from './inspector.ts';
-import { isRunning } from './runs.ts';
+import { isHandingOff, 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 {
@@ -52,9 +52,9 @@ export function mountNavigation(ctx: ExtensionContext, children: Children, memor
       invalidate() {},
       render(width: number) {
         if (inspectorShowing()) return []; // The open panel replaces the editor and this bar.
-        const list = children.history.list(), running = list.filter(isRunning).length, paused = list.filter(r => r.state === 'paused').length;
+        const list = children.history.list(), running = list.filter(isRunning).length, paused = list.filter(r => r.state === 'paused').length, handingOff = list.filter(isHandingOff).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${paused ? ` · ${paused} interrupted` : ''} · ${list.length - running - paused} saved`)}   ${label('usage', 'Usage')}   ${memory.progress().total || running ? theme.fg('accent', '● ') : ''}${label('activity', 'Activity')}`;
+        const left = `${label('agents', `Agents: ${running} running${paused ? ` · ${paused} interrupted` : ''}${handingOff ? ` · ${handingOff} handing off` : ''} · ${list.length - running - paused - handingOff} saved`)}   ${label('usage', 'Usage')}   ${memory.progress().total || running || handingOff ? 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)];

package/src/prompts.ts

@@ -1,6 +1,7 @@
+import type { ModelChoice } from './compactor.ts';
 import { NODE, start, type Part } from './memory.ts';
 
-// Prompts from Victor Taelin's OptChat recipe, lightly adapted; README "How it differs from the recipe" lists the changes.
+// Prompts from Victor Taelin's OptChat recipe, lightly adapted; docs/recipe-differences.md lists the changes.
 export const COMPACT = `You are OptChat, an AI agent that works for one user in a single chat that never ends.
 Each call to you is a turn or a compaction:
 the view below is followed by the user's new message, or by a task starting "Compaction:".
@@ -70,6 +71,10 @@ further along than it was, and never narrate the process of summarizing
 ("output unseen", "read-only", "unconfirmed") unless that uncertainty is itself
 a fact OptChat must know. If told the line is too long, shorten it. Non-ASCII
 characters cost 2-4 bytes.`;
+/** Names the profile's subagent choice, so the agent has no gap to fill from memory when it spawns: unset means this
+ * model, and the ids it knows from training drift, so the models tool is the only source for a named one. */
+export const modelsHint = ({ provider, model, thinking }: ModelChoice) =>
+  `Subagents run ${provider}/${model} at thinking ${thinking}: leave a task's model and thinking unset for that. Set either one only when the user asks for it. A named model takes its id from models(), never from memory: your training may not know the newest ones, and a family without a version ("Opus", "GPT") means the newest one.`;
 /** Labels the line naming running agents, last in every main-agent request while any run (src/transcript.ts); never stored. */
 export const AT_WORK = '[OptChat status] Agents at work now: ';
 export const MASTER = `You are OptChat, an AI agent that works for one user in a single chat that
@@ -150,7 +155,7 @@ export const IMPORT_GUIDANCE = `Entries marked Historical are imported records,
 
 // Subagent instructions, joined after the user's own (AGENTS.md etc.): one of the two delegation paragraphs,
 // then STEERABLE, then the connected or plain tell_parent paragraph.
-export const delegation = (maxAgents: number) => `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.`;
+export const delegation = (maxAgents: number, choice: ModelChoice) => `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. ${modelsHint(choice)}`;
 export const NO_DELEGATION = 'You are at the maximum delegation depth. Complete your task with your own tools.';
 /** 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.';

package/src/runs.ts

@@ -38,6 +38,8 @@ export function transition(run: RunInfo, to: RunState) {
 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';
+/** A connected run that has ended but whose handoff summary has not reached the main agent yet. */
+export const isHandingOff = (run: RunInfo) => !isActiveRun(run) && !!run.handoff && !run.handoff.delivered;
 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)

package/src/settings.ts

@@ -23,9 +23,9 @@ export const SETTINGS = {
   summaryAcceptBytes: { kind: 'number', label: 'Summary size tolerance', default: NODE * 1.25, min: NODE, unit: 'bytes',
     description: `The compactor is always asked for ${NODE}-byte lines; a longer line up to this size is kept instead of retried. ${NODE}: strict, as in Victor's recipe. The default saves retries for a little more view space.`,
     applies: 'Applies to the next summary.' },
-  importJobs: { kind: 'number', label: 'Import: summaries at once', default: 8, min: 1, max: 64, unit: '',
-    description: 'Summaries an import builds at once. With N at once, a summary can see up to N−1 lines not summarized yet before it, so higher is faster but a little less accurate (at 8 that costs about 0.8 points per summary, #108). Higher also hits your provider\'s rate limits harder; the compactor retries what is refused. Chat itself always runs 8.',
-    applies: 'Applies to the next import.' },
+  jobs: { kind: 'number', label: 'Summaries at once', default: 8, min: 1, max: 64, unit: '',
+    description: 'Summaries built at once, by chat compaction and by an import. With N at once, a summary can see up to N−1 lines not summarized yet before it, so higher is faster but a little less accurate (at 8 that costs about 0.8 points per summary, #108). Higher also hits your provider\'s rate limits harder; the compactor retries what is refused. If your provider caps parallel requests, set it below that cap so the main turn has room.',
+    applies: 'Applies to the next import, and to chat once the profile opens again (e.g. after /reload).' },
   refreshAt: { kind: 'percent', label: 'Turn refresh threshold', default: 0.3, min: 0, max: 0.9,
     description: 'Once the current turn\'s messages pass this share of the model\'s context window, they move into memory and the turn goes on with a fresh window: the rebuilt view, the task word for word, and its last tool call and result. 0%: off, as in Victor\'s recipe, and a long turn can run out of window. OPTCHAT_REFRESH_AT (a fraction, e.g. 0.3; 0 is off) overrides it. Subagents use Pi\'s own compaction at about the same point.',
     applies: 'Applies from the next call, and to subagents started or resumed after this.' },
@@ -54,6 +54,8 @@ export function invalid(key: SettingKey, value: unknown) {
 
 /** Missing keys take their defaults, so config files written before a setting existed keep working. */
 export function readSettings(value: Record<string, unknown>): Settings {
+  // "Summaries at once" was `importJobs` while it only covered imports; an older config.json keeps its value.
+  if (!Object.hasOwn(value, 'jobs') && Object.hasOwn(value, 'importJobs')) value = { ...value, jobs: value.importJobs };
   return Object.fromEntries(SETTING_KEYS.map(key => {
     const raw = Object.hasOwn(value, key) ? value[key] : SETTINGS[key].default, problem = invalid(key, raw);
     if (problem) throw new Error(problem);

package/src/window-bridge.ts

@@ -123,7 +123,7 @@ export async function serveWindows(directory: string, children: Children, availa
             if (frame.activeOnly && (!children.live(id) || !['running', 'waiting', 'paused'].includes(info.state)))
               throw new Error(`Subagent ${id} is no longer available in the menu. Refresh and choose a live agent.`);
             const live = children.live(id);
-            const messages = live?.session.messages ?? children.messages(id);
+            const messages = children.retained(id);
             said.add(info.task.trim());
             // This socket borrows the existing session, never its lifetime, slot or report destination.
             // Other views (the main window's Agents page, other terminals) stay open alongside it.
@@ -148,7 +148,7 @@ export async function serveWindows(directory: string, children: Children, availa
             }
             if (frame.action === 'complete') {
               const live = children.live(child);
-              if (live) drainMessages(live.session.messages, live.info.task);
+              if (live) drainMessages(children.retained(child), live.info.task);
               ending = true;
               if (!attached) track(children.finish(child, 'complete').then(() => {}));
               send({ kind: 'event', name: 'finished', text: attached ? 'Detached. The background agent remains with its original parent.'
@@ -167,7 +167,8 @@ export async function serveWindows(directory: string, children: Children, availa
     const drainMessages = (messages: AgentMessage[], task: string) => {
       const displayable = messages.filter(message => message.role === 'user' || message.role === 'assistant' || message.role === 'toolResult');
       // An attachment may replay hours of tool output. Pace the history instead of overflowing the bounded wire
-      // or starving the owner's event loop. The next status tick continues from the same cursor.
+      // or starving the owner's event loop. The next status tick continues from the same cursor, which stays valid because
+      // retained messages are only ever appended (unlike Pi's projection, which compaction and retries replace).
       let batch = 0;
       while (cursor < displayable.length) {
         if (batch++ >= 32 || socket.writableLength > 1_000_000) return false;
@@ -190,7 +191,7 @@ export async function serveWindows(directory: string, children: Children, availa
         send({ kind: 'event', name: 'finished', text: 'This conversation was deleted from the Agents page.' });
         return;
       }
-      if (live) drainMessages(live.session.messages, info.task);
+      if (live) drainMessages(children.retained(child), info.task);
       const preview = live?.streaming && 'content' in live.streaming ? textContent(live.streaming.content).slice(-2000) : '';
       const text = `${info.state === 'waiting' ? 'Awaiting user or child reports' : info.state} · ${info.model}\n${live ? [...live.tools.values()].map(t => t.name).join(', ') : ''}\n${preview}`;
       let state: LiveState = { state: info.state, model: info.model,
@@ -202,7 +203,7 @@ export async function serveWindows(directory: string, children: Children, availa
       const status = JSON.stringify(state);
       if (status !== lastStatus) { lastStatus = status; send({ kind: 'event', name: 'status', text, live: state }); }
       if (!live && (attached && !isActiveRun(info) || info.handoff?.delivered)) {
-        try { if (!drainMessages(finalMessages ??= children.messages(child), info.task)) return; }
+        try { if (!drainMessages(finalMessages ??= children.retained(child), info.task)) return; }
         catch (error) { send({ kind: 'event', name: 'message', text: `Could not read the final transcript: ${errorText(error)}` }); }
         ending = true;
         send({ kind: 'event', name: 'finished', text: attached ? `Agent ${child} is ${info.state}. Its report goes to its original parent; /complete closes only this view.` : info.handoff?.text ?? 'Conversation ended.' });