pi-optchat 0.8.8 → 0.9.0

package/README.md

@@ -176,7 +176,7 @@ Source paths, selection keys, exactly what is left out, and duplicate rules: [do
 
 Each profile is locked to one Pi process. Open the same profile in a second terminal and Pi offers to connect it to the original window as a subagent.
 
-- Your first message starts a subagent in the second window's working directory; later messages continue it. The window looks like a normal Pi chat.
+- Your first message starts a subagent in the second window's working directory; later messages continue it. The window looks like a normal Pi chat: messages you send while it works queue under the spinner, Esc interrupts, Alt+Up takes the last queued one back.
 - The subagent runs inside the original process, which stays the only writer of memory.
 - `/tell-main <message>` messages the main agent. `/complete` ends the conversation and the compactor writes a handoff for the main agent; closing the window also produces one, marked **interrupted**.
 - Text only. The connection is a local socket restricted to your OS user (on Windows a named pipe, without that restriction; see [Windows](#windows)); no daemon or server.

package/docs/connected-windows.md

@@ -8,6 +8,7 @@ If you open the same profile in a second terminal, Pi offers to connect it to th
 
 - Your first message starts a subagent in the second window's working directory. Later messages continue the same conversation.
 - The window looks like a normal Pi chat: replies, tool calls with their output and running time, the working spinner, and reports from the subagent's own agents in the dark box. Ctrl+O expands tool output.
+- Messages you send while the agent works show under the spinner until it reads them, as in Pi. At the editor, Esc interrupts the agent (it goes on with any queued messages, or waits for your next one) and Alt+Up (Alt+Q on Windows) takes the newest queued message back to edit. Both follow your Pi keybindings.
 - The subagent runs inside the original process, which stays the only writer of memory. It appears in the original window's inspector and takes one of the profile's active agent slots (Max active agents, 8 by default). While it is open, the original window can't switch profile or import.
 - The main agent is told when the conversation starts. Use `/tell-main <message>` to message it yourself; the subagent can use `tell_parent`, and the main agent replies with `tell`. Routine turns don't wake the main agent.
 - Text only. For images, give the agent a file path.
@@ -35,7 +36,7 @@ pi --optchat-profile work --optchat-agent 8ab62e89
 This opens that **same agent's session** as a normal Pi chat: its task, previous replies and tool results, then live output. Messages you type are guidance to that agent; a paused agent continues when you send one. `/tell-main` still contacts the main agent.
 
 - The original Pi window stays the only owner: it runs the agent, and reports still go to the agent's parent. Opening the window starts no new agent or model call.
-- **Closing the terminal or `/complete` only detaches.** The agent keeps running. Stop or interrupt it from the main window's **Agents** page, which can open the same agent at the same time, as can other terminals.
+- **Closing the terminal or `/complete` only detaches.** The agent keeps running. Esc interrupts it here as in a connected window; stop it from the main window's **Agents** page, which can open the same agent at the same time, as can other terminals.
 - A finished agent opens for reading, without being restarted.
 - This needs interactive Pi and a running owner window. An unknown ID, or a conversation owned by another connected window, is refused rather than starting a new one.
 - The attached terminal saves no session to resume; run the command again instead. The agent ID is not a Pi session ID.

package/docs/storage.md

@@ -4,7 +4,7 @@ Profile data lives in `~/.optchat/profiles/<name>/` (override the root with `OPT
 
 ## Git checkpoints
 
-Each profile folder is a local Git repository, committed after each turn and on clean shutdown (memory and config; not runs, HTML, or usage). It has no remote, so it is not a backup. To back up, copy the folder while Pi is closed.
+Each profile folder is a local Git repository, committed after each turn (memory and config; not runs, HTML, or usage). It has no remote, so it is not a backup. To back up, copy the folder while Pi is closed.
 
 ## Import generations
 

package/docs/victor-recipe.md

@@ -12,7 +12,7 @@ The source remains upstream rather than duplicating the full article here. Its p
 
 - `src/memory.ts`: append-only log, binary summary tree, compression scheduling (§4 of the 2026-10-08 revision: a message's summary starts once fewer than 8 lines before it are unbuilt, a merge once both halves are built, kept in a queue so the tree is never scanned for work), the compactions' own view (§4: the view merged further to 16,000-32,000 bytes, ending at the node; unlike the recipe, a line not built yet shows as a placeholder instead of ending it, so a summary still sees the built lines after it), the view (§3.2: the most due pair, measured from its last message, merges in one batch from 128,000 down to 64,000 bytes, and the view is saved to `view.json` rather than refolded at start), zoom/date, and the opt-in text search over original messages (`src/tools.ts` has the tool; not in the recipe, off by default).
 - `src/compactor.ts`: contextual compression and size retries, with the 2026-10-08 revision's task (a 512-dash ruler for the size) and its "Too long" retry, verbatim. The compactions' view shows each line under its `id+n|` head, as the task's line ids need, so a reply that copies a head has it removed.
-- `src/cache.ts`: Anthropic cache marks: the view in blocks of 4 lines, one mark on the last whole block and one at the request's end, as in recipe §3.3, plus two marks 20 and 40 blocks before the last. Anthropic looks back only 20 blocks from a mark, so with the recipe's one view mark a turn that added more than 80 lines, such as 40 tool calls and their results, made the next turn rewrite the whole view. OpenAI requests get no marks: GPT-5.6 and GPT-6 Luna reject the recipe's `prompt_cache_breakpoint` with a 400 (found by @aaaxn), so they rely on implicit prefix caching. OptChat doesn't set `reasoning.context` either: GPT-5.6 already defaults to the recipe's `"all_turns"`, and OpenAI documents it only for GPT-5.6 and GPT-6.1 Sol.
+- `src/cache.ts`: Anthropic cache marks: the view in blocks of 4 lines, one mark on the last whole block and one at the request's end, as in recipe §3.3 (a compaction leaves its end unmarked, as Unii does: its task is never sent again), plus two marks 20 and 40 blocks before the last. Anthropic looks back only 20 blocks from a mark, so with the recipe's one view mark a turn that added more than 80 lines, such as 40 tool calls and their results, made the next turn rewrite the whole view. OpenAI requests get no marks: GPT-5.6 and GPT-6 Luna reject the recipe's `prompt_cache_breakpoint` with a 400 (found by @aaaxn), so they rely on implicit prefix caching. OptChat doesn't set `reasoning.context` either: GPT-5.6 already defaults to the recipe's `"all_turns"`, and OpenAI documents it only for GPT-5.6 and GPT-6.1 Sol.
 - `src/transcript.ts`: fresh context per parent run, current-run tool loop retained. The previous completed exchange is also retained in full text (left out if over 16,000 bytes by default), an intentional addition to the summary-only recipe for conversational continuity.
 - `src/agents.ts`: asynchronous Pi SDK children and automatic completion reports.
 - `src/settings.ts`: per-profile settings for the departures from the recipe. Defaults are the recipe's (no memory search), except the previous exchange (on), the summary size tolerance (640 bytes, against the recipe's strict 512) and the turn refresh threshold (30%, where the recipe has none). Grouped subagent reports are off by default, as in the revised recipe, which reports each subagent on its own.

package/package.json

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

package/src/agents.ts

@@ -23,7 +23,7 @@ import { THINKING } from './profiles.ts';
 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>;
+  pendingReports: string[]; pendingGuidance: string[]; wake?: () => void; completion?: Promise<void>; primed?: Promise<unknown>;
   /** 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. */
@@ -98,6 +98,30 @@ export function subagentCompaction(contextWindow: number, fraction: number) {
   if (!(fraction > 0)) return { enabled: true };
   return { enabled: true, reserveTokens: Math.max(16_384, Math.round(contextWindow * (1 - fraction) - VIEW / 4)) };
 }
+/** Waits for `promise`, or until `signal` aborts. */
+async function abortable(promise: Promise<unknown>, signal?: AbortSignal) {
+  let stop = () => {};
+  const aborted = new Promise<void>(resolve => { stop = resolve; });
+  signal?.addEventListener('abort', stop, { once: true });
+  if (signal?.aborted) stop();
+  try { await Promise.race([promise, aborted]); } finally { signal?.removeEventListener('abort', stop); }
+}
+/** Resolves once the session's model starts answering, or its request ends without an answer. */
+const answering = (session: AgentSession) => new Promise<void>(resolve => {
+  const off = session.subscribe(event => {
+    if (event.type === 'message_update' || event.type === 'agent_end' || event.type === 'message_end' && event.message.role === 'assistant') { off(); resolve(); }
+  });
+});
+
+/** What a run interrupted with messages queued continues with: the user's interrupt, so windows show it as theirs. */
+export const INTERRUPTED = 'Interrupted by the user:\n\n';
+const interruptedWith = (texts: string[]) => `${INTERRUPTED}${texts.join('\n\n')}`;
+
+/** Pi reads AGENTS.md/CLAUDE.md only at session start and /reload. Re-reading the files Pi loaded picks up edits each run and keeps
+ * the session's own choices (`-nc`, its agent dir); a file that can't be read is skipped, as Pi does. A new file still needs /reload. */
+export function refreshContextFiles(options: { contextFiles: Array<{ path: string; content: string }> }) {
+  options.contextFiles = options.contextFiles.flatMap(({ path }) => { try { return [{ path, content: readFileSync(path, 'utf8') }]; } catch { return []; } });
+}
 export class Children {
   private readonly running = new Map<string, LiveRun>();
   readonly history: RunHistory;
@@ -224,10 +248,14 @@ export class Children {
     const launched = await this.track(this.launchBatch({ tasks: runs, cwd, depth, parentId, connected, signal, cancelled }));
     // Grouped, the last child of this spawn to finish delivers every report; otherwise each reports on its own.
     const batch = groupReports && !connected ? { ids: launched.map(c => c.info.id), reports: new Map<string, string>() } : undefined;
+    // Siblings on one model and directory send the same system prompt, tools and view. Anthropic can't read a cache entry
+    // still being written, so their first requests wait until the first sibling starts answering and read its entry instead.
+    const [first] = launched, answered = launched.length > 1 && first.session.model?.api === 'anthropic-messages' ? answering(first.session) : undefined;
     for (const live of launched) {
       live.batch = batch;
       const work = this.execute(live, `${view}\n\nYour task:\n${live.info.task}`).catch(error => this.warn(`Subagent completion failed: ${String(error)}`))
         .finally(() => { this.completions.delete(work); this.changed(); });
+      if (live === first && answered) for (const sibling of launched.slice(1)) if ((['model', 'thinking', 'cwd'] as const).every(k => sibling.info[k] === first.info[k])) sibling.primed = Promise.race([answered, work]);
       this.completions.add(work);
       live.completion = work;
     }
@@ -280,7 +308,6 @@ 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, 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' });
@@ -291,11 +318,18 @@ export class Children {
         const provider = this.registry.getRegisteredProviderConfig(o.model.provider);
         if (provider) pi.registerProvider(o.model.provider, provider);
         // Same prompt as the main agent (AGENTS.md files, skills, cwd); only the OptChat preamble differs.
+        // Read every run, so edits reach a live child's next run (after a pause, or a connected window's next message); Pi sends only the changed sections.
         pi.on('before_agent_start', event => {
           event.systemPromptOptions.customPrompt = allowSearch(`${SUBAGENT}\n\n${VIEW_DOC}${memorySearch ? SEARCH_DOC : ''}`, memorySearch);
-          event.systemPromptOptions.sections.instructions = instructions;
+          event.systemPromptOptions.sections.instructions = [this.instructions(), delegates ? delegation(maxAgents, this.choice()) : NO_DELEGATION, STEERABLE, connected ? CONNECTED : NOT_CONNECTED].filter(Boolean).join('\n\n');
+          refreshContextFiles(event.systemPromptOptions);
+        });
+        pi.on('before_provider_request', async (event, ctx) => {
+          // Set by launch for a sibling's first request; a stop or an interrupt aborts the request, which ends the wait.
+          const live = this.running.get(id), primed = live?.primed;
+          if (live && primed) { live.primed = undefined; await abortable(primed, ctx.signal); }
+          return ctx.model?.api === 'anthropic-messages' ? cachePayload(event.payload) : event.payload;
         });
-        pi.on('before_provider_request', (event, ctx) => ctx.model?.api === 'anthropic-messages' ? cachePayload(event.payload) : event.payload);
       }],
     });
     await loader.reload();
@@ -362,7 +396,9 @@ export class Children {
       await session.prompt(prompt);
       while (info.state !== 'stopping') {
         if (live.interruption) {
-          const guidance = live.interruption.filter(g => g.state === 'queued');
+          // A message Pi took during the abort (a rebuild of its queue can still be landing) went into a request the abort
+          // cancelled, so it got no reply: it goes in this prompt too. Only a stop's undelivered ones stay out.
+          const guidance = live.interruption.filter(g => g.state !== 'undelivered');
           // 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;
@@ -384,7 +420,7 @@ export class Children {
           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')}`);
+          await session.prompt(interruptedWith(guidance.map(g => g.text)));
           continue;
         }
         const paused = info.state === 'paused';
@@ -503,9 +539,12 @@ export class Children {
     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.
+    // They leave pendingGuidance and Pi's steering queue here, and execute() sends them in one prompt. Pi's queue must be empty
+    // before the abort: after an aborted tool call Pi hands it to a request the abort cancels.
     const texts = new Set(guidance.map(g => g.text));
     live.pendingGuidance = live.pendingGuidance.filter(text => !texts.has(text));
+    // The rest of the queue (a child's tell_parent message) follows the interrupt's prompt, as reports to a paused run do.
+    live.pendingReports.push(...live.session.clearQueue().steering.filter(text => !texts.has(text)));
     live.interruption = guidance;
     live.wake?.();
     await live.session.abort();

package/src/cache.ts

@@ -33,8 +33,9 @@ function lastBlock(message: Record<string, unknown>) {
 /** Anthropic: marks on the view (see MARKS) plus a mark at the end of the request, so the next call finds the last one's entry
  * and pays only for the lines after it. The end mark sits on the last block itself rather than as top-level automatic caching:
  * a proxy or setting that gives block marks a 1h TTL makes Anthropic refuse a top-level mark, whose TTL defaults to 5m, on the
- * same block ("Top-level cache_control has ttl='5m' but the target block already has cache_control with ttl='1h'"). */
-export function cachePayload(payload: unknown): unknown {
+ * same block ("Top-level cache_control has ttl='5m' but the target block already has cache_control with ttl='1h'").
+ * `end: false` leaves the end unmarked: a compaction's task is never sent again, so marking it would only write it at 1.25× (#197). */
+export function cachePayload(payload: unknown, { end: markEnd = true } = {}): unknown {
   if (!record(payload) || !Array.isArray(payload.messages)) return payload;
   const messages = payload.messages;
   const view = new Set<unknown>();
@@ -42,9 +43,12 @@ export function cachePayload(payload: unknown): unknown {
     if (!record(message) || message.role !== 'user' || !Array.isArray(message.content)) continue;
     const at = message.content.findIndex((block: unknown) => record(block) && block.type === 'text' && typeof block.text === 'string' && isView(block.text));
     if (at < 0) continue;
-    const pieces = splitView(message.content[at].text), marked = new Set(MARKS.map(back => pieces.length - 2 - back));
+    // A subagent's task follows the view in the same text. Lines never hold a newline, so the first one before </chat> ends the view;
+    // the task goes in its own block, so the view's marks fall on lines its siblings share and they can read one another's entry.
+    const text: string = message.content[at].text, close = text.indexOf('\n</chat>'), end = close < 0 ? text.length : close + '\n</chat>'.length;
+    const pieces = splitView(text.slice(0, end)), marked = new Set(MARKS.map(back => pieces.length - 2 - back));
     const blocks = pieces.map((text, j) => ({ type: 'text', text, ...(marked.has(j) ? { cache_control: { type: 'ephemeral' } } : {}) }));
-    message.content.splice(at, 1, ...blocks);
+    message.content.splice(at, 1, ...blocks, ...(end < text.length ? [{ type: 'text', text: text.slice(end) }] : []));
     for (const block of blocks) view.add(block);
     break;
   }
@@ -62,7 +66,7 @@ export function cachePayload(payload: unknown): unknown {
   // Pi may end the request with an empty system message carrying settings (effort); it holds nothing to cache.
   const [before, last] = messages.filter(message => !record(message) || message.role !== 'system').slice(-2);
   const turn = isAtWork(last) && record(before) && before.role === 'user' ? lastBlock(before) : undefined;
-  const end = turn ?? endBlock(messages);
+  const end = markEnd ? turn ?? endBlock(messages) : undefined;
   if (end) end.cache_control = { type: 'ephemeral' };
   return payload;
 }

package/src/checkpoint.ts

@@ -1,16 +1,28 @@
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
-import { existsSync } from 'node:fs';
+import { existsSync, rmSync, statSync } from 'node:fs';
 import { join } from 'node:path';
 import { atomicWrite } from './store.ts';
 const exec = promisify(execFile);
 // Each checkpoint stores the whole day log again as a loose object. Git's own auto gc counts loose objects, not bytes, and waits for about 6,700 of them (some 1,000 checkpoints), so the checkpoint packs them itself once they pass this size.
 const LOOSE_LIMIT_KIB = 16_384;
+// A host that stops Pi with SIGTERM and SIGKILL a second later can kill git mid-checkpoint, and git never removes the lock it leaves (#220).
+// Index and ref updates take seconds at most, so no live git plausibly holds a lock this old. A younger one may still belong to a git that a
+// killed Pi left running (a big `git add` or gc), so that checkpoint is skipped and the next one, after the next turn, looks again.
+const STALE_LOCK_MS = 10 * 60_000;
+const LOCKS = ['index.lock', 'HEAD.lock', 'refs/heads/main.lock'];
 
 export async function checkpoint(directory: string) {
   const git = (args: string[]) => exec('git', ['-C', directory, ...args], { maxBuffer: 1_000_000 });
   if (!existsSync(join(directory, '.git'))) await git(['init', '-q', '-b', 'main']);
   if (!existsSync(join(directory, '.gitignore'))) atomicWrite(join(directory, '.gitignore'), '/runs/\n/memory.html\n/usage.jsonl\n*.tmp\n');
+  const locks = LOCKS.flatMap(name => {
+    const path = join(directory, '.git', name), stat = statSync(path, { throwIfNoEntry: false });
+    return stat ? [{ path, age: Date.now() - stat.mtimeMs }] : [];
+  });
+  if (locks.some(lock => lock.age < STALE_LOCK_MS)) return;
+  // A lock that cannot go (Windows EBUSY) makes git fail below, and the next turn tries again.
+  for (const { path } of locks) try { rmSync(path, { force: true }); } catch { /* next turn retries */ }
   await git(['add', '-A', '--', '.']);
   const status = await git(['diff', '--cached', '--name-only']);
   if (!status.stdout.trim()) return;

package/src/compactor.ts

@@ -76,7 +76,7 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
           // A shared session id is the OpenAI prompt-cache key; SSE because over a websocket Codex would chain unrelated parallel calls on one cached connection.
           sessionId: 'optchat-compactor', transport: 'sse',
           reasoning: thinking, signal, cacheRetention: 'short',
-          onPayload: payload => model.api === 'anthropic-messages' ? cachePayload(payload) : payload,
+          onPayload: payload => model.api === 'anthropic-messages' ? cachePayload(payload, { end: false }) : payload,
         });
         // The cache entry is usable once the model starts answering.
         for await (const event of stream) if (event.type !== 'start') { warmed(event.type !== 'error'); break; }

package/src/connected-window.ts

@@ -1,5 +1,5 @@
-import { getMarkdownTheme, UserMessageComponent, type ExtensionAPI, type ExtensionContext, type Theme } from '@earendil-works/pi-coding-agent';
-import { Container, Loader, Markdown, type Component, type TUI } from '@earendil-works/pi-tui';
+import { getMarkdownTheme, keyText, UserMessageComponent, type ExtensionAPI, type ExtensionContext, type Theme } from '@earendil-works/pi-coding-agent';
+import { Container, Editor, getKeybindings, Loader, Markdown, Spacer, TruncatedText, TuiAltScreen, TuiMainScreen, type Component, type TUI } from '@earendil-works/pi-tui';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { connectWindow, type LiveState, type WindowEvent } from './window-bridge.ts';
 import { profilePath } from './profiles.ts';
@@ -43,14 +43,15 @@ export function registerConnectedRenderer(pi: ExtensionAPI) {
 
 const toolCalls = (message: AgentMessage) => message.role === 'assistant' ? message.content.flatMap(part => part.type === 'toolCall' ? [part.id] : []) : [];
 
-/** What normally sits at the bottom of Pi's chat while it works: the streaming reply, running tools and the working spinner. */
+/** What normally sits at the bottom of Pi's chat while it works: the streaming reply, running tools, the working spinner and your queued messages. */
 class LiveTurn implements Component {
   private readonly loader: Loader;
   private readonly body = new Container();
+  private readonly queued = new Container();
   private spinning = false;
   turn: AgentMessage[] = [];
   live?: LiveState;
-  constructor(private readonly tui: TUI, theme: Theme) {
+  constructor(readonly tui: TUI, private readonly theme: Theme) {
     this.loader = new Loader(tui, text => theme.fg('accent', text), text => theme.fg('muted', text), 'Working');
     // Running tools show their elapsed time, which only moves when they are redrawn.
     this.timer = setInterval(() => { if (this.live?.tools.length) this.update(); }, 1000); this.timer.unref();
@@ -65,13 +66,21 @@ class LiveTurn implements Component {
     // Waiting with no agents of its own means it is waiting for you, so nothing spins, like an idle Pi.
     const agents = this.live?.agents ?? 0;
     const spin = !!state && statusState(state, agents) === 'working';
-    this.loader.setMessage(state === 'waiting' ? `Waiting for ${agents === 1 ? '1 agent' : `${agents} agents`}` : state === 'stopping' ? 'Stopping' : 'Working');
+    // Owners that send `queued` also take Esc; older ones would drop the connection on it.
+    const interrupt = this.live?.queued ? ` (${keyText('app.interrupt')} to interrupt)` : '';
+    this.loader.setMessage(state === 'waiting' ? `Waiting for ${agents === 1 ? '1 agent' : `${agents} agents`}${interrupt}` : state === 'stopping' ? 'Stopping' : `Working${interrupt}`);
     if (spin && !this.spinning) this.loader.start(); else if (!spin && this.spinning) this.loader.stop();
     this.spinning = spin;
+    // Like Pi's own queue: what you sent shows at once, and leaves this list when the agent reads it into the chat.
+    this.queued.clear();
+    const queued = this.live?.queued ?? [];
+    if (queued.length) this.queued.addChild(new Spacer(1));
+    for (const text of queued) this.queued.addChild(new TruncatedText(this.theme.fg('dim', `Steering: ${text.replace(/\s+/g, ' ')}`), 1, 0));
+    if (queued.length) this.queued.addChild(new TruncatedText(this.theme.fg('dim', `↳ ${keyText('app.message.dequeue')} to edit the last one`), 1, 0));
     this.tui.requestRender();
   }
-  render(width: number) { return [...this.body.render(width), ...(this.spinning ? this.loader.render(width) : [])]; }
-  invalidate() { this.body.invalidate(); this.loader.invalidate(); }
+  render(width: number) { return [...this.body.render(width), ...(this.spinning ? this.loader.render(width) : []), ...this.queued.render(width)]; }
+  invalidate() { this.body.invalidate(); this.loader.invalidate(); this.queued.invalidate(); }
   dispose() { clearInterval(this.timer); this.loader.stop(); }
 }
 
@@ -135,6 +144,23 @@ export async function openConnectedWindow(pi: ExtensionAPI, ctx: ExtensionContex
     ctx.ui.setStatus('optchat', `OptChat: ${profile} · connected window · send a task to start`); title('waiting');
     display(`Connected to ${profile}'s original window. Messages here go to one subagent using the profile's subagent model. /tell-main sends a message to the main agent; /complete ends this conversation and sends a handoff. Closing this window interrupts it.`);
   }
+  const failed = (what: string) => (error: unknown) => ctx.ui.notify(`Could not ${what}: ${error instanceof Error ? error.message : String(error)}`, 'error');
+  /** The agent runs in the original window, so Esc and Alt+Up go there; only at the chat's editor, so dialogs and autocomplete keep them. */
+  const unlisten = ctx.ui.onTerminalInput(data => {
+    const tui = liveTurn?.tui, focused = tui instanceof TuiMainScreen || tui instanceof TuiAltScreen ? tui.getFocusedComponent() : undefined;
+    if (ended || !live?.queued || !(focused instanceof Editor) || focused.isShowingAutocomplete() || tui?.hasOverlay()) return;
+    const keys = getKeybindings();
+    if (keys.matches(data, 'app.interrupt') && live.state !== 'stopping' && statusState(live.state, live.agents) === 'working') {
+      connection.request('interrupt').catch(failed('interrupt'));
+      return { consume: true };
+    }
+    if (keys.matches(data, 'app.message.dequeue') && live.queued.length) {
+      connection.request('withdraw').then(text => {
+        if (text !== undefined) ctx.ui.setEditorText([text, ctx.ui.getEditorText()].filter(part => part.trim()).join('\n\n'));
+      }, failed('take the message back'));
+      return { consume: true };
+    }
+  });
   return {
     /** Ended by /complete, by the owner, or by losing the owner: nothing left here to protect from a session switch. */
     get ended() { return ended; },
@@ -150,6 +176,6 @@ export async function openConnectedWindow(pi: ExtensionAPI, ctx: ExtensionContex
         ended = true; connection.close(); ctx.shutdown();
       } finally { ctx.ui.setWorkingMessage(); }
     },
-    close() { ended = true; connection.close(); },
+    close() { ended = true; unlisten(); connection.close(); },
   };
 }

package/src/index.ts

@@ -16,7 +16,7 @@ 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';
 import { registerReportRenderer, type ReportDetails } from './report-message.ts';
 import { memoryTools, result, searchTool } from './tools.ts';
-import { Children, loadedBuiltins, modelsTool, TASKS } from './agents.ts';
+import { Children, loadedBuiltins, modelsTool, refreshContextFiles, TASKS } from './agents.ts';
 import { isActiveRun, type RunInfo } from './runs.ts';
 import { exportBrowser } from './browser.ts';
 import { Inbox } from './inbox.ts';
@@ -168,8 +168,8 @@ export default function optchat(pi: ExtensionAPI) {
       await closeWindows?.(); closeWindows = undefined;
       await recovery;
       await old.children.close(); flush(); if (!pendingImport(old.dir)) old.inbox.recover(old.memory);
+      // No checkpoint here: a host may kill Pi a second after asking it to stop (#220). The next turn's checkpoint commits what this wrote.
       await old.memory.close(); await checkpoints;
-      await checkpoint(old.dir);
     } finally {
       await old.memory.close(); await old.unlock(); active = undefined;
       run = []; previous = []; logged = 0; keep = 0; view = undefined; runStarted = false; receipts.clear(); prompt = ''; idle = () => true;
@@ -387,6 +387,7 @@ export default function optchat(pi: ExtensionAPI) {
     syncSearch(a.config);
     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}`;
+    refreshContextFiles(event.systemPromptOptions);
     prompt = event.systemPrompt;
   });
   const DUPLICATE_REPORT = '(duplicate report, already delivered)';

package/src/memory.ts

@@ -279,14 +279,13 @@ export class Memory {
       }).finally(() => { this.busy.delete(id); this.schedule(); this.events.emit('change'); });
       this.busy.set(id, promise);
     };
-    // A message's node starts once fewer than `jobs` lines before it are unbuilt; a merge, once both halves are built.
-    let ahead = 0;
-    for (const i of this.unbuilt) {
-      if (ahead++ === this.jobs) break;
-      if (this.busy.size >= this.jobs) return;
-      run({ l: 0, i });
-    }
-    for (const part of this.merges.values()) {
+    // A message's node starts once fewer than `jobs` lines before it are unbuilt; a merge, once both halves are built. They start
+    // in the order of the context they end at, a merge first at a tie, as Unii's do (#194): messages first left the merges waiting
+    // through a backlog, so the views ran over budget and changed at every node built, and compactions read about 60% from the cache.
+    const ready: Part[] = [];
+    for (const i of this.unbuilt) { if (ready.length === this.jobs) break; ready.push({ l: 0, i }); }
+    const at = (part: Part) => part.l ? end(part) : part.i;
+    for (const part of [...ready, ...this.merges.values()].sort((a, b) => at(a) - at(b) || b.l - a.l)) {
       if (this.busy.size >= this.jobs) return;
       run(part);
     }

package/src/window-bridge.ts

@@ -1,19 +1,21 @@
 import { chmodSync } from 'node:fs';
 import { createConnection, createServer, type Socket } from 'node:net';
-import type { Children } from './agents.ts';
+import { INTERRUPTED, type Children } from './agents.ts';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { record } from './cache.ts';
 import { checkSocketPath, isWindows, profileSocket, removeStaleSocket } from './profiles.ts';
 import { textContent } from './transcript.ts';
-import { isActiveRun } from './runs.ts';
+import { isActiveRun, type RunInfo } from './runs.ts';
 
-type Action = 'list-agents' | 'attach' | 'start' | 'say' | 'tell-main' | 'answer' | 'complete';
+const ACTIONS = ['list-agents', 'attach', 'start', 'say', 'tell-main', 'answer', 'interrupt', 'withdraw', 'complete'] as const;
+type Action = typeof ACTIONS[number];
+const isAction = (value: unknown): value is Action => ACTIONS.some(action => action === value);
 interface Request { kind: 'request'; id: number; action: Action; text?: string; cwd?: string; activeOnly?: boolean }
 interface Reply { kind: 'reply'; id: number; error?: string; text?: string }
 /** A tool the subagent is running right now, with its streamed output so far. */
 export interface LiveTool { id: string; name: string; args: unknown; output?: unknown; started: number }
-/** What the subagent is doing between finished messages: its streaming reply and running tools. */
-export interface LiveState { state: string; model: string; streaming?: AgentMessage; tools: LiveTool[]; agents?: number }
+/** What the subagent is doing between finished messages: its streaming reply, running tools, and your messages it has not read yet. */
+export interface LiveState { state: string; model: string; streaming?: AgentMessage; tools: LiveTool[]; agents?: number; queued?: string[] }
 /**
  * `from` marks the conversation itself (your messages and the agent's replies); other messages have no `from`.
  * `message` carries the agent's own messages (replies with tool calls, tool results) so the window can draw them with Pi's components.
@@ -28,7 +30,8 @@ const isMessage = (value: unknown): value is AgentMessage => record(value) && (v
 const isLive = (value: unknown): value is LiveState => record(value) && typeof value.state === 'string' && typeof value.model === 'string'
   && (value.streaming === undefined || isMessage(value.streaming))
   && Array.isArray(value.tools) && value.tools.every(t => record(t) && typeof t.id === 'string' && typeof t.name === 'string' && typeof t.started === 'number')
-  && (value.agents === undefined || typeof value.agents === 'number');
+  && (value.agents === undefined || typeof value.agents === 'number')
+  && (value.queued === undefined || Array.isArray(value.queued) && value.queued.every(text => typeof text === 'string'));
 function parse(value: unknown): Frame {
   if (!record(value)) throw new Error('Invalid window message');
   const name = value.name, action = value.action, from = value.from;
@@ -38,7 +41,7 @@ function parse(value: unknown): Frame {
   if (typeof value.id !== 'number' || !Number.isSafeInteger(value.id)) throw new Error('Invalid request ID');
   if (value.kind === 'reply' && (value.error === undefined || typeof value.error === 'string') && (value.text === undefined || typeof value.text === 'string'))
     return { kind: 'reply', id: value.id, error: value.error, text: value.text };
-  if (value.kind === 'request' && (action === 'list-agents' || action === 'attach' || action === 'start' || action === 'say' || action === 'tell-main' || action === 'answer' || action === 'complete')
+  if (value.kind === 'request' && isAction(action)
     && (value.text === undefined || typeof value.text === 'string') && (value.cwd === undefined || typeof value.cwd === 'string')
     && (value.activeOnly === undefined || typeof value.activeOnly === 'boolean'))
     return { kind: 'request', id: value.id, action, text: value.text, cwd: value.cwd, activeOnly: value.activeOnly as boolean | undefined };
@@ -97,7 +100,6 @@ export async function serveWindows(directory: string, children: Children, availa
     connections.add(socket);
     let child: string | undefined, attached = false, cursor = 0, firstUser = true, lastStatus = '', ending = false;
     let finalMessages: AgentMessage[] | undefined;
-    const said = new Set<string>(); // Main-agent guidance and child reports reach the session as user messages too.
     const controller = new AbortController();
     let queue = Promise.resolve();
     const track = (promise: Promise<void>) => { work.add(promise); void promise.finally(() => work.delete(promise)).catch(() => {}); };
@@ -124,13 +126,11 @@ export async function serveWindows(directory: string, children: Children, availa
               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 = 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.
             attached = true; child = id; finalMessages = live ? undefined : messages;
-            for (const guidance of info.guidance) if (guidance.from === 'user') said.add(guidance.text.trim());
             send({ kind: 'event', name: 'started', text: child });
-            drainMessages(messages, info.task);
+            drainMessages(messages, info);
           } else if (frame.action === 'start') {
             if (child) throw new Error('This window already has a conversation');
             if (!available()) throw new Error('Profile is importing or shutting down; try again when it is ready');
@@ -146,16 +146,25 @@ export async function serveWindows(directory: string, children: Children, availa
               if (text.length > ANSWER_LIMIT) throw new Error(`The reply is over ${ANSWER_LIMIT.toLocaleString('en')} characters; the original Pi window has it in full`);
               send({ kind: 'reply', id: frame.id, text }); return;
             }
+            // Esc and Alt+Up in the window, as agent-view.ts does them in the main one.
+            if (frame.action === 'interrupt') {
+              // Reply once the abort has started, not when it ends, so a tool that ignores it can't hold up this window.
+              // interrupt() throws before it starts the abort, so a refusal is already settled and wins the race.
+              const interrupting = children.interrupt(child);
+              track(interrupting.then(() => {}));
+              send({ kind: 'reply', id: frame.id, text: await Promise.race([interrupting, undefined]) }); return;
+            }
+            if (frame.action === 'withdraw') { send({ kind: 'reply', id: frame.id, text: children.withdraw(child) }); return; }
             if (frame.action === 'complete') {
               const live = children.live(child);
-              if (live) drainMessages(children.retained(child), live.info.task);
+              if (live) drainMessages(children.retained(child), live.info);
               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.'
                 : 'Conversation ended by you. The original window is stopping remaining work and preparing the handoff.' });
             } else {
               if (!frame.text?.trim()) throw new Error('Message is empty');
-              if (frame.action === 'say') { said.add(frame.text.trim()); await children.tell(child, frame.text, 'user'); }
+              if (frame.action === 'say') await children.tell(child, frame.text, 'user');
               else await report(`[${child}] User message from connected window: ${frame.text}`);
             }
           }
@@ -164,7 +173,8 @@ export async function serveWindows(directory: string, children: Children, availa
       });
       track(queue);
     });
-    const drainMessages = (messages: AgentMessage[], task: string) => {
+    /** Main-agent guidance and child reports reach the session as user messages too; only what the user sent, from any view, shows as theirs. */
+    const drainMessages = (messages: AgentMessage[], info: RunInfo) => {
       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, which stays valid because
@@ -174,8 +184,14 @@ export async function serveWindows(directory: string, children: Children, availa
         if (batch++ >= 32 || socket.writableLength > 1_000_000) return false;
         const message = displayable[cursor++];
         let text = message.role === 'toolResult' ? '' : textContent(message.content);
-        if (message.role === 'user' && firstUser) { text = task; firstUser = false; said.add(task.trim()); }
-        if (message.role === 'user') { if (text) send({ kind: 'event', name: 'message', from: said.has(text.trim()) ? 'user' : undefined, text: shorten(text, 200_000) }); continue; }
+        const task = message.role === 'user' && firstUser;
+        if (task) { text = info.task; firstUser = false; }
+        if (message.role === 'user') {
+          // The task, and an interrupt, which continues with your queued messages, are yours too.
+          const yours = task || text.startsWith(INTERRUPTED) || info.guidance.some(g => g.from === 'user' && g.text === text.trim());
+          if (text) send({ kind: 'event', name: 'message', from: yours ? 'user' : undefined, text: shorten(text, 200_000) });
+          continue;
+        }
         const clipped = clip(message);
         if (fits(clipped)) send({ kind: 'event', name: 'message', from: message.role === 'assistant' ? 'agent' : undefined, text: shorten(text, 200_000), message: clipped });
         else if (text) send({ kind: 'event', name: 'message', from: 'agent', text: shorten(text, 200_000) });
@@ -191,19 +207,20 @@ 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(children.retained(child), info.task);
+      if (live) drainMessages(children.retained(child), info);
       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,
         streaming: live?.streaming?.role === 'assistant' ? clip(live.streaming) : undefined,
         tools: live ? [...live.tools].map(([id, t]) => ({ id, name: t.name, args: t.args, output: clipOutput(t.output), started: t.started })) : [],
         // A finished child counts until its report has reached this agent, so the agent never looks idle in between.
-        agents: [...children.history.records.values()].filter(run => run.parentId === child && (isActiveRun(run) || children.live(run.id))).length };
+        agents: [...children.history.records.values()].filter(run => run.parentId === child && (isActiveRun(run) || children.live(run.id))).length,
+        queued: info.guidance.flatMap(g => g.state === 'queued' && g.from === 'user' ? [g.text.slice(0, 1000)] : []) };
       if (!fits(state)) state = { ...state, streaming: undefined, tools: state.tools.map(t => ({ ...t, args: {}, output: undefined })) };
       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.retained(child), info.task)) return; }
+        try { if (!drainMessages(finalMessages ??= children.retained(child), info)) 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.' });