pi-optchat 0.8.6 → 0.8.8

package/README.md

@@ -245,7 +245,7 @@ OptChat keeps the recipe's numbers: 512-byte lines, binary merges, the 128,000
 | Prompts | The original and 2026-10-08 prompts | The same, lightly adapted, all in `src/prompts.ts`: reports start `[id]`, a note on `[OptChat status]`, "don't poll slow things", the size limit as a ceiling rather than a target | Fit OptChat's tools; the size wording gave less filler with no recall loss (#129) |
 | Compactor instructions | Gets your instructions | Doesn't | An A/B found they added nothing (#112) |
 | Summary size | Strict 512 bytes | Asked for 512, keeps up to 640 without a retry | Saves retries for a little view space |
-| Memory view | Sawtooth, 128,000 → 64,000 bytes | Same, saved to `view.json` and reloaded as it was | |
+| Memory view | Sawtooth, 128,000 → 64,000 bytes | Same, saved to `view.json` with the compactions' view and reloaded as they were | A restart keeps both prompt prefixes cached |
 | Compaction view | Ends at the first unsummarized line | Shows that line as a placeholder and keeps the lines after it | Cutting there hid short lines like an echo's own tool call; summaries scored lower (#101) |
 | Tool-result summaries | Result only | Also sees the raw tool call | Recall 3.88 → 4.22 (#153) |
 | Cache marks | View in 4-line blocks, one mark on the last whole block | Two more marks, 20 and 40 blocks before it | With one mark, a turn that added over 80 lines made the next turn rewrite the whole view; now up to 240 lines still read from cache |

package/docs/inspector.md

@@ -40,5 +40,6 @@ A memory gauge: how many messages the profile holds and how much of the 128 KB v
 
 - If summarizing keeps failing, the last error and the retry countdown show under it. A turn waiting for summaries shows the same error next to its spinner, usually a summarizer model you aren't logged in to (`/optchat model`).
 - Once every summary a turn waits for has failed, the turn goes on, with "(not summarized yet: zoom it)" in place of the missing lines, and the failed summaries keep retrying in the background.
+- A summary the model itself won't write (a refusal, an empty reply, or 5 replies cut off at the token limit) isn't retried: that line keeps the start of what it summarizes, after "(not summarized: zoom it)", and a warning names it once. Errors such as a dropped connection, a rate limit or a missing login keep retrying.
 - 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 **●**.

package/docs/recipe-differences.md

@@ -23,7 +23,7 @@ The README has the summary table. This page has the detail: what changed in each
 
 - 512-byte summary nodes. By default summaries up to 640 bytes are accepted without a retry, as long as they are smaller than what they replace (setting: Summary size tolerance).
 - A memory view that grows a line per message and, past 128,000 bytes, merges in one batch down to 64,000. Between batches it only grows at its end, so each turn reads the last one's view from the cache. The view is saved and reloaded as it was.
-- Binary merges, 8 compression workers by default (setting: Summaries at once), fixed retry delays, 5 shortening attempts, and a 30,000-character tool output cap.
+- Binary merges, 8 compression workers by default (setting: Summaries at once), fixed retry delays, 5 shortening attempts, and a 30,000-character tool output cap. As in UniiChat, a node the model refuses keeps the first 512 bytes of its source instead (#193), and a summarizer is sent at most 100,000 characters of one message; zoom still pages through all of it.
 
 ## Compaction view and scheduling
 

package/docs/storage.md

@@ -12,7 +12,7 @@ An import builds a new memory generation (`memories/<id>/`) and switches `active
 
 ## The `Store` seam
 
-Memory reaches disk through one seam, `Store` in `src/store.ts`: the log, summary nodes, saved view and images, which is what would travel between machines.
+Memory reaches disk through one seam, `Store` in `src/store.ts`: the log, summary nodes, saved view and images, which is what would travel between machines. The saved view (`view.json`) holds the chat's view and the compactions' view, each with its batch state; an older one without the compactions' view refolds it from the chat's, once.
 
 - Runs, recovery journals, imports and their pointer, usage, settings and `AGENTS.md` stay local files.
 - `FileStore` (the layout in the README) is the only store today. Another, such as Postgres, would implement the same few operations.

package/docs/subagents.md

@@ -19,7 +19,7 @@ Your MCP servers (`~/.pi/agent/mcp.json`, the project's `.pi/mcp.json`) work in
 Each task runs the profile's subagent model (`/optchat agents model`), unless the spawn sets that task's `model` (`provider/id`, as in `/model`) or `thinking`. The agent sets them only when you ask for them.
 
 - What a task leaves out comes from the profile: a model alone runs at the profile's thinking level, or the nearest level that model takes.
-- The `models` tool (`provider` optional) lists what a task may name, with the profile's default marked. The agent is told to call it when you name a family without a version ("Opus"), since the newest ids may postdate its training.
+- The agent's instructions name the profile's subagent model and level, so it leaves a task's `model` unset unless you ask for another one. The `models` tool (`provider` optional) lists what a task may name, with the default marked; the agent is told to take ids only from it, never from memory, since the newest ids may postdate its training ("Opus" without a version means the newest).
 - A model Pi doesn't know refuses the whole spawn before any child starts, and the error lists the models you can use.
 - A resumed child keeps the model and level it ran with.
 

package/package.json

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

package/src/agent-view.ts

@@ -6,7 +6,7 @@ import {
 import { Editor, Spacer, compositeTuiLine, 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 { isHandingOff, type RunInfo } from './runs.ts';
 import { textContent } from './transcript.ts';
 import { record } from './cache.ts';
 import { elapsed, fit, oneLine } from './inspector.ts';
@@ -164,7 +164,7 @@ export interface AgentViewOptions {
 
 const statusOf = (run: RunInfo, children: Children) => {
   const live = children.live(run.id);
-  if (!live) return run.state;
+  if (!live) return isHandingOff(run) ? 'handing off' : 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';

package/src/agents.ts

@@ -68,8 +68,8 @@ export const taskDirectory = (cwd: string, path = '.', windows = process.platfor
 const CWD_DOC = 'Project directory the subagent works in (~ allowed); its AGENTS.md files load from there. Defaults to your current directory.';
 /** The spawn tools' tasks. What a task leaves out of model and thinking is the profile's subagent choice. */
 export const TASKS = Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String({ description: CWD_DOC })),
-  model: Type.Optional(Type.String({ description: 'Model as provider/id, such as anthropic/claude-sonnet-5-5. Set it only when the user asks for one; otherwise the profile\'s subagent model runs.' })),
-  thinking: Type.Optional(StringEnum(THINKING, { description: 'Thinking level. Set it only when the user asks for one; otherwise the profile\'s subagent level applies.' })) }), { minItems: 1 });
+  model: Type.Optional(Type.String({ description: 'Leave unset for the profile\'s subagent model (named in your instructions). Set only when the user asks for a model, as provider/id from models().' })),
+  thinking: Type.Optional(StringEnum(THINKING, { description: 'Leave unset for the profile\'s subagent level. Set only when the user asks for one.' })) }), { minItems: 1 });
 export type Task = Static<typeof TASKS>[number];
 /** The tool beside spawn that lists what a task's `model` may be. */
 export const modelsTool = (children: () => Children) => ({ name: 'models', label: 'List models',
@@ -147,13 +147,21 @@ export class Children {
     const file = this.history.records.get(id)?.sessionFile;
     return file ? sessionMessages(file) : [];
   }
+  /**
+   * Every message a run has finalized, in order and never rewritten: Pi's session entries, for a live run too.
+   * `session.messages` is only the model's projection, which compaction and retries replace with a shorter list.
+   */
+  retained(id: string): AgentMessage[] {
+    const live = this.running.get(id);
+    return live ? live.session.sessionManager.getEntries().flatMap(e => e.type === 'message' ? [e.message] : []) : this.messages(id);
+  }
   /** A run's messages for zoom, live or finished; undefined for no such run. A subagent `reader` sees only its own descendants, as with tell. */
   transcript(id: string, reader?: string) {
     const known = reader ? this.history.descendants(reader).some(run => run.id === id) : this.running.has(id) || this.history.records.has(id);
     if (!known) return undefined;
     const live = this.running.get(id);
     if (!live) return this.messages(id);
-    const retained = live.session.sessionManager.getEntries().flatMap(e => e.type === 'message' ? [e.message] : []);
+    const retained = this.retained(id);
     // Pi puts the finalized message in session.messages before message_end listeners run, then persists that same object.
     const tail = live.streaming ?? live.session.messages.at(-1);
     return tail && !retained.includes(tail) ? [...retained, tail] : retained;
@@ -272,7 +280,7 @@ export class Children {
     thinking?: ModelChoice['thinking']; sessionManager: SessionManager }) {
     const { id, directory, depth, parentId, connected } = o;
     const { subagentLevels, maxAgents, memorySearch } = this.settings, delegates = depth < subagentLevels;
-    const instructions = [this.instructions(), delegates ? delegation(maxAgents) : NO_DELEGATION, STEERABLE, connected ? CONNECTED : NOT_CONNECTED].filter(Boolean).join('\n\n');
+    const instructions = [this.instructions(), delegates ? delegation(maxAgents, this.choice()) : NO_DELEGATION, STEERABLE, connected ? CONNECTED : NOT_CONNECTED].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: subagentCompaction(o.model.contextWindow, refreshFraction(this.settings.refreshAt)), cacheWarming: 'off' });

package/src/compactor.ts

@@ -3,7 +3,7 @@ import { clampThinkingLevel, isRetryableAssistantError, type Api, type Assistant
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
 import { COMPACT, compaction, IMPORT_GUIDANCE, tooLong } from './prompts.ts';
-import { bytes, NODE, type Compressor } from './memory.ts';
+import { bytes, cut, Refused, type Compressor } from './memory.ts';
 import { cachePayload, splitView } from './cache.ts';
 import { DEFAULT_SETTINGS } from './settings.ts';
 
@@ -42,10 +42,21 @@ function primeFirst() {
     };
   };
 }
+/** Pi's agent loop retries a dropped connection itself; streamSimple doesn't, so a transient error is asked again before it surfaces. */
+export async function retryTransient(ask: () => Promise<AssistantMessage>, onReply: (reply: AssistantMessage) => void,
+  delays: readonly number[] = [1000, 2000], signal?: AbortSignal) {
+  for (let retry = 0; ; retry++) {
+    const reply = await ask();
+    onReply(reply);
+    if (retry >= delays.length || !isRetryableAssistantError(reply)) return reply;
+    await sleep(delays[retry], undefined, { signal });
+  }
+}
+
 /** The model is asked for 512 bytes; `accepted` is the longest line kept without a retry (the profile's summary size tolerance). */
 export function createCompressor(registry: ModelRegistry, choice: () => ModelChoice,
   onUsage: (message: AssistantMessage) => void = () => {}, accepted = () => DEFAULT_SETTINGS.summaryAcceptBytes,
-  retryDelays: readonly number[] = [1000, 2000]): Compressor {
+  retryDelays?: readonly number[]): Compressor {
   const gate = primeFirst();
   return async (input, signal) => {
     const selected = choice();
@@ -72,31 +83,26 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
         return await stream.result();
       } finally { warmed(false); }
     };
-    // Pi's agent loop retries a dropped connection itself; streamSimple doesn't, so a transient error is asked again before it surfaces.
-    const answer = async () => {
-      for (let retry = 0; ; retry++) {
-        const reply = await ask();
-        onUsage(reply);
-        if (retry >= retryDelays.length || !isRetryableAssistantError(reply)) return reply;
-        await sleep(retryDelays[retry], undefined, { signal });
-      }
-    };
+    const answer = () => retryTransient(ask, onUsage, retryDelays, signal);
     for (let attempt = 0; attempt < 5; attempt++) {
       const reply = await answer();
+      // A stop reason means the model answered: a refusal or a content filter, which asking again repeats.
+      // A provider's own 'error' stop (Mistral) is a failure on its side, not an answer: a plain error, tried again later.
+      if (reply.stopReason === 'error' && reply.rawStopReason !== undefined && reply.rawStopReason !== 'error' && !isRetryableAssistantError(reply))
+        throw new Refused(reply.errorMessage ?? `Compactor stopped: ${reply.rawStopReason}`);
       if (reply.stopReason === 'error' || reply.stopReason === 'aborted') throw new Error(reply.errorMessage ?? `Compactor ${reply.stopReason}`);
       // A reply cut off at the token limit, or one that calls a tool, is no summary: ask again.
       if (reply.stopReason === 'length' || reply.content.some(c => c.type === 'toolCall')) continue;
       // The compactions' view shows each line under its id+n| head, which a line can copy.
       const line = reply.content.filter(c => c.type === 'text').map(c => c.text).join('').trim().replace(/^\d+\+\d+\|\s*/, '');
-      if (!line) throw new Error('Compactor returned no text.');
+      if (!line) throw new Refused('Compactor returned no text.');
       tries.push(line);
       // A merge of two short lines can come back nearly as big as both, so a line must also shrink what it replaces.
       if (bytes(line) <= accepted() && bytes(line) < bytes(input.source)) break;
       messages.push(reply);
-      const cut = Buffer.from(line).subarray(0, NODE).toString('utf8').replace(/\uFFFD$/, '');
-      messages.push({ role: 'user', content: tooLong(bytes(line), cut), timestamp: Date.now() });
+      messages.push({ role: 'user', content: tooLong(bytes(line), cut(line)), timestamp: Date.now() });
     }
-    if (!tries.length) throw new Error('Compactor returned no whole line in 5 tries.');
+    if (!tries.length) throw new Refused('Compactor returned no whole line in 5 tries.');
     return tries.reduce((a, b) => bytes(a) <= bytes(b) ? a : b);
   };
 }

package/src/handoff.ts

@@ -1,7 +1,7 @@
 import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { AssistantMessage } from '@earendil-works/pi-ai';
-import { reasoningFor, type ModelChoice } from './compactor.ts';
+import { reasoningFor, retryTransient, type ModelChoice } from './compactor.ts';
 import { HANDOFF } from './prompts.ts';
 import type { RunInfo } from './runs.ts';
 import { textContent } from './transcript.ts';
@@ -30,7 +30,7 @@ function formatEvidence({ run, messages, transcriptError }: HandoffEvidence) {
 
 /** Summarize in one call when possible; otherwise fold chunks with the prior handoff included in the budget. */
 export function createHandoffSummarizer(registry: ModelRegistry, choice: () => ModelChoice,
-  usage: (message: AssistantMessage) => void) {
+  usage: (message: AssistantMessage) => void, retryDelays?: readonly number[]) {
   return async (run: RunInfo, messages: AgentMessage[], descendants: HandoffEvidence[] = []) => {
     const selected = choice(), model = registry.find(selected.provider, selected.model);
     if (!model) throw new Error('Profile compactor model unavailable');
@@ -50,11 +50,10 @@ export function createHandoffSummarizer(registry: ModelRegistry, choice: () => M
       let end = Math.min(transcript.length, offset + available);
       // Keep multibyte characters intact at chunk boundaries.
       while (end < transcript.length && (transcript[end] & 0xc0) === 0x80) end--;
-      const reply = await registry.streamSimple(model, {
+      const reply = await retryTransient(() => registry.streamSimple(model, {
         systemPrompt: HANDOFF,
         messages: [{ role: 'user', timestamp: Date.now(), content: prefix + transcript.subarray(offset, end).toString('utf8') }],
-      }, { reasoning: reasoningFor(model, selected.thinking), maxTokens, signal: AbortSignal.timeout(300_000) }).result();
-      usage(reply);
+      }, { reasoning: reasoningFor(model, selected.thinking), maxTokens, signal: AbortSignal.timeout(300_000) }).result(), usage, retryDelays);
       if (reply.stopReason === 'error' || reply.stopReason === 'aborted') throw new Error(reply.errorMessage ?? reply.stopReason);
       if (reply.stopReason === 'length') throw new Error('Handoff hit the model output limit before finishing');
       summary = textContent(reply.content).trim();

package/src/index.ts

@@ -10,7 +10,7 @@ import { Memory } from './memory.ts';
 import { atomicWrite, storeFor } from './store.ts';
 import { createCompressor } from './compactor.ts';
 import { createProfile, holdProfile, instructions, isWindows, lastProfile, listProfiles, loadConfig, profilePath, rememberProfile, saveConfig, ProfileBusyError, type ProfileConfig } from './profiles.ts';
-import { allowSearch, CONTINUITY, IMPORT_GUIDANCE, MASTER, SEARCH_DOC, TURN_REFRESHED, VIEW_DOC } from './prompts.ts';
+import { allowSearch, CONTINUITY, IMPORT_GUIDANCE, MASTER, modelsHint, SEARCH_DOC, TURN_REFRESHED, VIEW_DOC } from './prompts.ts';
 import { cachePayload, record } from './cache.ts';
 import { saveImages } from './images.ts';
 import { asUser, boundedMessage, atWork, buildContext, logMessage, previousExchange, refreshedRun, refreshBudget, refreshFraction, refreshPoint, reportReceipt, REPORT_RECEIPT, REPORT_TYPE, RUN_BOUNDARY, textContent, typedText } from './transcript.ts';
@@ -385,7 +385,7 @@ export default function optchat(pi: ExtensionAPI) {
     const a = required();
     // Pi's own prompt sections (AGENTS.md files, skills, cwd) stay; the profile's instructions go last.
     syncSearch(a.config);
-    event.systemPromptOptions.customPrompt = allowSearch(`${MASTER}\n\n${VIEW_DOC}${a.config.previousExchange ? CONTINUITY : ''}${a.config.memorySearch ? SEARCH_DOC : ''}`, a.config.memorySearch);
+    event.systemPromptOptions.customPrompt = allowSearch(`${MASTER}\n\n${modelsHint(a.config.subagent)}\n\n${VIEW_DOC}${a.config.previousExchange ? CONTINUITY : ''}${a.config.memorySearch ? SEARCH_DOC : ''}`, a.config.memorySearch);
     event.systemPromptOptions.sections.instructions = `${instructions(a.dir)}\n\n${IMPORT_GUIDANCE}`;
     prompt = event.systemPrompt;
   });
@@ -507,7 +507,7 @@ export default function optchat(pi: ExtensionAPI) {
     if (tools.includes('search') !== memorySearch) pi.setActiveTools(memorySearch ? [...tools, 'search'] : tools.filter(name => name !== 'search'));
   };
   pi.registerTool({ name: 'spawn', label: 'Spawn background agents',
-    description: 'Start background subagents, returning IDs immediately. Use only when the user asks. Give each task the cwd of the project it works on, so the subagent starts there with that project\'s AGENTS.md. A task names a model only when the user asks for one; models() lists the valid ids. Each receives the current memory view and read-only zoom/date. Whether children may delegate further, and how many agents may run at once, is set per profile. Completion reports arrive automatically; never poll or sleep waiting for them.',
+    description: 'Start background subagents, returning IDs immediately. Use only when the user asks. Give each task the cwd of the project it works on, so the subagent starts there with that project\'s AGENTS.md. Leave a task\'s model unset for the profile\'s default; name one only when the user asks, with an id from models(). Each receives the current memory view and read-only zoom/date. Whether children may delegate further, and how many agents may run at once, is set per profile. Completion reports arrive automatically; never poll or sleep waiting for them.',
     parameters: Type.Object({ tasks: TASKS }),
     async execute(_id, args, signal, _update, ctx) {
       const text = await required().children.start(args.tasks, ctx.cwd, signal); status(ctx);

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';
@@ -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,3 +1,4 @@
+import type { ModelChoice } from './compactor.ts';
 import { NODE, start, type Part } from './memory.ts';
 
 // Prompts from Victor Taelin's OptChat recipe, lightly adapted; docs/recipe-differences.md lists the changes.
@@ -70,8 +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.`;
-/** Spawn tasks may name a model; the ids the model knows from training drift, so the models tool is the source. */
-export const MODELS_HINT = 'When the user names a model family without a version ("Opus", "GPT"), assume the newest one and call models() for its exact id: your training may not know it.';
+/** 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
@@ -81,7 +84,6 @@ message.
 Do the user's tasks yourself (or delegate to subagents according to the tasks and user preferences), with your tools, following the user's instructions
 at the end of this prompt: who they are, how their files are organized and how
 they want work done. Use subagents when it makes sense and when the user asks for them.
-${MODELS_HINT}
 
 Messages the user sends while you work reach you between tool calls. Subagents
 and computer tasks run in the background; each one's report reaches you as a
@@ -153,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. ${MODELS_HINT}`;
+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/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.' });