pi-optchat 0.6.4 → 0.6.5

package/README.md

@@ -137,7 +137,7 @@ See OpenAI's guides on [exporting ChatGPT data](https://help.openai.com/en/artic
 
 ## Connected windows
 
-Each profile is locked to one Pi process. If you open the same profile in a second terminal, Pi offers to connect it to the original window as a subagent.
+Each profile is locked to one Pi process. If you open the same profile in a second terminal, Pi offers to connect it to the original window as a subagent, or to go back to the profile picker.
 
 - Your first message starts a subagent in the second window's working directory. Later messages continue the same conversation.
 - The window looks like a normal Pi chat: replies, tool calls with their output and running time, the working spinner, and reports from the subagent's own agents in the dark box. Ctrl+O expands tool output.
@@ -181,7 +181,7 @@ To delete a profile, delete its folder. Your original Pi sessions are kept in Pi
 - **Images** are available during the current run but stored in memory as text placeholders.
 - **Pi's auto-compaction is off.** A single very long run can still hit the model's context limit; stop it and continue in a new turn.
 - **Restarts**: unsent inputs are recovered into memory, and pending subagent reports are delivered. Interrupted subagents are not restarted.
-- **Skill and template inputs** can occasionally be recovered as an unanswered input after a crash, because Pi expands them after the input journal records them. Plain text chat is unaffected.
+- **Prompt-template inputs** can be saved twice: expanded, and later in their original form as an unanswered input, because Pi expands them after the input journal records them. Skill commands (`/skill:name`) are matched back to their journaled input and don't have this problem. Plain text chat is unaffected.
 
 ## How it differs from the recipe
 

package/package.json

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

package/src/agents.ts

@@ -1,6 +1,7 @@
 import { randomUUID } from 'node:crypto';
-import { existsSync, readFileSync } from 'node:fs';
-import { join, dirname } from 'node:path';
+import { existsSync, readFileSync, statSync } from 'node:fs';
+import { join, dirname, resolve } from 'node:path';
+import { homedir } from 'node:os';
 import { createAgentSession, DefaultResourceLoader, SessionManager, SettingsManager, getAgentDir, type AgentSession, type AgentSessionEvent, type ModelRegistry } from '@earendil-works/pi-coding-agent';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import { SUBAGENT, VIEW_DOC } from './prompts.ts';
@@ -28,10 +29,16 @@ const packageName = (path: string): string | undefined => {
   for (let dir = dirname(path); dir !== dirname(dir); dir = dirname(dir)) {
     const manifest = join(dir, 'package.json');
     if (!existsSync(manifest)) continue;
-    const data: unknown = JSON.parse(readFileSync(manifest, 'utf8'));
-    return data && typeof data === 'object' && 'name' in data && typeof data.name === 'string' ? data.name : undefined;
+    try {
+      const data: unknown = JSON.parse(readFileSync(manifest, 'utf8'));
+      return data && typeof data === 'object' && 'name' in data && typeof data.name === 'string' ? data.name : undefined;
+    } catch { return undefined; } // A broken manifest is not OptChat's and must not block every spawn.
   }
 };
