pi-optchat 0.6.8 → 0.7.0

package/README.md

@@ -76,8 +76,10 @@ Compression and subagents make extra model requests with your provider credentia
 | Subagent model | Opus 5.5, high | Same as `/optchat agents model`. Applies to new subagents. |
 | Subagent levels | 1 | 1: only the main agent starts subagents (the recipe). 2 or more: subagents may start their own, that many levels deep. Applies to subagents started or resumed after the change. |
 | Max active agents | 8 | Subagents running at once in the profile, all levels together, so it also caps how deep a chain can go. |
+| Group subagent reports | on | The subagents started by one spawn report together, in one message once the last of them finishes (the recipe). Off: each reports as soon as it finishes. Applies to the next spawn. |
 | Previous exchange | on | Replays your last request and answer in full with the next turn (see below). Off is the recipe. |
 | Previous exchange limit | 16 KB | A larger last exchange is left out. |
+| Memory search | off | Gives the agent, and subagents started or resumed after the change, a `search` tool over your original messages (see below). Off is the recipe: zoom and date only. Applies from the next turn. |
 | Summary size tolerance | 640 bytes | The compactor is always asked for 512-byte lines; a longer line up to this size is kept instead of retried. 512 is the recipe's strict rule. |
 
 Numbers must be whole numbers of at least 1 (512 for the summary size tolerance). Missing keys in an older `config.json` take their defaults.