+/** A task's cwd may start with `~` and may be relative to the spawning agent's directory. */
+export const taskDirectory = (cwd: string, path = '.', windows = process.platform === 'win32') =>
+  resolve(cwd, path.replace(windows ? /^~(?=$|[\\/])/ : /^~(?=$|\/)/, homedir()));
+export const CWD_DOC = 'Project directory the subagent works in (~ allowed); its AGENTS.md files load from there. Defaults to your current directory.';
 const isOptchat = (path: string) => packageName(path) === 'pi-optchat';
 export class Children {
   private readonly running = new Map<string, LiveRun>();
@@ -92,6 +99,7 @@ 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) {
+    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++;
     try { await this.memory.settle(signal); } finally { this.settling--; }
@@ -113,7 +121,7 @@ export class Children {
       for (const task of tasks) {
         signal?.throwIfAborted();
         if (cancelled()) throw new Error('Parent or profile is stopping.');
-        const id = randomUUID().slice(0, 8), directory = task.cwd ?? cwd;
+        const id = randomUUID().slice(0, 8), directory = taskDirectory(cwd, task.cwd);
         const delegation = depth < 3 ? '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 8 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');
@@ -151,7 +159,7 @@ export class Children {
       }
     } catch (error) {
       for (const child of launched) {
-        child.session.dispose(); this.running.delete(child.info.id);
+        this.dispose(child.session); this.running.delete(child.info.id);
         child.info.state = 'failed'; child.info.ended = Date.now(); child.info.report = `Launch failed: ${String(error)}`;
         if (child.info.connected) child.info.handoff = { reason: signal?.aborted ? 'disconnected' : 'failed' };
         this.save(child.info);
@@ -171,7 +179,7 @@ export class Children {
   }
   private delegationTools(parentId: string, cwd: string) {
     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 3 and 8 active agents per profile.',
-      parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String()) }), { minItems: 1, maxItems: 8 }) }),
+      parameters: Type.Object({ tasks: Type.Array(Type.Object({ task: Type.String(), cwd: Type.Optional(Type.String({ description: CWD_DOC })) }), { minItems: 1, maxItems: 8 }) }),
       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.`),
     }, { name: 'tell', label: 'Guide child', description: 'Send guidance to one of your direct children.',
       parameters: Type.Object({ id: Type.String(), message: Type.String() }),
@@ -199,6 +207,9 @@ export class Children {
       },
     };
   }
+  private dispose(session: AgentSession) {
+    try { session.dispose(); } catch (error) { this.warn(`Subagent cleanup failed: ${String(error)}`); }
+  }
   private directChildren(id: string) { return [...this.running.values()].filter(c => c.info.parentId === id); }
   private async execute(live: LiveRun, view: string) {
     const { session, info } = live;
@@ -240,7 +251,8 @@ export class Children {
       for (const g of info.guidance) if (g.state === 'queued') g.state = 'undelivered';
       try { await session.extensionRunner.emit({ type: 'session_shutdown', reason: 'quit' }); }
       catch (error) { this.warn(`Subagent cleanup failed: ${String(error)}`); }
-      finally { session.dispose(); this.running.delete(info.id); }
+      // A failed dispose must neither keep the slot taken nor drop the report below.
+      this.dispose(session); this.running.delete(info.id);
     }
     if (info.connected) {
       info.handoff ??= { reason: 'failed' };

package/src/inbox.ts

@@ -23,8 +23,14 @@ export class Inbox {
     const item = { id: randomUUID(), text, date: new Date().toISOString() };
     this.items.push(item); this.save(); return item.id;
   }
-  claim(text: string) {
-    const item = this.items.find(i => !this.claimed.has(i.id) && i.text === text);
+  claim(text: string) { return this.claimWhere(i => i.text === text); }
+  /** Pi expands `/skill:name args` after the input is journaled; match the expansion back to that input. */
+  claimSkill(name: string, args = '') {
+    const command = `/skill:${name}`;
+    return this.claimWhere(i => i.text.startsWith(command) && /^(\s|$)/.test(i.text.slice(command.length)) && i.text.slice(command.length).trim() === args);
+  }
+  private claimWhere(match: (item: Arrival) => boolean) {
+    const item = this.items.find(i => !this.claimed.has(i.id) && match(i));
     if (!item) return undefined;
     this.claimed.add(item.id); return item.id;
   }

package/src/index.ts

@@ -4,17 +4,17 @@ import { join } from 'node:path';
 import { hostname } from 'node:os';
 import { createHash } from 'node:crypto';
 import type { AgentMessage, ThinkingLevel } from '@earendil-works/pi-agent-core';
-import type { ExtensionAPI, ExtensionContext, ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
+import { parseSkillBlock, type ExtensionAPI, type ExtensionContext, type ExtensionCommandContext } from '@earendil-works/pi-coding-agent';
 import { Type } from 'typebox';
 import { Memory } from './memory.ts';
 import { createCompressor } from './compactor.ts';
 import { atomicWrite, createProfile, instructions, lastProfile, listProfiles, loadConfig, lockProfile, profilePath, rememberProfile, saveConfig, ProfileBusyError, type ProfileConfig } from './profiles.ts';
 import { MASTER, VIEW_DOC } from './prompts.ts';
 import { cachePayload, record } from './cache.ts';
-import { asUser, boundedMessage, buildContext, logMessage, previousExchange, REPORT_TYPE, RUN_BOUNDARY, textContent } from './transcript.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 { Children } from './agents.ts';
+import { Children, CWD_DOC } from './agents.ts';
 import { exportBrowser } from './browser.ts';
 import { Inbox } from './inbox.ts';
 import { checkpoint } from './checkpoint.ts';
@@ -114,6 +114,7 @@ export default function optchat(pi: ExtensionAPI) {
       untitle?.(); untitle = undefined; title.clear(); working = false;
     }
   };
+  const CONNECT = 'Start a connected subagent conversation here', BACK = 'Back';
   const chooseProfile = async (ctx: ExtensionContext): Promise<string | undefined> => {
     if (!ctx.hasUI) return undefined;
     const names = listProfiles(), last = lastProfile();
@@ -175,20 +176,28 @@ export default function optchat(pi: ExtensionAPI) {
 
   pi.on('session_start', async (_event, ctx) => {
     stopping = false;
-    const saved = ctx.sessionManager.getEntries().find(e => e.type === 'custom' && e.customType === binding);
+    const entries = ctx.sessionManager.getEntries();
+    const saved = entries.findLast(e => e.type === 'custom' && e.customType === binding);
     const boundName = saved?.type === 'custom' && record(saved.data) && typeof saved.data.name === 'string' ? saved.data.name : undefined;
+    // A session with conversation in it belongs to its profile. One that is only bound (a fresh `/optchat profile` session) may still pick another.
+    const settled = boundName !== undefined && entries.some(e => e.type === 'message' || e.type === 'custom_message');
     const flag = pi.getFlag('optchat-profile');
     try {
       if (boundName && typeof flag === 'string' && flag !== boundName) throw new Error(`Session belongs to ${boundName}; cannot resume it as ${flag}.`);
-      const name = boundName ?? (typeof flag === 'string' ? flag : await chooseProfile(ctx));
-      if (!name) { status(ctx); return; }
-      try { await openProfile(name, ctx); }
-      catch (error) {
-        if (!(error instanceof ProfileBusyError) || ctx.mode !== 'tui') throw error;
-        if (!await ctx.ui.confirm('Profile open in another window', `${error.owner}\nStart a connected subagent conversation here?`)) throw error;
-        remote = await openConnectedWindow(pi, ctx, name, text => title.show(t => ctx.ui.setTitle(t), text)); fault = undefined;
+      let name = boundName ?? (typeof flag === 'string' ? flag : await chooseProfile(ctx));
+      for (;;) {
+        if (!name) { status(ctx); return; }
+        try { await openProfile(name, ctx); break; }
+        catch (error) {
+          if (!(error instanceof ProfileBusyError) || ctx.mode !== 'tui') throw error;
+          // A resumed conversation already belongs to this profile, so another profile needs a new session (/optchat profile).
+          const choice = await ctx.ui.select(`${name} is open in another window\n${error.owner}`, settled ? [CONNECT] : [CONNECT, BACK]);
+          if (choice === CONNECT) { remote = await openConnectedWindow(pi, ctx, name, text => title.show(t => ctx.ui.setTitle(t), text)); fault = undefined; break; }
+          if (choice !== BACK) throw error;
+          name = await chooseProfile(ctx);
+        }
       }
-      if (!boundName) pi.appendEntry(binding, { name });
+      if (name !== boundName) pi.appendEntry(binding, { name });
     } catch (error) {
       if (active) await stop().catch(() => {});
       fault = errorText(error); ctx.ui.notify(fault, 'error');
@@ -243,7 +252,10 @@ export default function optchat(pi: ExtensionAPI) {
         const text = textContent(message.content);
         if (reports.includes(text)) receipts.set(message, reportReceipt(text));
         else {
-          let receipt = active.inbox.claim(text);
+          // The inbox journaled the typed input: match without image placeholders or Pi's image notes.
+          const typed = typedText(message.content), skill = parseSkillBlock(typed.bare);
+          let receipt = active.inbox.claim(typed.text) ?? active.inbox.claim(typed.bare)
+            ?? (skill ? active.inbox.claimSkill(skill.name, skill.userMessage) : undefined);
           if (!receipt) { active.inbox.record(text); receipt = active.inbox.claim(text); }
           if (receipt) receipts.set(message, receipt);
         }
@@ -302,8 +314,8 @@ export default function optchat(pi: ExtensionAPI) {
   registerReportRenderer(pi);
   for (const tool of memoryTools(() => required().memory)) pi.registerTool(tool);
   pi.registerTool({ name: 'spawn', label: 'Spawn background agents',
-    description: 'Start background subagents, returning IDs immediately. Use only when the user asks. Each receives the current memory view and read-only zoom/date. Children may delegate two more levels; the whole profile allows 8 active agents. 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()) }), { minItems: 1, maxItems: 8 }) }),
+    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. Children may delegate two more levels; the whole profile allows 8 active agents. 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, maxItems: 8 }) }),
     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.`);