@@ -92,7 +94,7 @@ Ask in plain words, for example: "Spawn an agent to investigate this repository
 
 - Children get the profile's memory view (frozen at launch), its instructions, read-only `zoom`/`date`, and normal coding tools plus your installed extensions.
 - Children also get the Pi built-in extensions the main session loaded: MCP, codemode and tool search. Your MCP servers (`~/.pi/agent/mcp.json`, the project's `.pi/mcp.json`) work in subagents, with the sign-ins you made in Pi. If MCP is off in the main session (`--no-mcp`, `-builtin:mcp` in settings, or an extension that replaces `/mcp`), it is off in subagents too. Each subagent opens its own server connections (stdio servers start once per subagent) and closes them when it ends.
-- Each child reports back on its own when it finishes. The parent stays alive to receive reports; it never polls.
+- The children of one spawn report together: when the last of them finishes, their reports reach the parent as one message, `[id] report` each, in spawn order. A stopped or failed child counts as finished, with its stop or error text as its report. Each finished report is journaled right away, so if Pi dies before the rest finish, the reports it already has are delivered at the next start. Turn **Group subagent reports** off to get each report as soon as its child finishes. Messages sent with `tell_parent`, connected windows and their handoffs are never held back, and a child resumed with `tell` reports on its own. The parent stays alive to receive reports; it never polls.
 - In the main chat, subagent messages and reports appear in a dark grey box labelled `↳ subagent <id> · still running` or `· report`, so they don't look like something you typed. The model still receives them as ordinary user messages. (One exception: reports recovered at startup, before your first message in the session, still show as plain user messages.)
 - The parent can send a running child guidance with `tell`, and the child can message its parent mid-run with `tell_parent` (a question, an early finding). It reaches the parent like a report, marked "still running": between tool calls if the parent is busy, or waking it if it's waiting.
 - `tell` to a finished child resumes it: the same agent (ID, parent, model, directory) reopens its saved transcript, gets the message as a new prompt, and sends a new report. This also works for children from earlier Pi sessions. Only the agent that started the child can resume it, and the resumed child takes one active slot. Connected windows can't be resumed, and a child whose transcript is missing must be spawned fresh.
@@ -146,13 +148,13 @@ Pick the destination profile, then run `/optchat import`.
 3. **Mode** (only if the profile already has history):
    - **Append**: keep existing summaries and add the import. Faster and cheaper.
    - **Rebuild by conversation start date**: regenerate the whole tree, ordered by conversation start.
-4. **Preview**: destination, new and duplicate counts, text size, rough token estimate, and compactor. This is not a price quote.
+4. **Preview**: destination, new and duplicate counts, text size, rough token estimate, and compactor. This is not a price quote: a big import costs about 3x that estimate in compactor input, because every message is summarized and then re-read in merges, each with the memory view as (mostly cached) context.
 
-**What gets imported**: user messages and final assistant replies, with original dates and source labels, as in Victor's recipe. Tool calls and results, intermediate commentary, reasoning, subagent transcripts, replayed context, and image/audio/file bytes are left out. ChatGPT alternate branches are labelled as alternatives. Imported records are marked as historical so old requests are not treated as new instructions.
+**What gets imported**: user messages and final assistant replies, with original dates and source labels, as in Victor's recipe. Tool calls and results, intermediate commentary, reasoning, subagent transcripts, replayed context, and image/audio/file bytes are left out. So is the output Claude Code logs for slash and shell commands; the command itself stays as typed (`/name args` or `!command`). So are the context messages Codex injects, such as the AGENTS.md instructions and the environment context. Dropped text never becomes a conversation's title. ChatGPT alternate branches are labelled as alternatives. Imported records are marked as historical so old requests are not treated as new instructions.
 
 **Claude Code memories**: the auto-memory topic files in `~/.claude/projects/*/memory/` (not `MEMORY.md`, which only indexes them), picked by project. Each file becomes one dated note in the memory tree, not part of the prompt. An edited file comes in again as a newer note.
 
-**Duplicates**: re-importing skips messages already present, even if titles or paths changed. Changed source messages can appear as a separate historical version.
+**Duplicates**: re-importing skips messages already present, even if titles or paths changed. A resumed Claude Code session copies earlier messages into its own file; those copies are matched by message id and text, so they come in once, also against messages an earlier import stored. Changed source messages can appear as a separate historical version.
 
 **Pausing**: **Pause import** (or Escape) saves progress, and so does restarting Pi. `/optchat import` then offers **Resume** or **Discard staged import**. While an import is pending, chat in that profile is blocked; other profiles still work. Imports need the main agent and its subagents to be idle.
 
@@ -212,14 +214,15 @@ To delete a profile, delete its folder. Your original Pi sessions are kept in Pi
 
 ## How it differs from the recipe
 
-The recipe's four prompts are kept verbatim in `src/prompts.ts`, along with its numbers: 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; see Summary size tolerance), a 128,000-byte memory view, binary merges, 8 compression workers, fixed retry delays, 5 shortening attempts, and a 30,000-character tool output cap. Anthropic requests get stable cache breakpoints on the view, and when that view is not cached yet, one compactor call goes first and the others wait until it starts answering, so they read the cache instead of each writing it. See `docs/victor-recipe.md` for notes.
+The recipe's four prompts are kept verbatim in `src/prompts.ts` (the view doc adds one sentence: you can zoom out too, from a message to the summaries above it), along with its numbers: 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; see Summary size tolerance), a 128,000-byte memory view, binary merges, 8 compression workers, fixed retry delays, 5 shortening attempts, and a 30,000-character tool output cap. Each compactor request shows a 512-byte example line for scale. It is a true line about OptChat itself, labelled as not from the chat and fenced off in `<example>` tags, with the text to summarize in `<input>` tags: shown bare, a made-up example was sometimes summarized as if it were chat and spread up the tree. Anthropic requests get stable cache breakpoints on the view, and when that view is not cached yet, one compactor call goes first and the others wait until it starts answering, so they read the cache instead of each writing it. See `docs/victor-recipe.md` for notes.
 
 Each run's context is the memory view, the previous exchange, and your new message. Deliberate additions (the ones that change the recipe's behaviour are settings, see [Settings](#settings)):
 
 1. **Previous exchange kept verbatim.** Your last request (with any steering) and the final answer are included in full, so "why is that?" refers to what you actually read. Tool calls and reasoning are not carried over. It comes on top of the 128,000-byte view. If it is over 16,000 bytes (about 4,000 tokens, usually a big paste; Previous exchange limit) it is left out entirely, and the model relies on the view and zoom as in Victor's recipe. A new Pi session starts with the memory view only.
-2. **Subagents** are built in with Pi's SDK rather than a separate package. Children report individually instead of per batch, and with Subagent levels above 1 they can delegate further.
-3. **Profiles**, the **inspector**, the **usage ledger**, **import**, and **connected windows** are additions. Import adds historical-record guidance to the prompts.
-4. **Not done**: computer use and hosting on an always-on machine.
+2. **Subagents** are built in with Pi's SDK rather than a separate package. With Subagent levels above 1 they can delegate further.
+3. **Memory search** (off by default). With the setting on, the agent also gets `search(text, before?)`: plain, case-insensitive text matching over the original messages, never the summaries (a summary can be wrong, and one fact repeats at every level of the tree), skipping logged zoom and search results. It returns 20 hits at a time, newest first, each with its id, the view line that holds it when that is a summary (`1234 (in 1024+256)`), its date and a snippet; `before: id` pages back, and `zoom(id, 1)` reads a hit. One line about it is added to the system prompt. Turning it on or off changes the cached prompt once.
+4. **Profiles**, the **inspector**, the **usage ledger**, **import**, and **connected windows** are additions. Import adds historical-record guidance to the prompts.
+5. **Not done**: computer use and hosting on an always-on machine.
 
 ## Development
 
@@ -242,12 +245,12 @@ npm run test:live  # paid Anthropic calls on synthetic data in a disposable prof
 
 Pi's [package directory](https://github.com/earendil-works/pi/blob/main/packages/coding-agent/docs/packages.md) lists npm packages with the `pi-package` keyword, which the manifest already has. GitHub alone is not enough.
 
-```sh
-npm ci --ignore-scripts
-npm run check && npm test
-npm pack --dry-run
-npm publish --access public
-```
+Publishing a GitHub release publishes to npm. The [Publish workflow](.github/workflows/publish.yml) uses npm trusted publishing, so no token or `npm login` is involved:
+
+1. Merge a PR that bumps `version` in `package.json`.
+2. `gh release create vX.Y.Z --target main --generate-notes`
+
+The workflow checks that the tag matches `package.json`, runs the type check and tests, and publishes with provenance. It skips versions already on npm. To retry a tag, run it by hand: `gh workflow run publish.yml -f tag=vX.Y.Z`.
 
 ## Credits and license
 

package/docs/victor-recipe.md

@@ -10,12 +10,12 @@ The source remains upstream rather than duplicating the full article here. Its f
 
 ## Implementation mapping
 
-- `src/memory.ts`: append-only log, binary summary tree, compression scheduling, bounded view, zoom/date.
+- `src/memory.ts`: append-only log, binary summary tree, compression scheduling, bounded view, 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.
-- `src/cache.ts`: stable Anthropic cache boundaries.
+- `src/cache.ts`: stable Anthropic cache boundaries. OpenAI requests get no marks: GPT-5.6 rejects 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 (one subagent level), except the previous exchange (on) and the summary size tolerance (640 bytes, against the recipe's strict 512).
-- `src/import/`: profile-scoped historical imports retain user messages and final assistant replies, following the lighter history described in recipe section 10. Source adapters, final-reply detection, replay filtering, and ChatGPT branch labels are integration choices. Live-chat tool logging remains unchanged.
+- `src/settings.ts`: per-profile settings for the departures from the recipe. Defaults are the recipe's (one subagent level, no memory search), except the previous exchange (on) and the summary size tolerance (640 bytes, against the recipe's strict 512).
+- `src/import/`: profile-scoped historical imports retain user messages and final assistant replies, following the lighter history described in recipe section 10. An import hands `Memory` one message at a time, each once the one before it is summarized, so the compactor sees the view a live chat would have shown it. Source adapters, final-reply detection, replay filtering, and ChatGPT branch labels are integration choices. Live-chat tool logging remains unchanged.
 
 Profiles, native Pi UI, conversation import, and local Git checkpoints are integration choices described in the README.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-optchat",
-  "version": "0.6.8",
+  "version": "0.7.0",
   "type": "module",
   "pi": {
     "extensions": [
@@ -10,7 +10,7 @@
   },
   "scripts": {
     "check": "tsc --noEmit",
-    "test": "tsx --test test/*.test.ts",
+    "test": "tsx --import ./test/support.ts --test test/*.test.ts",
     "test:live": "tsx test/live.ts"
   },
   "devDependencies": {

package/src/agents.ts

@@ -7,7 +7,7 @@ import * as sdk from '@earendil-works/pi-coding-agent';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { Api, Model } from '@earendil-works/pi-ai';
 import { SUBAGENT, VIEW_DOC } from './prompts.ts';
-import { memoryTools } from './tools.ts';
+import { memoryTools, SEARCH_DOC, searchTool } from './tools.ts';
 import { type Memory } from './memory.ts';
 import type { ModelChoice } from './compactor.ts';
 import { cachePayload } from './cache.ts';
@@ -23,12 +23,16 @@ 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>;
+  /** Shared by the children of one spawn whose reports are delivered together, in spawn order. */
+  batch?: { ids: string[]; reports: Map<string, string> };
 }
 interface Options { parentSession?: string; usage?: UsageLedger; createSession?: typeof createAgentSession;
   /** Names of the built-in extensions the main session loaded (see `loadedBuiltins`). */
   builtins?: () => Iterable<string>;
-  /** Read on every spawn, so a changed profile setting applies to the next one. */
-  settings?: () => Pick<Settings, 'subagentLevels' | 'maxAgents'>;
+  /** Journals the reports a main-agent spawn has so far while its other children still run (none: the batch was delivered), so a crash cannot lose them. */
+  hold?: (batch: string, texts: string[]) => void;
+  /** Read on every spawn, so a changed profile setting applies to the next one. Missing settings take their defaults. */
+  settings?: () => Partial<Settings>;
   summarizeHandoff?: (run: RunInfo, messages: AgentMessage[], descendants?: HandoffEvidence[]) => Promise<string> }
 
 // Subagents load the user's installed extensions, except any copy of OptChat itself: they get memory tools directly and must not open a profile.
@@ -72,7 +76,7 @@ export class Children {
   private readonly completions = new Set<Promise<void>>();
   constructor(private readonly memory: Memory, private readonly registry: ModelRegistry,
     private readonly choice: () => ModelChoice, private readonly instructions: () => string,
-    private readonly report: (text: string, once?: boolean) => Promise<void>, private readonly warn: (text: string) => void,
+    private readonly report: (text: string, options?: { once?: boolean; count?: number }) => Promise<void>, private readonly warn: (text: string) => void,
     private readonly profileDirectory = memory.directory, private readonly options: Options = {}) {
     this.history = new RunHistory(profileDirectory);
     for (const warning of this.history.warnings) warn(warning);
@@ -84,7 +88,7 @@ export class Children {
       } catch (error) { warn(`Could not backfill child usage for ${run.id}: ${String(error)}`); }
     }
   }
-  private get settings() { return this.options.settings?.() ?? DEFAULT_SETTINGS; }
+  private get settings(): Settings { return { ...DEFAULT_SETTINGS, ...this.options.settings?.() }; }
   private full(extra: number) { return this.running.size + this.launching + extra > this.settings.maxAgents; }
   get ids() { return [...this.running.keys()]; }
   get active() { return this.completions.size > 0 || this.launching > 0 || this.settling > 0; }
@@ -123,6 +127,14 @@ export class Children {
     } catch (error) { this.warn(`Could not record subagent activity: ${String(error)}`); }
   }
   async spawn(tasks: { task: string; cwd?: string }[], cwd: string, signal?: AbortSignal, parentId?: string, connected = false) {
+    return (await this.launch(tasks, cwd, signal, parentId, connected)).ids;
+  }
+  /** The spawn tools' answer, saying how this spawn's reports will come back. */
+  async start(tasks: { task: string; cwd?: string }[], cwd: string, signal?: AbortSignal, parentId?: string) {
+    const { ids, grouped } = await this.launch(tasks, cwd, signal, parentId);
+    return `Started: ${ids.join(', ')}. ${grouped && ids.length > 1 ? 'Their reports will arrive together, as one message, once all of them have finished.' : 'Reports will arrive automatically.'}`;
+  }
+  private async launch(tasks: { task: string; cwd?: string }[], cwd: string, signal: AbortSignal | undefined, parentId: string | undefined, connected = false) {
     for (const directory of tasks.map(t => taskDirectory(cwd, t.cwd))) if (!existsSync(directory) || !statSync(directory).isDirectory()) throw new Error(`No such directory: ${directory}`);
     if (this.closing) throw new Error('Profile is closing.');
     this.settling++;
@@ -131,7 +143,7 @@ export class Children {
     const cancelled = () => this.closing || (parentId !== undefined && this.running.get(parentId)?.info.state !== 'running');
     if (parentId && (!parent || parent.info.state !== 'running')) throw new Error('The parent is no longer running.');
     const depth = parent ? parent.info.depth + 1 : 1;
-    const { subagentLevels, maxAgents } = this.settings;
+    const { subagentLevels, maxAgents, groupReports } = this.settings;
     if (depth > subagentLevels) throw new Error(`Delegation depth limit reached: this profile allows ${subagentLevels} level${subagentLevels === 1 ? '' : 's'} of subagents.`);
     if (this.closing) throw new Error('Profile is closing.');
     if (this.full(tasks.length)) throw new Error(`Profile limit: at most ${maxAgents} active agents, including parents and descendants. Reduce the batch or continue without delegating.`);
@@ -140,15 +152,17 @@ export class Children {
     const model = this.registry.find(selected.provider, selected.model);
     if (!model) throw new Error(`Subagent model unavailable: ${selected.provider}/${selected.model}`);
     const launched = await this.track(this.launchBatch({ tasks, cwd, depth, parentId, connected, selected, model, signal, cancelled }));
-    // Each child reports independently. A slow sibling must not hold back a finished result.
+    // 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;
     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(); });
       this.completions.add(work);
       live.completion = work;
     }
     this.changed();
-    return launched.map(c => c.info.id);
+    return { ids: launched.map(c => c.info.id), grouped: batch !== undefined };
   }
   /** close() waits for launches, so shutdown never unlocks the profile under a child that is still opening. */
   private track<T>(launch: Promise<T>) {
@@ -195,7 +209,7 @@ export class Children {
   private async open(o: { id: string; directory: string; depth: number; parentId?: string; connected: boolean; provider: string; model: Model<Api>;
     thinking?: ModelChoice['thinking']; sessionManager: SessionManager }) {
     const { id, directory, depth, parentId, connected } = o;
-    const { subagentLevels, maxAgents } = this.settings, delegates = depth < subagentLevels;
+    const { subagentLevels, maxAgents, memorySearch } = this.settings, delegates = depth < subagentLevels;
     const delegation = delegates ? `You may delegate parts of your assigned task with spawn when useful. Child reports arrive automatically after your current run ends; the harness keeps you alive to receive them. Never poll, sleep, or wait in a tool for children. Finish your current work and return; you will be prompted with their results. The profile allows ${maxAgents} active agents total.` : 'You are at the maximum delegation depth. Complete your task with your own tools.';
     const instructions = [this.instructions(), delegation, connected ? 'You are speaking directly with the user in a connected window. Continue this conversation across requests. Use tell_parent for questions or findings the main agent needs now. A handoff will be generated when the user completes or disconnects the window.'
       : 'Use tell_parent only when your parent needs something now (a blocking question, an important early finding, or when asked to). Your final answer is delivered automatically; do not repeat it with tell_parent.'].filter(Boolean).join('\n\n');
@@ -209,7 +223,7 @@ export class Children {
         if (provider) pi.registerProvider(o.provider, provider);
         // Same prompt as the main agent (AGENTS.md files, skills, cwd); only the OptChat preamble differs.
         pi.on('before_agent_start', event => {
-          event.systemPromptOptions.customPrompt = `${SUBAGENT}\n\n${VIEW_DOC}`;
+          event.systemPromptOptions.customPrompt = `${SUBAGENT}\n\n${VIEW_DOC}${memorySearch ? SEARCH_DOC : ''}`;
           event.systemPromptOptions.sections.instructions = instructions;
         });
         pi.on('before_provider_request', (event, ctx) => ctx.model?.api === 'anthropic-messages' ? cachePayload(event.payload) : event.payload);
@@ -218,7 +232,7 @@ export class Children {
     await loader.reload();
     const { session } = await (this.options.createSession ?? createAgentSession)({ cwd: directory, resourceLoader: loader, settingsManager,
       model: o.model, thinkingLevel: o.thinking, sessionManager: o.sessionManager,
-      customTools: [...memoryTools(() => this.memory), ...(delegates ? this.delegationTools(id, directory, subagentLevels, maxAgents) : []), this.parentTool(id, parentId, connected)],
+      customTools: [...memoryTools(() => this.memory), ...(memorySearch ? [searchTool(() => this.memory)] : []), ...(delegates ? this.delegationTools(id, directory, subagentLevels, maxAgents) : []), this.parentTool(id, parentId, connected)],
       excludeTools: delegates ? [] : ['spawn', 'tell'],
     });
     // Callers track the session only after this returns: clean up here if its extensions fail to start.
@@ -229,7 +243,7 @@ export class Children {
   private delegationTools(parentId: string, cwd: string, levels: number, maxAgents: number) {
     return [{ name: 'spawn', label: 'Delegate task', description: `Delegate parts of your task. Results arrive automatically after this run; never poll or sleep waiting. Maximum depth ${levels} and ${maxAgents} active agents per profile.`,
       parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String({ description: CWD_DOC })) }), { minItems: 1 }) }),
-      execute: async (_id: string, args: { tasks: { task: string; cwd?: string }[] }, signal?: AbortSignal) => result(`Started: ${(await this.spawn(args.tasks, cwd, signal, parentId)).join(', ')}. Results will arrive automatically.`),
+      execute: async (_id: string, args: { tasks: { task: string; cwd?: string }[] }, signal?: AbortSignal) => result(await this.start(args.tasks, cwd, signal, parentId)),
     }, { name: 'tell', label: 'Guide child', description: 'Send guidance to one of your direct children. A finished child is resumed with its earlier conversation, and its new report arrives automatically.',
       parameters: Type.Object({ id: Type.String(), message: Type.String() }),
       execute: async (_id: string, args: { id: string; message: string }) => {
@@ -317,18 +331,27 @@ export class Children {
     }
     // A metadata failure must not suppress delivery of the actual result.
     try { this.save(info); } catch (error) { this.warn(`Could not save run metadata: ${String(error)}`); }
-    const text = `[${info.id}] ${info.report}`;
+    let text = `[${info.id}] ${info.report}`;
+    const batch = live.batch;
+    let count: number | undefined;
+    if (batch) {
+      batch.reports.set(info.id, text);
+      const texts = batch.ids.flatMap(id => batch.reports.get(id) ?? []);
+      if (texts.length < batch.ids.length) { if (!info.parentId) this.options.hold?.(batch.ids[0], texts); return; }
+      text = texts.join('\n\n'); count = texts.length;
+    }
     if (info.parentId) {
       const parent = this.running.get(info.parentId);
       if (parent && parent.info.state !== 'stopping') { parent.pendingReports.push(text); this.changed(); }
       return;
     }
-    if (this.closing) { this.memory.append('user', text); return; }
-    try { await this.report(text); }
+    if (this.closing) this.memory.append('user', text);
+    else try { await this.report(text, { count }); }
     catch (error) {
       this.memory.append('user', text);
       this.warn(`Subagent report saved but could not wake the parent: ${String(error)}`);
     }
+    if (batch && batch.ids.length > 1) this.options.hold?.(batch.ids[0], []);
   }
   /** `caller` is the agent sending a manager message: undefined for the main agent, else the parent subagent's ID. */
   async tell(id: string, message: string, source: 'manager' | 'user' = 'manager', caller?: string) {
@@ -440,7 +463,7 @@ export class Children {
       handoff.text = `[${run.id}] Connected conversation ${handoff.reason === 'complete' ? 'completed by user' : `interrupted (${handoff.reason})`}. This describes the conversation ending, not proof that every task succeeded.\n${summary}\n${source}`;
       run.report = handoff.text; this.save(run);
     }
-    await this.report(handoff.text, true);
+    await this.report(handoff.text, { once: true });
     handoff.delivered = true; this.save(run);
   }
   async stop(id: string) {

package/src/compactor.ts

@@ -1,4 +1,4 @@
-import type { AssistantMessage, Message } from '@earendil-works/pi-ai';
+import { clampThinkingLevel, type Api, type AssistantMessage, type Message, type Model } from '@earendil-works/pi-ai';
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
 import { COMPACT } from './prompts.ts';
@@ -8,8 +8,14 @@ import { IMPORT_GUIDANCE } from './import/guidance.ts';
 import { DEFAULT_SETTINGS } from './settings.ts';
 
 export interface ModelChoice { provider: string; model: string; thinking: ThinkingLevel }
-/** A realistic summary line of exactly NODE bytes, on a topic no real chat shares so its wording can't leak into summaries. */
-export const SCALE = 'user: Plan the Lisbon trip for 14-18 May: four adults, one in a wheelchair, 2400 EUR budget, no flights before 09:00. talk: Suggested Baixa; skip tram 28 (not step-free). tool: searched TAP, easyJet fares; echo: TAP TP1205 at 08:40 (too early), easyJet U27652 at 11:15 is 162 EUR each. user: "Book easyJet; step-free rooms matter more than a view." work: [4c1e9a20] Casa do Rio has two step-free rooms at 138 EUR/night, free cancellation to 10 May, held to 2 May. talk: Asked about a Sintra day trip, unanswered.';
+/** A level the model can't take would be sent as no level, which Sonnet 5.5 runs at high effort; Pi's own sessions clamp the same way. */
+export const reasoningFor = (model: Model<Api>, level: ThinkingLevel) => {
+  const thinking = clampThinkingLevel(model, level);
+  return thinking === 'off' ? undefined : thinking;
+};
+/** The size example: a line of exactly NODE bytes about OptChat itself. Every claim in it is true and timeless (no ids, PRs or decisions),
+ * so a summary that copies it states nothing false; the request also fences it off from the input. */
+export const SCALE = 'note: How OptChat memory works. Each message becomes a leaf line: a short message is its own line, a longer one is compressed to about 512 bytes. Adjacent lines merge in pairs into a binary tree: two lines into one line covering both, two of those into one covering four, and so on. The view shows recent messages one per line and older ones more per line, within a fixed byte budget. zoom(id, n) opens line id+n into the two lines it was made from, down to the original message; date(id) tells when it was sent.';
 const WARM_MS = 4 * 60_000; // Anthropic's short cache lives 5 minutes from its last use.
 
 /** Parallel calls can't read a cache entry that isn't written yet, so one call primes a cold prefix and the rest wait until it answers. */
@@ -45,17 +51,21 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
     const selected = choice();
     const model = registry.find(selected.provider, selected.model);
     if (!model) throw new Error(`Compactor model unavailable: ${selected.provider}/${selected.model}. Use /optchat model.`);
-    const step = `${input.historical ? IMPORT_GUIDANCE + '\n\n' : ''}For scale, this line is exactly 512 bytes:\n${SCALE}\n\n${input.merge ? 'Merge these two lines into one' : 'Compress this message into one line'}, in at most 512 bytes:\n${input.source}`;
+    const thinking = reasoningFor(model, selected.thinking);
+    // Shown bare between the view and the input, the example was sometimes summarized as if it were chat, so it is labelled and both are tagged.
+    const step = `${input.historical ? IMPORT_GUIDANCE + '\n\n' : ''}For scale only, here is an example line, not from this chat; it is exactly 512 bytes and is never part of your input or your line:\n<example>${SCALE}</example>\n\n${input.merge ? 'Merge these two lines into one' : 'Compress this message into one line'}, in at most 512 bytes:\n<input>\n${input.source}\n</input>`;
     const messages: Message[] = [{ role: 'user', content: [{ type: 'text', text: input.context }, { type: 'text', text: step }], timestamp: Date.now() }];
     const view = splitView(input.context);
-    const prefix = model.api === 'anthropic-messages' && view.length > 1 ? `${model.provider}/${model.id}/${selected.thinking}\n${view.slice(0, -1).join('')}` : undefined;
+    const prefix = model.api === 'anthropic-messages' && view.length > 1 ? `${model.provider}/${model.id}/${thinking ?? 'off'}\n${view.slice(0, -1).join('')}` : undefined;
     const tries: string[] = [];
     for (let attempt = 0; attempt < 5; attempt++) {
       const warmed = prefix ? await gate(prefix, signal) : () => {};
       let reply: AssistantMessage;
       try {
         const stream = registry.streamSimple(model, { systemPrompt: COMPACT, messages }, {
-          reasoning: selected.thinking === 'off' ? undefined : selected.thinking, signal, cacheRetention: 'short',
+          // 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,
         });
         // The cache entry is usable once the model starts answering.

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 type { ModelChoice } from './compactor.ts';
+import { reasoningFor, type ModelChoice } from './compactor.ts';
 import type { RunInfo } from './runs.ts';
 import { textContent } from './transcript.ts';
 
@@ -53,7 +53,7 @@ export function createHandoffSummarizer(registry: ModelRegistry, choice: () => M
       const reply = await registry.streamSimple(model, {
         systemPrompt: SYSTEM,
         messages: [{ role: 'user', timestamp: Date.now(), content: prefix + transcript.subarray(offset, end).toString('utf8') }],
-      }, { reasoning: selected.thinking === 'off' ? undefined : selected.thinking, maxTokens, signal: AbortSignal.timeout(300_000) }).result();
+      }, { reasoning: reasoningFor(model, selected.thinking), maxTokens, signal: AbortSignal.timeout(300_000) }).result();
       usage(reply);
       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');

package/src/import/job.ts

@@ -1,10 +1,10 @@
 import { existsSync, readFileSync, rmSync, cpSync, mkdirSync } from 'node:fs';
 import { join, relative } from 'node:path';
 import { randomUUID } from 'node:crypto';
-import { Memory, bytes, type Entry, type Compressor } from '../memory.ts';
+import { Memory, bytes, isEntry, type Entry, type Compressor } from '../memory.ts';
 import { atomicWrite } from '../profiles.ts';
 import { record } from '../cache.ts';
-import type { ImportedEntry } from './sources.ts';
+import { copyKey, type ImportedEntry } from './sources.ts';
 
 export type ImportMode = 'append' | 'rebuild';
 export interface ImportJob {
@@ -12,6 +12,8 @@ export interface ImportJob {
   added: number; skipped: number; total: number; inputBytes: number;
 }
 const pendingFile = (dir: string) => join(dir, 'imports', 'pending.json');
+// The whole planned log. `main/` holds only the part already given to Memory, so resume continues from its length.
+const STAGED = 'staged.jsonl';
 function generationPath(dir: string, name: string) {
   if (name !== '.' && !/^memories\/[a-f0-9-]{36}$/.test(name)) throw new Error('Invalid memory generation path.');
   return join(dir, name);
@@ -38,11 +40,13 @@ export function pendingImport(dir: string): ImportJob | undefined {
 }
 export function deduplicate(existing: readonly Entry[], incoming: readonly ImportedEntry[]) {
   const receipts = new Set(existing.map(e => e.receipt).filter(Boolean));
+  const copies = new Set(existing.map(copyKey).filter(Boolean));
   const added: ImportedEntry[] = []; let skipped = 0;
   for (const entry of incoming) {
     if (!entry.receipt?.startsWith('import:')) throw new Error('Imported entry has no stable source identity.');
-    if (receipts.has(entry.receipt)) { skipped++; continue; }
-    receipts.add(entry.receipt); added.push(entry);
+    const copy = copyKey(entry);
+    if (receipts.has(entry.receipt) || copy && copies.has(copy)) { skipped++; continue; }
+    receipts.add(entry.receipt); if (copy) copies.add(copy); added.push(entry);
   }
   return { added, skipped };
 }
@@ -68,8 +72,10 @@ export function prepareImport(dir: string, old: Memory, incoming: readonly Impor
   // Append copies existing summaries without changing their indices. Rebuild regenerates every node.
   const all = mode === 'rebuild' ? chronological([...old.root, ...added]) : [...old.root, ...chronological(added)];
   const entries: Entry[] = all.map((e, i) => ({ ...e, i, size: bytes(`${e.kind}: ${e.text}`) }));
-  mkdirSync(join(path, 'tree'), { recursive: true, mode: 0o700 });
-  atomicWrite(join(path, 'main', '000-import.jsonl'), entries.map(e => JSON.stringify(e)).join('\n') + '\n');
+  const kept = mode === 'append' ? old.root.length : 0;
+  for (const sub of ['main', 'tree']) mkdirSync(join(path, sub), { recursive: true, mode: 0o700 });
+  if (kept) atomicWrite(join(path, 'main', '000-import.jsonl'), entries.slice(0, kept).map(e => JSON.stringify(e)).join('\n') + '\n');
+  atomicWrite(join(path, STAGED), entries.map(e => JSON.stringify(e)).join('\n') + '\n');
   if (mode === 'append') cpSync(join(old.directory, 'tree'), join(path, 'tree'), { recursive: true });
   const job: ImportJob = { id, mode, previous: relative(dir, old.directory) || '.', target,
     created: new Date().toISOString(), added: added.length, skipped, total: entries.length,
@@ -88,17 +94,26 @@ export async function runImport(dir: string, compress: Compressor, signal: Abort
   progress: (state: ImportProgress) => void = () => {}): Promise<ImportJob> {
   const job = pendingImport(dir); if (!job) throw new Error('No pending import.');
   const path = generationPath(dir, job.target);
-  if (!existsSync(join(path, 'main', '000-import.jsonl'))) throw new Error('Import staging data is missing; original memory remains intact.');
+  const finish = () => { rmSync(join(path, STAGED), { force: true }); rmSync(pendingFile(dir)); };
+  // A crash after the pointer swap leaves only the cleanup to do.
+  if (memoryDirectory(dir) === path) { finish(); return job; }
+  if (!existsSync(join(path, STAGED))) throw new Error('Import staging data is missing; original memory remains intact.');
+  const plan: unknown[] = readFileSync(join(path, STAGED), 'utf8').split('\n').filter(Boolean).map(line => JSON.parse(line));
+  // Every line must parse, and the plan must be whole and in order, so a damaged plan can't drop messages silently.
+  if (!plan.every(isEntry) || plan.length !== job.total || plan.some((e, i) => e.i !== i)) throw new Error('Import staging data is invalid; original memory remains intact.');
   const memory = new Memory(path, compress, () => {});
-  const report = () => progress({ messages: memory.root.length - memory.pending, total: memory.root.length, summaries: memory.tree.size, error: memory.lastError });
+  const report = () => progress({ messages: memory.root.length - memory.pending, total: plan.length, summaries: memory.tree.size, error: memory.lastError });
   const timer = setInterval(report, 500);
   try {
-    report(); await memory.settle(signal, true); signal.throwIfAborted();
+    if (memory.root.length > plan.length || memory.root.some((e, i) => e.text !== plan[i].text)) throw new Error('Import staging data does not match its log; original memory remains intact.');
+    report();
+    // Recipe §10: imported messages are compressed like any other, so each arrives once the one before it is summarized, as in a live chat.
+    for (const e of plan.slice(memory.root.length)) { await memory.settle(signal); memory.append(e.kind, e.text, e.date, e.receipt, e.origin); }
+    await memory.settle(signal, true); signal.throwIfAborted();
     // Close all writers before the single atomic pointer swap. The previous generation stays intact.
     await memory.close();
     atomicWrite(join(dir, 'imports', `${job.id}.json`), JSON.stringify({ ...job, completed: new Date().toISOString() }, null, 2));
     atomicWrite(join(dir, 'active-memory.json'), JSON.stringify(job.target));
-    rmSync(pendingFile(dir));
-    report(); return job;
+    finish(); report(); return job;
   } finally { clearInterval(timer); await memory.close(); }
 }

package/src/import/sources.ts

@@ -29,6 +29,8 @@ export function timestamp(value: unknown, fallback: string): string {
   const date = new Date(time);
   return Number.isNaN(date.getTime()) ? fallback : date.toISOString();
 }
+/** Header time: minutes are enough to place a message, and the rest of an ISO stamp costs summary bytes. */
+const minute = (date: string) => `${date.slice(0, 16).replace('T', ' ')}Z`;
 function text(value: unknown): string {
   if (typeof value === 'string') return value;
   if (Array.isArray(value)) return value.map(text).filter(Boolean).join('\n');
@@ -41,12 +43,46 @@ function text(value: unknown): string {
   if (typeof value.content_type === 'string') return `[${value.content_type} attachment; binary content is not imported]`;
   return '';
 }
+/**
+ * Claude Code logs slash commands, `!` shell commands, and their local output as user messages. Returns undefined
+ * for anything else, '' for output to drop, or what the user typed (`/name args`, `/name`, `!command`).
+ */
+function claudeCommand(content: string): string | undefined {
+  const s = content.trimStart();
+  if (/^<(local-command|bash)-(stdout|stderr)>/.test(s)) return '';
+  const shell = /^<bash-input>([\s\S]*?)<\/bash-input>/.exec(s)?.[1].trim();
+  if (shell !== undefined) return shell && `!${shell}`;
+  if (!/^<command-(name|message|args)>/.test(s)) return undefined;
+  const name = /<command-name>([^<]*)<\/command-name>/.exec(s)?.[1].trim(), args = /<command-args>([\s\S]*?)<\/command-args>/.exec(s)?.[1].trim();
+  return name ? `${name} ${args ?? ''}`.trimEnd() : '';
+}
+/**
+ * Context Codex injects as user messages, as codex-rs recognizes it (core/src/context/contextual_user_message.rs).
+ * Codex matches marked fragments ignoring case, but the `<external_…>` context, the internal-context source and the warnings exactly.
+ */
+const CODEX_MARKED = /^(?:# AGENTS\.md instructions[\s\S]*<\/INSTRUCTIONS>|<(environment_context|user_shell_command|turn_aborted|subagent_notification|skill|agent_message_board_notification|recommended_plugins|goal_context)>[\s\S]*<\/\1>|<hook_prompt hook_run_id="[^"]+">[\s\S]*<\/hook_prompt>)$/i;
+const CODEX_EXACT = /^(?:<external_([^>]+)>[\s\S]*<\/external_\1>|<codex_internal_context source="[a-z][a-z0-9_]*">[\s\S]*<\/codex_internal_context>|Warning: apply_patch was requested via [\s\S]*Use the apply_patch tool instead of exec_command\.|Warning: (?:Your account was flagged for potentially high-risk cyber activity|The maximum number of unified exec processes you can keep open is)[\s\S]*)$/;
+/** What the user typed in a Codex message: every part except the context Codex injected. */
+const codexTyped = (content: unknown) => (Array.isArray(content) ? content : [content]).map(text)
+  .filter(piece => piece && !CODEX_MARKED.test(piece.trim()) && !CODEX_EXACT.test(piece.trim())).join('\n');
 const digest = (s: string) => createHash('sha256').update(s).digest('hex');
+/**
+ * A resumed Claude Code session copies the earlier messages into its own file, each with its uuid and text, so a copy
+ * matches on those across files. The header line names the file (and its format has changed), and a command stored raw
+ * by an older import is read as typed, so entries already in a profile match too. Messages without a uuid never match.
+ */
+export function copyKey(e: Pick<ImportedEntry, 'kind' | 'text' | 'origin'>): string | undefined {
+  if (e.origin?.source !== 'claude' || e.origin.message.startsWith('line:')) return undefined;
+  const body = e.text.slice(e.text.indexOf('\n') + 1);
+  return JSON.stringify([e.origin.message, e.kind, claudeCommand(body) || body]);
+}
 function imported(c: Conversation, id: string, kind: Kind, content: string, date: string, identity = content): ImportedEntry | undefined {
   if (!content.trim()) return undefined;
   // Text provenance survives compression. Stable per-message receipts survive moved files and repeated exports.
   const origin: Origin = { source: c.source, conversation: c.id, message: id, title: c.title, project: c.project };
-  return { kind, date, origin, text: `[Historical ${c.source} · ${date} · conversation ${c.id} · ${c.title}]\n${content}`,
+  // The agent reads only text, so the id's first 13 characters stay in it: enough to find a Claude or Codex transcript by
+  // glob. Codex ids are UUIDv7, whose first 8 characters are a coarse timestamp shared by many sessions.
+  return { kind, date, origin, text: `[Historical ${c.source} · ${minute(date)} · ${c.id.slice(0, 13)} · ${c.title}]\n${content}`,
     receipt: `import:${digest(JSON.stringify([c.source, c.id, id, kind, identity]))}` };
 }
 async function* jsonLines(file: string, warnings: string[], limit = Infinity, signal?: AbortSignal) {
@@ -102,8 +138,10 @@ export async function scanLocal(source: 'claude' | 'codex', roots?: string[], si
           if (v.type === 'custom-title' || v.type === 'ai-title') title = string(v.customTitle ?? v.aiTitle) ?? title;
         }
         const m = source === 'claude' ? v.message : v.type === 'response_item' ? v.payload : undefined;
-        if (record(m) && m.role === 'user' && !title) {
-          title = text(m.content).replace(/\s+/g, ' ').slice(0, 110);
+        const user = record(m) && m.role === 'user' && !title;
+        const first = !user ? '' : source === 'claude' ? claudeCommand(text(m.content)) ?? text(m.content) : codexTyped(m.content);
+        if (first.trim()) {
+          title = first.replace(/\s+/g, ' ').slice(0, 110);
           date = timestamp(v.timestamp, date);
         }
       }
@@ -229,7 +267,7 @@ async function readMemory(c: Conversation, signal?: AbortSignal): Promise<{ entr
   const date = timestamp(fields.get('modified'), modified.toISOString());
   return { warnings: [], entries: [{ kind: 'note', date,
     origin: { source: c.source, conversation: c.id, message: hash.slice(0, 16), title: name, project: c.project },
-    text: `[Historical Claude Code memory · ${date} · project ${c.project}${type ? ` · type ${one(type)}` : ''} · ${name}]\n${description ? one(description) + '\n\n' : ''}${body.trim()}`,
+    text: `[Historical Claude Code memory · ${minute(date)} · project ${c.project}${type ? ` · type ${one(type)}` : ''} · ${name}]\n${description ? one(description) + '\n\n' : ''}${body.trim()}`,
     receipt: `import:${digest(JSON.stringify([c.source, c.id, hash]))}` }] };
 }
 
@@ -332,7 +370,8 @@ export async function readConversation(c: Conversation, signal?: AbortSignal): P
               warnings.push(`${c.file}:${line}: unsupported Claude content block ${String(b.type)} skipped`);
             return [];
           });
-          if (m.role === 'user' && parts.length) { finish(); for (const part of parts) add(part.id, 'user', part.content, date); }
+          // Receipts keep the raw text, so a command already imported is still recognized.
+          if (m.role === 'user' && parts.length) { finish(); for (const part of parts) add(part.id, 'user', claudeCommand(part.content) ?? part.content, date, part.content); }
           else if (m.role === 'assistant') {
             const final = m.stop_reason === 'end_turn' || m.stop_reason === 'stop_sequence';
             if (toolActivity || v.isApiErrorMessage === true || m.stop_reason && !final) pending = [];
@@ -347,7 +386,7 @@ export async function readConversation(c: Conversation, signal?: AbortSignal): P
         }
         if (c.source === 'codex' && v.type === 'response_item' && record(v.payload)) {
           const m = v.payload, id = string(m.id) ?? string(m.call_id) ?? `line:${line}`;
-          if (m.type === 'message' && m.role === 'user') { finish(); add(id, 'user', text(m.content), date); }
+          if (m.type === 'message' && m.role === 'user') { finish(); add(id, 'user', codexTyped(m.content), date, text(m.content)); }
           else if (m.type === 'message' && m.role === 'assistant') {
             pending = [];
             const channel = m.channel ?? m.phase;

package/src/import/ui.ts

@@ -78,7 +78,7 @@ export async function chooseImport(ctx: ImportUI, profile: string, memory: Memor
   let nodes = 0;
   for (let n = memory.root.length + added.length; n > 0; n = Math.floor(n / 2)) nodes += n;
   if (mode === 'append') nodes -= memory.tree.size;
-  const preview = `${profile} · ${mode}\n${source === 'claude-memory' ? 'Each memory file as one dated historical note; MEMORY.md indexes excluded.' : 'Historical user messages and final replies; tool activity excluded.'}\n${conversations.length} ${unit} selected · ${added.length} new ${source === 'claude-memory' ? 'notes' : 'messages'} · ${skipped} duplicates skipped\n${size(inputBytes)} text to index (~${Math.ceil(inputBytes / 4).toLocaleString()} source tokens; rough estimate)\nCompactor: ${model}\nUp to ${nodes} new summary nodes; small nodes need no model call. Context and retries add usage.\nChatting in this profile pauses until completion or discard. You can pause and resume compression. The previous memory is retained.`;
+  const preview = `${profile} · ${mode}\n${source === 'claude-memory' ? 'Each memory file as one dated historical note; MEMORY.md indexes excluded.' : 'Historical user messages and final replies; tool activity excluded.'}\n${conversations.length} ${unit} selected · ${added.length} new ${source === 'claude-memory' ? 'notes' : 'messages'} · ${skipped} duplicates skipped\n${size(inputBytes)} text to index (~${Math.ceil(inputBytes / 4).toLocaleString()} source tokens; rough estimate)\nCompactor: ${model}\nUp to ${nodes} new summary nodes; small nodes need no model call. A big import costs about 3x the source tokens in compactor input, plus cached context and retries.\nChatting in this profile pauses until completion or discard. You can pause and resume compression. The previous memory is retained.`;
   if (!await ctx.ui.confirm('Start import?', preview, { signal })) return;
   return { entries, mode };
 }

package/src/index.ts

@@ -3,6 +3,7 @@ import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { hostname } from 'node:os';
 import { createHash } from 'node:crypto';
+import { getSupportedThinkingLevels } from '@earendil-works/pi-ai';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { parseSkillBlock, type ExtensionAPI, type ExtensionContext, type ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
@@ -12,8 +13,8 @@ import { atomicWrite, createProfile, instructions, lastProfile, listProfiles, lo
 import { MASTER, VIEW_DOC } from './prompts.ts';
 import { cachePayload, record } from './cache.ts';
 import { asUser, boundedMessage, buildContext, logMessage, previousExchange, REPORT_TYPE, RUN_BOUNDARY, textContent, typedText } from './transcript.ts';
-import { registerReportRenderer } from './report-message.ts';
-import { memoryTools, result } from './tools.ts';
+import { registerReportRenderer, type ReportDetails } from './report-message.ts';
+import { memoryTools, result, SEARCH_DOC, searchTool } from './tools.ts';
 import { Children, CWD_DOC, loadedBuiltins } from './agents.ts';
 import { exportBrowser } from './browser.ts';
 import { Inbox } from './inbox.ts';
@@ -33,8 +34,10 @@ import { showSettings } from './settings-page.ts';
 
 const binding = 'optchat.profile';
 const CONTINUITY = '\n\nFor conversational continuity, the memory view may be followed by the immediately preceding completed exchange (its user requests and final answer, in full text; left out when very long), then the new input. Use that exact wording to understand follow-ups; older exchanges and previous tool output remain accessible through memory and zoom.';
-/** A report run while idle reuses the last built prompt, so a Previous exchange change since then is applied here. */
-const continuity = (prompt: string, on: boolean) => on === prompt.includes(CONTINUITY) ? prompt : on ? prompt.replace(VIEW_DOC, VIEW_DOC + CONTINUITY) : prompt.replace(CONTINUITY, '');
+const toggle = (prompt: string, line: string, on: boolean, after: string) => on === prompt.includes(line) ? prompt : on ? prompt.replace(after, after + line) : prompt.replace(line, '');
+/** A report run while idle reuses the last built prompt, so Previous exchange and Memory search changes since then are applied here. */
+const promptFor = (prompt: string, { previousExchange, memorySearch }: ProfileConfig) =>
+  toggle(toggle(prompt, CONTINUITY, previousExchange, VIEW_DOC), SEARCH_DOC, memorySearch, previousExchange ? VIEW_DOC + CONTINUITY : VIEW_DOC);
 interface Active { name: string; dir: string; config: ProfileConfig; memory: Memory; inbox: Inbox; children: Children; usage: UsageLedger; unlock: () => Promise<void> }
 
 export default function optchat(pi: ExtensionAPI) {
@@ -49,7 +52,8 @@ export default function optchat(pi: ExtensionAPI) {
   let prompt = '';
   let runStarted = false;
   let fault: string | undefined;
-  let reports: string[] = [];
+  /** Reports not yet in memory. `count`: how many subagent reports the text joins. `batch`: held while the rest of that spawn runs, not sent yet. */
+  let reports: { text: string; count?: number; batch?: string }[] = [];
   const receipts = new Map<AgentMessage, string>();
   let checkpoints = Promise.resolve();
   let importing = false;
@@ -66,13 +70,21 @@ export default function optchat(pi: ExtensionAPI) {
     const a = active;
     if (a) title.show(text => ctx.ui.setTitle(text), mainTitle(a.name, working, a.children.ids.length));
   };
+  /** Journals written before batches held plain strings. */
+  const isPendingReport = (s: unknown): s is string | { text: string; count?: number } =>
+    typeof s === 'string' || record(s) && typeof s.text === 'string' && (s.count === undefined || typeof s.count === 'number');
   const reportReceipt = (text: string) => 'report:' + createHash('sha256').update(text).digest('hex');
   const errorText = (error: unknown) => error instanceof Error ? error.message : String(error);
   pi.registerFlag('optchat-profile', { description: 'OptChat profile (required for noninteractive sessions without a saved binding)', type: 'string' });
   const required = () => { if (!active) throw new Error('Choose an OptChat profile first: /optchat profile'); return active; };
   const status = (ctx: ExtensionContext) => {
     const a = active;
-    ctx.ui.setStatus('optchat', a ? `OptChat: ${a.name} · ${a.memory.root.length} messages · ${a.memory.pending} pending · ${a.children.ids.length} agents${importing ? ' · importing' : pendingImport(a.dir) ? ' · import paused: /optchat import' : ''}` : 'OptChat: choose profile');
+    if (!a) { ctx.ui.setStatus('optchat', 'OptChat: choose profile'); return; }
+    // A display only: a broken import journal is refused where it matters, never here.
+    let note = '';
+    try { note = importing ? ' · importing' : pendingImport(a.dir) ? ' · import paused: /optchat import' : ''; }
+    catch { note = ' · import journal invalid'; }
+    ctx.ui.setStatus('optchat', `OptChat: ${a.name} · ${a.memory.root.length} messages · ${a.memory.pending} pending · ${a.children.ids.length} agents${note}`);
   };
   const saveReports = () => { if (active) atomicWrite(join(active.dir, 'pending-reports.json'), JSON.stringify(reports)); };
   const flush = () => {
@@ -84,21 +96,25 @@ export default function optchat(pi: ExtensionAPI) {
       if (receipt && !receipt.startsWith('report:')) active.inbox.acknowledge(receipt);
       receipts.delete(message);
       if (message.role === 'user') {
-        const index = reports.indexOf(textContent(message.content));
+        const text = textContent(message.content), index = reports.findIndex(r => !r.batch && r.text === text);
         if (index >= 0) { reports.splice(index, 1); saveReports(); }
       }
     }
   };
   // Shown as a dark background box, not as the user's own message. Before this profile has run once there is no
   // built system prompt to reuse, so that rare case still goes through Pi's normal prompt path as a user message.
-  const sendReport = (text: string) => {
-    if (prompt) pi.sendMessage({ customType: REPORT_TYPE, content: text, display: true }, { triggerTurn: true, deliverAs: 'steer' });
+  const sendReport = (text: string, count?: number) => {
+    if (prompt) pi.sendMessage<ReportDetails>({ customType: REPORT_TYPE, content: text, display: true, details: { count } }, { triggerTurn: true, deliverAs: 'steer' });
     else pi.sendUserMessage(text, { deliverAs: 'steer', expandPromptTemplates: false });
   };
-  const deliverReport = async (text: string, once = false) => {
-    if (once && (active?.memory.root.some(e => e.receipt === reportReceipt(text)) || reports.includes(text))) return;
-    reports.push(text); saveReports();
-    if (!stopping) sendReport(text);
+  const deliverReport = async (text: string, { once = false, count }: { once?: boolean; count?: number } = {}) => {
+    if (once && (active?.memory.root.some(e => e.receipt === reportReceipt(text)) || reports.some(r => r.text === text))) return;
+    reports.push({ text, count }); saveReports();
+    if (!stopping) sendReport(text, count);
+  };
+  const holdReports = (batch: string, texts: string[]) => {
+    reports = [...reports.filter(r => r.batch !== batch), ...texts.length ? [{ text: texts.join('\n\n'), count: texts.length, batch }] : []];
+    saveReports();
   };
   const stop = async () => {
     remote?.close(); remote = undefined;
@@ -141,7 +157,7 @@ export default function optchat(pi: ExtensionAPI) {
       usage.backfill(ctx.sessionManager.getEntries(), sessionId);
       const pending = join(dir, 'pending-reports.json');
       const saved: unknown = existsSync(pending) ? JSON.parse(readFileSync(pending, 'utf8')) : [];
-      if (!Array.isArray(saved) || !saved.every(s => typeof s === 'string')) throw new Error('Invalid pending report journal.');
+      if (!Array.isArray(saved) || !saved.every(isPendingReport)) throw new Error('Invalid pending report journal.');
       const memory = new Memory(memoryDirectory(dir), createCompressor(ctx.modelRegistry, () => config.compactor, message => {
         usage.compression(message, 'compactor', sessionId);
         status(ctx);
@@ -151,10 +167,12 @@ export default function optchat(pi: ExtensionAPI) {
       const recovered = pendingImport(dir) ? 0 : inbox.recover(memory);
       if (recovered) ctx.ui.notify(`Recovered ${recovered} unanswered inputs into ${name}'s memory. Ask to continue them when ready.`, 'info');
       const children = new Children(memory, ctx.modelRegistry, () => config.subagent, () => `${instructions(dir)}\n\n${IMPORT_GUIDANCE}`,
-        deliverReport, text => ctx.ui.notify(text, 'error'), dir, { parentSession: sessionId, usage, builtins: () => loadedBuiltins(pi), settings: () => config,
+        deliverReport, text => ctx.ui.notify(text, 'error'), dir, { parentSession: sessionId, usage, builtins: () => loadedBuiltins(pi), settings: () => config, hold: holdReports,
           summarizeHandoff: createHandoffSummarizer(ctx.modelRegistry, () => config.compactor, message => usage.compression(message, 'compactor', sessionId)) });
       const loggedReports = new Set(memory.root.map(e => e.receipt));
-      reports = saved.filter((s): s is string => typeof s === 'string' && !loggedReports.has(reportReceipt(s)));
+      // Reports a crash held back with their unfinished siblings are delivered now, as they are.
+      reports = saved.map(s => typeof s === 'string' ? { text: s } : { text: s.text, count: s.count })
+        .filter(r => !loggedReports.has(reportReceipt(r.text)));
       atomicWrite(pending, JSON.stringify(reports));
       rememberProfile(name);
       active = { name, dir, config, memory, inbox, children, usage, unlock }; fault = undefined;
@@ -165,7 +183,7 @@ export default function optchat(pi: ExtensionAPI) {
       ctx.ui.notify(`OptChat · ${name} · ${memory.root.length} messages\nCompactor: ${config.compactor.provider}/${config.compactor.model} (${config.compactor.thinking})`, 'info');
       const queuedReports = [...reports];
       if (!pendingImport(dir)) recovery = children.recoverHandoffs().catch(error => ctx.ui.notify(`Handoff recovery: ${errorText(error)}`, 'error'));
-      setImmediate(() => { if (active?.memory === memory && !pendingImport(dir)) for (const text of queuedReports) sendReport(text); });
+      setImmediate(() => { if (active?.memory === memory && !pendingImport(dir)) for (const r of queuedReports) sendReport(r.text, r.count); });
     } catch (error) {
       await closeWindows?.(); closeWindows = undefined;
       untitle?.(); untitle = undefined; title.clear();
@@ -244,7 +262,8 @@ export default function optchat(pi: ExtensionAPI) {
     startRun(ctx);
     const a = required();
     // Pi's own prompt sections (AGENTS.md files, skills, cwd) stay; the profile's instructions go last.
-    event.systemPromptOptions.customPrompt = `${MASTER}\n\n${VIEW_DOC}${a.config.previousExchange ? CONTINUITY : ''}`;
+    syncSearch(a.config);
+    event.systemPromptOptions.customPrompt = `${MASTER}\n\n${VIEW_DOC}${a.config.previousExchange ? CONTINUITY : ''}${a.config.memorySearch ? SEARCH_DOC : ''}`;
     event.systemPromptOptions.sections.instructions = `${instructions(a.dir)}\n\n${IMPORT_GUIDANCE}`;
     prompt = event.systemPrompt;
   });
@@ -255,7 +274,7 @@ export default function optchat(pi: ExtensionAPI) {
     if (message.role === 'user') {
       try {
         const text = textContent(message.content);
-        if (reports.includes(text)) receipts.set(message, reportReceipt(text));
+        if (reports.some(r => !r.batch && r.text === text)) receipts.set(message, reportReceipt(text));
         else {
           // The inbox journaled the typed input: match without image placeholders or Pi's image notes.
           const typed = typedText(message.content), skill = parseSkillBlock(typed.bare);
@@ -283,7 +302,7 @@ export default function optchat(pi: ExtensionAPI) {
         view = a.memory.render(); // Capture old history before logging the new input.
         flush();
       }
-      return { messages: buildContext(event.messages, run, view, continuity(prompt, a.config.previousExchange), previous) };
+      return { messages: buildContext(event.messages, run, view, promptFor(prompt, a.config), previous) };
     } catch (error) {
       // Pi catches extension errors. Explicitly abort so it cannot fall back to old context.
       ctx.abort();
@@ -318,12 +337,19 @@ export default function optchat(pi: ExtensionAPI) {
   registerConnectedRenderer(pi);
   registerReportRenderer(pi);
   for (const tool of memoryTools(() => required().memory)) pi.registerTool(tool);
+  pi.registerTool({ ...searchTool(() => required().memory), defaultActive: false });
+  // The tool and its prompt line change together, once per toggle, so the cached prefix is otherwise stable.
+  // Synced on save too: a report turn started while idle reuses the tool set without before_agent_start.
+  const syncSearch = ({ memorySearch }: ProfileConfig) => {
+    const tools = pi.getActiveTools();
+    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. 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: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String({ description: CWD_DOC })) }), { minItems: 1 }) }),
     async execute(_id, args, signal, _update, ctx) {
-      const ids = await required().children.spawn(args.tasks, ctx.cwd, signal); status(ctx);
-      return result(`Started: ${ids.join(', ')}. Reports will arrive automatically.`);
+      const text = await required().children.start(args.tasks, ctx.cwd, signal); status(ctx);
+      return result(text);
     },
   });
   pi.registerTool({ name: 'tell', label: 'Tell background agent', description: 'Send a message to a subagent. A running one gets it at its next tool boundary. A finished one you started is resumed with its earlier conversation, and its new report arrives automatically.',
@@ -333,12 +359,14 @@ export default function optchat(pi: ExtensionAPI) {
 
   const pickModel = async (ctx: ExtensionContext, role: 'compactor' | 'subagent') => {
     const a = required(), current = a.config[role];
-    const choices = ctx.modelRegistry.getAvailable().map(m => `${m.provider}/${m.id}`);
+    const available = ctx.modelRegistry.getAvailable(), choices = available.map(m => `${m.provider}/${m.id}`);
     choices.sort((a, b) => Number(b === `${current.provider}/${current.model}`) - Number(a === `${current.provider}/${current.model}`) || a.localeCompare(b));
     const selected = await ctx.ui.select(`${a.name}: ${role} model`, choices);
     if (!selected) return;
-    const picked = await ctx.ui.select('Thinking level', [...THINKING]);
-    const thinking = THINKING.find(level => level === picked);
+    const model = available.find(m => `${m.provider}/${m.id}` === selected);
+    const levels = model ? getSupportedThinkingLevels(model) : THINKING;
+    const picked = await ctx.ui.select('Thinking level', [...levels]);
+    const thinking = levels.find(level => level === picked);
     if (!thinking) return;
     const separator = selected.indexOf('/');
     a.config[role] = { provider: selected.slice(0, separator), model: selected.slice(separator + 1), thinking };
@@ -423,8 +451,8 @@ export default function optchat(pi: ExtensionAPI) {
     if (action === 'settings') {
       const a = required();
       if (ctx.mode !== 'tui') throw new Error('/optchat settings requires interactive Pi. Edit config.json in the profile directory instead.');
-      return showSettings(ctx, { profile: a.name, config: a.config, models: ctx.modelRegistry.getAvailable().map(m => `${m.provider}/${m.id}`).sort(),
-        save: config => saveConfig(a.dir, config) });
+      return showSettings(ctx, { profile: a.name, config: a.config, models: ctx.modelRegistry.getAvailable().map(m => ({ name: `${m.provider}/${m.id}`, thinking: getSupportedThinkingLevels(m) })).sort((a, b) => a.name.localeCompare(b.name)),
+        save: config => { saveConfig(a.dir, config); syncSearch(config); } });
     }
     if (action === 'model') return pickModel(ctx, 'compactor');
     if (action === 'agents model') return pickModel(ctx, 'subagent');

package/src/memory.ts

@@ -63,7 +63,7 @@ function records(dir: string, warn: (s: string) => void): unknown[] {
 function object(value: unknown): value is Record<string, unknown> {
   return typeof value === 'object' && value !== null;
 }
-function isEntry(value: unknown): value is Entry {
+export function isEntry(value: unknown): value is Entry {
   return object(value) && Number.isSafeInteger(value.i) && typeof value.kind === 'string'
     && ['user', 'talk', 'tool', 'echo', 'note'].includes(value.kind)
     && typeof value.text === 'string' && typeof value.date === 'string';
@@ -116,9 +116,9 @@ export class Memory {
     const main = dirname(next), names = readdirSync(main).filter(n => n.endsWith('.jsonl'));
     if (names.length !== this.lastSeenBytes.size || names.some(n => statSync(join(main, n)).size !== this.lastSeenBytes.get(join(main, n)))) throw otherWriter(next);
   }
-  append(kind: Kind, text: string, date = new Date().toISOString(), receipt?: string) {
+  append(kind: Kind, text: string, date = new Date().toISOString(), receipt?: string, origin?: Origin) {
     if (this.stopped) throw new Error('Memory is closed.');
-    const entry: Entry = { i: this.root.length, kind, text, date, size: bytes(`${kind}: ${text}`), ...(receipt ? { receipt } : {}) };
+    const entry: Entry = { i: this.root.length, kind, text, date, size: bytes(`${kind}: ${text}`), ...(receipt ? { receipt } : {}), ...(origin ? { origin } : {}) };
     const file = join(this.directory, 'main', `${localDay()}.jsonl`);
     if (!this.lastSeenBytes.has(file)) this.checkLog(file);
     this.lastSeenBytes.set(file, appendJson(file, entry, this.lastSeenBytes.get(file) ?? 0));
@@ -134,17 +134,16 @@ export class Memory {
   get pending() { return this.root.length - this.leaves; }
   get active() { return this.busy.size; }
   get size() { return this.viewBytes; }
-  /** The view tiles the log in order, so a binary search finds the part covering a position. */
-  private visible(part: Part) {
-    const at = start(part);
+  /** The view line covering message `at`. The view tiles the log in order, so a binary search finds it. */
+  covering(at: number): Part | undefined {
     for (let lo = 0, hi = this.view.length - 1; lo <= hi;) {
       const mid = (lo + hi) >> 1, p = this.view[mid];
       if (end(p) <= at) lo = mid + 1;
       else if (start(p) > at) hi = mid - 1;
-      else return p.l === part.l && p.i === part.i;
+      else return p;
     }
-    return false;
   }
+  private visible(part: Part) { const p = this.covering(start(part)); return p?.l === part.l && p.i === part.i; }
   private fit(total = this.root.length) {
     while (this.viewBytes > this.budget) {
       let best = -1; let due = -Infinity;
@@ -169,6 +168,8 @@ export class Memory {
   }
   private pump() {
     if (this.stopped) return;
+    // One clock reading: skipping a part and arming its retry timer must agree on what is due.
+    const now = Date.now();
     const total = this.root.length;
     const first = this.view.find(p => !this.node(p));
     const boundary = first ? start(first) : total;
@@ -180,7 +181,7 @@ export class Memory {
         if (this.busy.size >= this.jobs) return;
         const part = { l, i }, id = key(part);
         if ((l === 0 ? i : end(part)) > boundary) break;
-        if (this.node(part) || this.busy.has(id) || (this.retryAt.get(id) ?? 0) > Date.now()) continue;
+        if (this.node(part) || this.busy.has(id) || (this.retryAt.get(id) ?? 0) > now) continue;
         if (l && (!this.node({ l: l - 1, i: 2 * i }) || !this.node({ l: l - 1, i: 2 * i + 1 }))) continue;
         const promise = this.build(part).catch(error => {
           if (this.stopped) return;
@@ -193,8 +194,8 @@ export class Memory {
       }
     }
     // A later failure can have a later deadline than the timer installed by the first.
-    const deadlines = [...this.retryAt.values()].filter(t => t > Date.now());
-    if (deadlines.length && !this.retryTimer) this.retryTimer = setTimeout(() => { this.retryTimer = undefined; this.schedule(); }, Math.max(1, Math.min(...deadlines) - Date.now()));
+    const deadlines = [...this.retryAt.values()].filter(t => t > now);
+    if (deadlines.length && !this.retryTimer) this.retryTimer = setTimeout(() => { this.retryTimer = undefined; this.schedule(); }, Math.max(1, Math.min(...deadlines) - now));
   }
   private async build(part: Part) {
     const source = part.l === 0 ? `${this.root[part.i].kind}: ${this.root[part.i].text}`
@@ -242,6 +243,17 @@ export class Memory {
       return `${start(part)}+${2 ** l}|${flat(node.text)}`;
     }).join('\n');
   }
+  /** 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) {
+    const needle = text.toLowerCase(), hits: Entry[] = [];
+    for (let i = Math.min(before, this.root.length) - 1; i >= 0; i--) {
+      const entry = this.root[i];
+      if ((entry.kind === 'tool' || entry.kind === 'echo') && /^(zoom|search)[ :]/.test(entry.text)) continue;
+      if (entry.text.toLowerCase().includes(needle)) hits.push(entry);
+    }
+    return hits;
+  }
   date(id: number) {
     if (!Number.isSafeInteger(id) || !this.root[id]) throw new Error(`No message ${id}.`);
     return new Date(this.root[id].date).toString();

package/src/prompts.ts

@@ -1,5 +1,5 @@
 // Prompts transcribed verbatim from Victor Taelin's OptChat recipe.
 export const COMPACT = "You write the memory of OptChat, an AI agent that works for one user in one\nendless chat, through tools and subagents. Each message has a kind: user\n(the user's words; but one starting \"[id] \" is a subagent's report),\ntalk (OptChat's replies), tool (OptChat's tool calls), echo (tool results), note\n(memories from before this chat).\n\nOver the messages grows a binary tree of one-line summaries. First, each\nmessage is compressed alone into a line (a short message is its own\nline). Then lines are merged in pairs: two adjacent lines become one\nline covering both, two of those become one covering four, and so on.\nYour job is one of these steps: compress one message into a line, or\nmerge two adjacent lines into one.\n\nOptChat sees the chat only through these lines: recent messages one per\nline, older ones more per line, the older the more. So your line stands\nin for its messages (your stretch) for weeks or years, and is later\nmerged with its neighbor into the line above. OptChat can open a line back\ninto the two lines it was made from, down to the messages, but only when\nthe line's words show that what it needs is inside: what your line omits\nis lost to OptChat and to every line above.\n\n<chat> is OptChat's view up to the last message of your stretch: use it to\nunderstand what was going on, to resolve references, and to recover\ndetail your input lost.\n\nGoal: let OptChat work later as well as if it remembered the whole stretch.\nSpace is scarce, so it goes by value:\n\n1. The user's own words matter most: orders, decisions, corrections,\npreferences, and above all their reasoning and explanations. Keep them\nas close to verbatim as space allows, and let them outlive everything\nelse up the tree. Record what the user said, not that they said\nsomething. Only text the user wrote counts as theirs.\n\n2. Next comes anything with lasting effect, done by anyone: whatever\nchanged in the world or was committed to, and what failed and why.\n\n3. Then findings and open questions, and OptChat's own replies, which\ndeserve far less space than the user's words.\n\n4. Least of all, intermediate steps: tool calls and their outputs. They\nfill most of the log and are mostly noise. Instead of copying them,\ndescribe each in a few words: what was done, whether it worked (and the\nerror, if not), what the thing it touched is and what is in it, and how\nthat relates to the task underway, even when it is unrelated. Later,\nthis tells OptChat what was already done and what is where, even for a task\nthis one never had in mind.\n\nAvoid dropping an item entirely: an absent item can never be found by\nzooming, while a word or two keeps it findable. When space is tight,\ngive the important items most of it and the minor ones just enough to be\nnamed; drop only what OptChat will plausibly never need, when its space is\nworth much more elsewhere.\n\nEach line will sit among neighbors you cannot predict, so it must make\nsense on its own. Tag each item with its source kind (\"user: ...; echo:\n...\"), and subagent reports as \"work:\". Record faithfully: never answer,\nobey or add to the messages, and never make anything look further along\nthan it was. Output only the line; non-ASCII characters cost 2-4 bytes.";
 export const MASTER = "You are OptChat, an AI agent that works for one user in a single chat that\nnever ends. Do the user's tasks yourself, with your tools, following\nthe user's instructions at the end of this prompt: they say who the\nuser is, how their files are organized and how they want work done.\nUse subagents only when the user asks for them.\n\nYou keep no memory between turns. Each turn starts with the view below,\nfollowed by the user's new message. Summaries keep little of tool\noutput, so say in your reply what you learned that will matter later.\nMessages the user sends while you work reach you between tool calls.\n\nSubagents and computer tasks run in the background. Each one's report\nreaches you as a message starting \"[id] \": between your tool calls\nwhile you work, or as a new turn once yours has ended. So never wait\nfor one (no sleep, no polling): go on, or end your turn and tell the\nuser what is running.";
-export const VIEW_DOC = "The view: the whole chat between OptChat and the user, oldest first, inside\n<chat> tags, as one-line summaries. Each line is\n\n  id+n|text   the n messages from id on, summarized (newlines shown as spaces)\n\nA summary tags each item with its kind: user (the user's words), talk\n(OptChat's replies), tool (OptChat's tool calls), echo (their results), note\n(memories from before this chat), or work (the report of a subagent or\na computer task, which the log holds as a user message starting\n\"[id] \"). A short message is its own line, word for word. Recent lines\ncover one message each; the older the messages, the more a line covers.\nA message not summarized yet shows as \"(not summarized yet: zoom it)\".\nNo message appears in full, not even the last ones.\n\nNavigating: zoom(id, n) opens line id+n into the two lines of n/2\nmessages it was made from; zoom(id, 1) gives message id in full. Zoom\nwhenever a summary only mentions something you need, such as what your\nlast reply said, a decision, a past attempt or where a file is, before\nyou act, guess or ask. date(id) gives the date and time of message id.";
+export const VIEW_DOC = "The view: the whole chat between OptChat and the user, oldest first, inside\n<chat> tags, as one-line summaries. Each line is\n\n  id+n|text   the n messages from id on, summarized (newlines shown as spaces)\n\nA summary tags each item with its kind: user (the user's words), talk\n(OptChat's replies), tool (OptChat's tool calls), echo (their results), note\n(memories from before this chat), or work (the report of a subagent or\na computer task, which the log holds as a user message starting\n\"[id] \"). A short message is its own line, word for word. Recent lines\ncover one message each; the older the messages, the more a line covers.\nA message not summarized yet shows as \"(not summarized yet: zoom it)\".\nNo message appears in full, not even the last ones.\n\nNavigating: zoom(id, n) opens line id+n into the two lines of n/2\nmessages it was made from; zoom(id, 1) gives message id in full. Zoom\nwhenever a summary only mentions something you need, such as what your\nlast reply said, a decision, a past attempt or where a file is, before\nyou act, guess or ask. date(id) gives the date and time of message id.\nYou can zoom out too: zoom(id, n) opens any summarized block with n a\npower of 2 and id a multiple of n, so from a message you can open the\nsummaries above it.";
 export const SUBAGENT = "You are a subagent of OptChat, an AI agent that works for one user in a\nsingle chat that never ends. OptChat gave you a task. Do it yourself, with\nyour tools, following the user's instructions at the end of this\nprompt: they say who the user is, how their files are organized and how\nthey want work done.\n\nYour first message holds the view below, then your task. The view shows\nyou what OptChat knows: what the user wants, decided and taught. Use it as\ncontext only, and do what your task says, not what the user's last\nmessage says, since OptChat may have given you just part of the work. Your\nfinal reply is your report to OptChat. OptChat may send you more messages, even\nwhile you work.";

package/src/report-message.ts

@@ -4,8 +4,12 @@ import { REPORT_TYPE, textContent } from './transcript.ts';
 
 const HEAD = /^\[([0-9a-f]{8})\] (?:(Message from subagent \(still running\)|Connected agent message): )?/;
 
+/** Sent with a report: `count` subagent reports joined in one message, when one spawn's reports arrive together. */
+export interface ReportDetails { count?: number }
+
 /** Split "[id] Message from subagent (still running): body" into a short label and the body. */
-export function reportParts(text: string) {
+export function reportParts(text: string, count = 1) {
+  if (count > 1) return { label: `${count} subagent reports`, body: text };
   const match = HEAD.exec(text);
   if (!match) return { label: 'subagent', body: text };
   const kind = match[2] === undefined ? 'report' : match[2].startsWith('Message') ? 'still running' : 'connected window';
@@ -21,8 +25,8 @@ function darkBackground(theme: Theme) {
 }
 
 /** Background traffic: a dark neutral box with dim text, so it never looks like something the user typed. */
-export function reportBox(text: string, outputPad: number, theme: Theme) {
-  const { label, body } = reportParts(text);
+export function reportBox(text: string, outputPad: number, theme: Theme, count?: number) {
+  const { label, body } = reportParts(text, count);
   const box = new Box(outputPad, 1, darkBackground(theme));
   box.addChild(new Text(theme.fg('dim', `↳ ${label}`), 0, 0));
   box.addChild(new Markdown(body.trim(), 0, 0, getMarkdownTheme(), { color: text => theme.fg('muted', text) }));
@@ -30,5 +34,5 @@ export function reportBox(text: string, outputPad: number, theme: Theme) {
 }
 export const isReport = (text: string) => HEAD.test(text);
 export function registerReportRenderer(pi: ExtensionAPI) {
-  pi.registerMessageRenderer(REPORT_TYPE, (message, { outputPad }, theme) => reportBox(textContent(message.content), outputPad, theme));
+  pi.registerMessageRenderer<ReportDetails | undefined>(REPORT_TYPE, (message, { outputPad }, theme) => reportBox(textContent(message.content), outputPad, theme, message.details?.count));
 }

package/src/settings-page.ts

@@ -3,6 +3,7 @@ import { DynamicBorder, type ExtensionContext, type Theme } from '@earendil-work
 import { defaults, THINKING, type ProfileConfig } from './profiles.ts';
 import { invalid, isNumberKey, SETTING_KEYS, SETTINGS, type NumberKey, type SettingKey } from './settings.ts';
 import type { ModelChoice } from './compactor.ts';
+import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 
 type Role = 'compactor' | 'subagent';
 const ROLES: Record<Role, { label: string; description: string; applies: string }> = {
@@ -20,7 +21,9 @@ const show = (key: SettingKey, value: number | boolean) => {
 };
 
 interface Options {
-  profile: string; config: ProfileConfig; models: string[];
+  profile: string; config: ProfileConfig;
+  /** Each model with the thinking levels Pi can send it (Sonnet 5.5 has no "off"). */
+  models: { name: string; thinking: readonly ThinkingLevel[] }[];
   /** Saves the whole profile config; throws if it can't be written. */
   save: (config: ProfileConfig) => void;
 }
@@ -61,21 +64,21 @@ class NumberStep extends Container {
 /** Model first (type to filter), then thinking level; Esc goes back a step. */
 class ModelStep extends Container {
   private active: { handleInput(data: string): void } = { handleInput: () => {} };
-  constructor(private readonly theme: Theme, private readonly role: Role, private readonly models: string[], private readonly current: ModelChoice,
+  constructor(private readonly theme: Theme, private readonly role: Role, private readonly models: Options['models'], private readonly current: ModelChoice,
     private readonly submit: (choice: ModelChoice) => string | undefined, private readonly cancel: () => void) {
     super();
     this.pickModel();
   }
   private pickModel() {
     const { theme, current } = this, filter = new Input();
-    const items: SelectItem[] = this.models.map(value => ({ value, label: value }));
+    const items: SelectItem[] = this.models.map(({ name }) => ({ value: name, label: name }));
     let list = new SelectList(items, 10, listTheme(theme));
     const build = () => {
       list = new SelectList(filter.getValue() ? fuzzyFilter(items, filter.getValue(), i => i.value) : items, 10, listTheme(theme));
       list.onSelect = item => this.pickThinking(item.value); list.onCancel = this.cancel;
       return list;
     };
-    build(); list.setSelectedIndex(Math.max(0, this.models.indexOf(modelName(current))));
+    build(); list.setSelectedIndex(Math.max(0, this.models.findIndex(m => m.name === modelName(current))));
     filter.focused = true;
     const box = step(theme, ROLES[this.role].label, `${ROLES[this.role].description} Now ${showModel(current)}.`, filter, 'Type to filter · Enter to choose · Esc to go back', [new Spacer(1), list]);
     this.show(box, data => {
@@ -87,11 +90,12 @@ class ModelStep extends Container {
   }
   private pickThinking(model: string) {
     const { theme, current } = this, error = new Text('', 0, 0);
-    const list = new SelectList(THINKING.map(value => ({ value, label: value })), THINKING.length, listTheme(theme));
-    list.setSelectedIndex(Math.max(0, THINKING.indexOf(current.thinking)));
+    const levels = this.models.find(m => m.name === model)?.thinking ?? THINKING;
+    const list = new SelectList(levels.map(value => ({ value, label: value })), levels.length, listTheme(theme));
+    list.setSelectedIndex(Math.max(0, levels.indexOf(current.thinking)));
     list.onCancel = () => this.pickModel();
     list.onSelect = item => {
-      const thinking = THINKING.find(level => level === item.value);
+      const thinking = levels.find(level => level === item.value);
       const slash = model.indexOf('/');
       const problem = thinking && this.submit({ provider: model.slice(0, slash), model: model.slice(slash + 1), thinking });
       if (problem) error.setText(theme.fg('error', problem));

package/src/settings.ts

@@ -8,12 +8,18 @@ export const SETTINGS = {
   maxAgents: { kind: 'number', label: 'Max active agents', default: 8, min: 1, unit: '',
     description: 'Subagents running at once in this profile, all levels together. It also caps how deep a chain can go.',
     applies: 'Applies to the next spawn.' },
+  groupReports: { kind: 'toggle', label: 'Group subagent reports', default: true,
+    description: 'On: the subagents started by one spawn report together, in one message once the last of them finishes, as in Victor\'s recipe. Off: each subagent reports as soon as it finishes.',
+    applies: 'Applies to the next spawn.' },
   previousExchange: { kind: 'toggle', label: 'Previous exchange', default: true,
     description: 'Send your last request and its answer in full with the next turn, so a follow-up reads the exact wording. Off: memory view only, as in Victor\'s recipe. On by default: a study found it costs little and saves zooms.',
     applies: 'Applies from the next turn.' },
   previousExchangeKB: { kind: 'number', label: 'Previous exchange limit', default: 16, min: 1, unit: 'KB',
     description: 'A larger last exchange, usually a big paste, is left out and the model zooms into memory instead.',
     applies: 'Applies from the next turn.' },
+  memorySearch: { kind: 'toggle', label: 'Memory search', default: false,
+    description: 'Give agents a search tool that finds original messages by plain text, newest first, for exact names, numbers, paths or errors the view doesn\'t show. Off: zoom and date only, as in Victor\'s recipe. Turning it on or off makes the next turn re-cache its prompt once.',
+    applies: 'Applies from the next turn, and to subagents started or resumed after this.' },
   summaryAcceptBytes: { kind: 'number', label: 'Summary size tolerance', default: NODE * 1.25, min: NODE, unit: 'bytes',
     description: `The compactor is always asked for ${NODE}-byte lines; a longer line up to this size is kept instead of retried. ${NODE}: strict, as in Victor's recipe. The default saves retries for a little more view space.`,
     applies: 'Applies to the next summary.' },

package/src/tools.ts

@@ -1,6 +1,28 @@
 import { Type } from 'typebox';
-import type { Memory } from './memory.ts';
+import { flat, start, type Memory } from './memory.ts';
 export const result = (text: string) => ({ content: [{ type: 'text' as const, text }], details: {} });
+export const SEARCH_PAGE = 20;
+const SNIPPET = 200;
+/** Added after the view doc when Memory search is on. */
+export const SEARCH_DOC = '\n\nsearch(text) finds the original messages that contain text, newest first. Use it for an exact name, number, PR, path or error the view doesn\'t show, then zoom(id, 1) to read a hit. A hit is one message: zoom around it too, especially the messages after it, where the outcome usually is.';
+
+/** One page of hits, each with its id, the view line holding it, its date and a snippet around the first match; at most ~5 KB. */
+export function searchPage(memory: Memory, text: string, before?: number) {
+  const hits = memory.search(text, before), older = before === undefined ? '' : 'older ';
+  if (!hits.length) return `No ${older}messages contain "${text}".`;
+  const page = hits.slice(0, SEARCH_PAGE), needle = text.toLowerCase();
+  const lines = page.map(entry => {
+    // Cut the original text, whose match may span lines, and flatten only the cut.
+    const at = Math.max(0, entry.text.toLowerCase().indexOf(needle) - SNIPPET / 4);
+    const snippet = flat(entry.text.slice(at, at + SNIPPET).replace(/^[\udc00-\udfff]|[\ud800-\udbff]$/g, ''));
+    // The live view, which may have folded since the turn's snapshot: its lines are built, so zoom always opens them.
+    const line = memory.covering(entry.i); // Named only when the hit is inside a summary line.
+    return `${entry.i}${line?.l ? ` (in ${start(line)}+${2 ** line.l})` : ''} · ${new Date(entry.date).toString().slice(0, 21)} · ${entry.kind}: ${at ? '…' : ''}${snippet}${at + SNIPPET < entry.text.length ? '…' : ''}`;
+  });
+  const more = hits.length > page.length ? `\nOlder matches: search again with before: ${page[page.length - 1].i}.` : '';
+  return `${hits.length} ${older}${hits.length === 1 ? 'message contains' : 'messages contain'} "${text}", newest first:\n${lines.join('\n')}${more}`;
+}
+
 export function memoryTools(memory: () => Memory) {
   return [
     { name: 'zoom', label: 'Zoom memory', description: 'Open the line id+n of the view into the two lines of n/2 under it; n = 1 gives the message whole.',
@@ -11,3 +33,8 @@ export function memoryTools(memory: () => Memory) {
       async execute(_id: string, args: { id: number }) { return result(memory().date(args.id)); } },
   ];
 }
+
+export const searchTool = (memory: () => Memory) => ({ name: 'search', label: 'Search memory',
+  description: `Find the original messages that contain text (plain text, any case), newest first, ${SEARCH_PAGE} at a time; before: id continues with older ones. zoom(id, 1) gives a hit whole.`,
+  parameters: Type.Object({ text: Type.String({ minLength: 1 }), before: Type.Optional(Type.Integer({ minimum: 0 })) }),
+  async execute(_id: string, args: { text: string; before?: number }) { return result(searchPage(memory(), args.text, args.before)); } });