package/src/memory.ts

@@ -12,10 +12,12 @@ export interface Part { l: number; i: number }
 export interface Summary extends Part { text: string; size: number }
 export interface Compression { context: string; source: string; merge: boolean; historical?: boolean }
 export type Compressor = (input: Compression, signal: AbortSignal) => Promise<string>;
-const key = ({ l, i }: Part) => `${l}:${i}`;
+const key = ({ l, i }: Part) => l * 2 ** 40 + i;
+const UNBUILT = '(not summarized yet: zoom it)';
 export const start = ({ l, i }: Part) => i * 2 ** l;
 export const end = (part: Part) => start(part) + 2 ** part.l;
 export const bytes = (s: string) => Buffer.byteLength(s, 'utf8');
+const UNBUILT_BYTES = bytes(UNBUILT);
 export const flat = (s: string) => s.replace(/[\r\n]+/g, ' ');
 export function cap(text: string, limit = CAP) {
   if (text.length <= limit) return text;
@@ -68,13 +70,17 @@ function isSummary(value: unknown): value is Summary {
 /** The log is authoritative. The tree and monotonically coarsening view follow recipe §§2–6. */
 export class Memory {
   readonly root: Entry[] = [];
-  readonly tree = new Map<string, Summary>();
+  readonly tree = new Map<number, Summary>();
   readonly view: Part[] = [];
   private readonly events = new EventEmitter();
   private readonly controller = new AbortController();
-  private readonly busy = new Map<string, Promise<void>>();
-  private readonly retryAt = new Map<string, number>();
-  private readonly reported = new Set<string>();
+  private readonly busy = new Map<number, Promise<void>>();
+  private readonly retryAt = new Map<number, number>();
+  private readonly reported = new Set<number>();
+  private viewBytes = 0;
+  private leaves = 0;
+  /** Per level, every node below this index is built. */
+  private readonly low: number[] = [];
   private retryTimer?: ReturnType<typeof setTimeout>;
   private scheduled = false;
   private stopped = false;
@@ -91,40 +97,53 @@ export class Memory {
     for (const value of records(join(directory, 'tree'), warn)) {
       if (!isSummary(value) || value.l < 0 || value.i < 0 || end(value) > this.root.length)
         throw new Error('Invalid OptChat summary record.');
+      if (value.l === 0 && !this.tree.has(key(value))) this.leaves++;
       this.tree.set(key(value), { ...value, size: bytes(value.text) });
     }
     // Fold history in order; do not retile the entire log on each turn.
-    for (let i = 0; i < this.root.length; i++) { this.view.push({ l: 0, i }); this.fit(i + 1); }
+    for (let i = 0; i < this.root.length; i++) { this.push(i); this.fit(i + 1); }
     this.schedule();
   }
   append(kind: Kind, text: string, date = new Date().toISOString(), receipt?: string) {
     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 } : {}) };
     appendJson(join(this.directory, 'main', `${localDay()}.jsonl`), entry);
-    this.root.push(entry); this.view.push({ l: 0, i: entry.i }); this.fit(); this.schedule();
+    this.root.push(entry); this.push(entry.i); this.fit(); this.schedule();
     return entry;
   }
   node(part: Part) { return this.tree.get(key(part)); }
-  private text(part: Part) { return this.node(part)?.text ?? '(not summarized yet: zoom it)'; }
+  private text(part: Part) { return this.node(part)?.text ?? UNBUILT; }
+  private partBytes(part: Part) { return this.node(part)?.size ?? UNBUILT_BYTES; }
+  private push(i: number) { const part = { l: 0, i }; this.view.push(part); this.viewBytes += this.partBytes(part); }
   render() { return `<chat>\n${this.view.map(p => `${start(p)}+${2 ** p.l}|${flat(this.text(p))}`).join('\n')}\n</chat>`; }
   get ready() { return this.view.every(p => this.node(p)); }
-  get pending() { return this.root.filter(e => !this.tree.has(key({ l: 0, i: e.i }))).length; }
+  get pending() { return this.root.length - this.leaves; }
   get active() { return this.busy.size; }
-  get size() { return this.view.reduce((n, p) => n + bytes(this.text(p)), 0); }
+  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);
+    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;
+    }
+    return false;
+  }
   private fit(total = this.root.length) {
-    let size = this.size;
-    while (size > this.budget) {
+    while (this.viewBytes > this.budget) {
       let best = -1; let due = -Infinity;
       for (let j = 0; j + 1 < this.view.length; j++) {
         const a = this.view[j], b = this.view[j + 1];
-        if (a.l !== b.l || a.i % 2 || b.i !== a.i + 1 || !this.node({ l: a.l + 1, i: a.i / 2 })) continue;
+        if (a.l !== b.l || a.i % 2 || b.i !== a.i + 1) continue;
         const age = (total - start(a)) / 2 ** (a.l + 2);
-        if (age > due) { best = j; due = age; }
+        if (age > due && this.node({ l: a.l + 1, i: a.i / 2 })) { best = j; due = age; }
       }
       if (best < 0) break;
       const a = this.view[best], b = this.view[best + 1];
       const parent = { l: a.l + 1, i: a.i / 2 };
-      size += bytes(this.text(parent)) - bytes(this.text(a)) - bytes(this.text(b));
+      this.viewBytes += this.partBytes(parent) - this.partBytes(a) - this.partBytes(b);
       this.view.splice(best, 2, parent);
     }
     this.events.emit('change');
@@ -140,11 +159,14 @@ export class Memory {
     const first = this.view.find(p => !this.node(p));
     const boundary = first ? start(first) : total;
     for (let l = 0; 2 ** l <= total; l++) {
-      for (let i = 0; (i + 1) * 2 ** l <= total; i++) {
+      let low = this.low[l] ?? 0;
+      while (this.node({ l, i: low })) low++;
+      this.low[l] = low;
+      for (let i = low; (i + 1) * 2 ** l <= total; i++) {
         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 ((l === 0 ? i : end(part)) > boundary) 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;
@@ -173,6 +195,8 @@ export class Memory {
     const node = { ...part, text, size: bytes(text) };
     appendJson(join(this.directory, 'tree', `${localDay()}.jsonl`), node);
     this.tree.set(key(part), node); this.retryAt.delete(key(part));
+    // A leaf is usually still in the view when built, but after a damaged tree file a saved parent can already hide it.
+    if (part.l === 0) { this.leaves++; if (this.visible(part)) this.viewBytes += node.size - UNBUILT_BYTES; }
     if (!this.retryAt.size) this.lastError = undefined;
     this.fit();
   }

package/src/transcript.ts

@@ -8,16 +8,22 @@ export const RUN_BOUNDARY = 'optchat.run';
 /** Subagent traffic to the main agent: a custom message on screen, a plain user message to the model and memory. */
 export const REPORT_TYPE = 'optchat-report';
 
-export function textContent(content: unknown): string {
+export function textContent(content: unknown, images = true): string {
   if (typeof content === 'string') return content;
   if (!Array.isArray(content)) return '';
   return content.map((part: unknown) => {
     if (typeof part !== 'object' || part === null) return '';
     if ('type' in part && part.type === 'text' && 'text' in part && typeof part.text === 'string') return part.text;
-    if ('type' in part && part.type === 'image') return '[image attachment: available in Pi session; text memory does not preserve image bytes]';
+    if (images && 'type' in part && part.type === 'image') return '[image attachment: available in Pi session; text memory does not preserve image bytes]';
     return '';
   }).filter(Boolean).join('\n');
 }
+/** What the user typed, as Pi's input event (and so the inbox) saw it: no image placeholders, and without the
+ * `[Image …]` notes Pi appends after the text when it resizes, converts or omits an attached image. */
+export function typedText(content: unknown) {
+  const text = textContent(content, false);
+  return { text, bare: text.replace(/\n\n\[Image[ :][^\n]*\](?:\n\[Image[ :][^\n]*\])*$/, '') };
+}
 /** Reports reach the model, memory and the previous-exchange replay exactly as the user messages they used to be. */
 export function asUser(message: AgentMessage): AgentMessage {
   if (message.role !== 'custom' || message.customType !== REPORT_TYPE) return message;