pi-optchat 0.7.2 → 0.8.0

package/src/import/sources.ts

@@ -6,6 +6,7 @@ import { homedir } from 'node:os';
 import { execFile } from 'node:child_process';
 import { promisify } from 'node:util';
 import { createHash } from 'node:crypto';
+import { getAgentDir, parseSkillBlock } from '@earendil-works/pi-coding-agent';
 import { record } from '../cache.ts';
 import { bytes, type Entry, type Kind, type Origin } from '../memory.ts';
 
@@ -15,7 +16,7 @@ export interface Conversation {
   source: Source; id: string; file: string; title: string; project: string; date: string; size: number;
   exported?: Record<string, unknown>;
 }
-export interface Scan { conversations: Conversation[]; warnings: string[] }
+export interface Scan { conversations: Conversation[]; warnings: string[]; note?: string }
 const exec = promisify(execFile);
 const string = (v: unknown) => typeof v === 'string' ? v : undefined;
 const codexSubagent = (metadata: Record<string, unknown>) => metadata.source === 'subagent'
@@ -65,6 +66,39 @@ const CODEX_EXACT = /^(?:<external_([^>]+)>[\s\S]*<\/external_\1>|<codex_interna
 /** 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');
+/**
+ * Pi and OMP write the same session format: an id/parentId tree in file order. OMP injects reminders and nudges as user
+ * messages it attributes to the agent; the user typed everything else.
+ */
+const piTyped = (m: Record<string, unknown>) => m.role === 'user' && m.attribution !== 'agent' && m.synthetic !== true;
+/** OptChat writes `optchat.*` entries into every session it runs; those messages are already in a profile's memory. */
+const optchatEntry = (v: Record<string, unknown>) => v.type === 'custom' && String(v.customType).startsWith('optchat.');
+/** Pi's sessions, then OMP's: its default profile in ~/.omp/agent/sessions, others in ~/.omp/profiles/<name>/agent/sessions. */
+async function piRoots(): Promise<string[]> {
+  const profiles = join(homedir(), '.omp/profiles');
+  const entries = await readdir(profiles, { withFileTypes: true }).catch(error => {
+    if (missingSource(error)) return [];
+    throw error;
+  });
+  const named = entries.filter(e => e.isDirectory()).map(e => join(profiles, e.name, 'agent/sessions')).sort();
+  return [join(getAgentDir(), 'sessions'), join(homedir(), '.omp/agent/sessions'), ...named];
+}
+/** What the user typed for a Pi or OMP session message, or undefined for anything they did not type. */
+function piUserText(v: Record<string, unknown>): string | undefined {
+  // OMP records `/skill:name args` as its own message, holding the skill's body. Newer versions keep the whole typed prompt;
+  // older ones only the name and what followed it.
+  if (v.type === 'custom_message' && v.customType === 'skill-prompt' && v.attribution === 'user' && record(v.details) && typeof v.details.name === 'string')
+    return string(v.details.prompt)?.trim() || `/skill:${v.details.name} ${string(v.details.args) ?? ''}`.trimEnd();
+  const m = v.type === 'message' ? v.message : undefined;
+  if (!record(m)) return undefined;
+  // Pi expands `/skill:name args` into the skill's body followed by the args.
+  if (piTyped(m)) { const typed = text(m.content), skill = parseSkillBlock(typed); return skill ? `/skill:${skill.name} ${skill.userMessage ?? ''}`.trimEnd() : typed; }
+  // `!cmd` and `$code` the user ran: the command as typed, never its output. `!!` and `$$` kept them from the model, so they stay out.
+  if (m.excludeFromContext === true) return undefined;
+  if (m.role === 'bashExecution' && typeof m.command === 'string') return `!${m.command}`;
+  if (m.role === 'pythonExecution' && typeof m.code === 'string') return `$${m.code}`;
+  return undefined;
+}
 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
@@ -83,7 +117,8 @@ function imported(c: Conversation, id: string, kind: Kind, content: string, date
   // 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]))}` };
+    // A Pi or OMP fork copies the earlier entries, ids and dates included, into a new session, so the session id stays out.
+    receipt: `import:${digest(JSON.stringify(c.source === 'pi' ? [c.source, id, kind, date, identity] : [c.source, c.id, id, kind, identity]))}` };
 }
 async function* jsonLines(file: string, warnings: string[], limit = Infinity, signal?: AbortSignal) {
   const stream = createReadStream(file, { encoding: 'utf8', signal });
@@ -111,22 +146,31 @@ async function filesUnder(path: string, accept: (name: string) => boolean, signa
   }
   return files.sort();
 }
-export async function scanLocal(source: 'claude' | 'codex', roots?: string[], signal?: AbortSignal): Promise<Scan> {
+export async function scanLocal(source: 'claude' | 'codex' | 'pi', roots?: string[], signal?: AbortSignal): Promise<Scan> {
   const folders = roots ?? (source === 'claude' ? [join(homedir(), '.claude/projects')]
+    : source === 'pi' ? await piRoots()
     : [join(homedir(), '.codex/sessions'), join(homedir(), '.codex/archived_sessions')]);
   const conversations: Conversation[] = [], warnings: string[] = [];
+  let underOptChat = 0;
   // Claude workflow journals contain orchestration events, not conversation messages.
   for (const folder of folders) for (const file of await filesUnder(folder, n => n.endsWith('.jsonl') && !(source === 'claude' && n === 'journal.jsonl'), signal)) {
     signal?.throwIfAborted();
     // Import user conversations, not separate delegated runs (including Claude's older flat layout).
     if (source === 'claude' && (relative(folder, dirname(file)).split(/[\\/]/).includes('subagents') || basename(file).startsWith('agent-'))) continue;
+    // OMP keeps a session's subagent and advisor logs in a folder named after the session, below the project folder.
+    if (source === 'pi' && relative(folder, file).split(/[\\/]/).length > 2) continue;
     try {
       const info = await stat(file);
       let id = basename(file, '.jsonl'), project = dirname(file), date = info.mtime.toISOString(), title = '';
+      // OMP's own title: a first line it rewrites on rename, else the header's.
+      let named = '', renamed = '';
       let sidechain = false;
-      for await (const { value: v, line } of jsonLines(file, warnings, source === 'claude' ? Infinity : 60, signal)) {
-        // Sidechain markers can appear late; picker metadata still comes from the first 60 lines.
+      for await (const { value: v, line } of jsonLines(file, warnings, source === 'codex' ? 60 : Infinity, signal)) {
+        // Sidechain and OptChat markers can appear late; picker metadata still comes from the first 60 lines.
         if (source === 'claude' && v.isSidechain === true) { sidechain = true; break; }
+        if (source === 'pi' && optchatEntry(v)) { sidechain = true; underOptChat++; break; }
+        // Pi's `/name` can come at any point; the latest wins.
+        if (source === 'pi' && v.type === 'session_info') renamed = string(v.name)?.trim() || renamed;
         if (line > 60) continue;
         if (source === 'codex' && v.type === 'session_meta' && record(v.payload)) {
           if (codexSubagent(v.payload)) { sidechain = true; break; }
@@ -137,23 +181,49 @@ export async function scanLocal(source: 'claude' | 'codex', roots?: string[], si
           project = string(v.cwd) ?? project;
           if (v.type === 'custom-title' || v.type === 'ai-title') title = string(v.customTitle ?? v.aiTitle) ?? title;
         }
+        if (source === 'pi') {
+          if (v.type === 'title' && line === 1) named = string(v.title) ?? named;
+          else if (v.type === 'session') {
+            id = string(v.id) ?? id; project = string(v.cwd) ?? project; date = timestamp(v.timestamp, date);
+            if (!named) named = string(v.title) ?? '';
+          }
+        }
         const m = source === 'claude' ? v.message : v.type === 'response_item' ? v.payload : undefined;
-        const user = record(m) && m.role === 'user' && !title;
-        const first = !user ? '' : source === 'claude' ? claudeCommand(text(m.content)) ?? text(m.content) : codexTyped(m.content);
+        const user = source === 'pi' || record(m) && m.role === 'user';
+        const first = !user || title ? '' : source === 'pi' ? piUserText(v) ?? '' : !record(m) ? ''
+          : 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);
         }
       }
       if (sidechain) continue;
-      conversations.push({ source, file, id, project, date, title: title || id, size: info.size });
+      conversations.push({ source, file, id, project, date, title: renamed || named || title || id, size: info.size });
     } catch (error) {
       signal?.throwIfAborted();
       if (!missingSource(error)) throw error;
       warnings.push(missingWarning(file));
     }
   }
-  return { conversations: conversations.sort((a, b) => b.date.localeCompare(a.date)), warnings };
+  return { conversations: conversations.sort((a, b) => b.date.localeCompare(a.date)), warnings,
+    note: underOptChat ? `${underOptChat} session${underOptChat === 1 ? '' : 's'} ran under OptChat and ${underOptChat === 1 ? 'is' : 'are'} already in a profile's memory; skipped.` : undefined };
+}
+/**
+ * Lists a ZIP, or reads one member, with the system's own tool, which checks CRCs and handles ZIP64: `unzip` on macOS and
+ * Linux, and on Windows the bsdtar in System32 since Windows 10 (by full path, because Git's GNU tar on PATH can't read ZIP).
+ */
+async function unzip(zip: string, member?: string, signal?: AbortSignal) {
+  const windows = process.platform === 'win32';
+  const tool = windows ? join(process.env.SystemRoot ?? 'C:\\Windows', 'System32', 'tar.exe') : 'unzip';
+  const args = member === undefined ? (windows ? ['-tf', zip] : ['-Z1', zip]) : windows ? ['-xOf', zip, member] : ['-p', zip, member];
+  try { return (await exec(tool, args, { signal, maxBuffer: member === undefined ? 10_000_000 : 1_000_000_000, windowsHide: true })).stdout; }
+  catch (error) {
+    if (signal?.aborted || !record(error)) throw error;
+    // unzip opens with a `[file]` line and wraps its message, so keep the first sentence after it.
+    const said = string(error.stderr)?.split(/\r?\n/).filter(line => !line.trim().startsWith('[')).join(' ').replace(/\s+/g, ' ').trim();
+    const reason = error.code === 'ENOENT' ? `${tool} was not found` : said?.match(/^.*?[.!](?=\s|$)/)?.[0] ?? (said?.slice(0, 200) || String(error.message));
+    throw new Error(`Could not read ${member === undefined ? zip : `${member} in ${zip}`}: ${reason.replace(/[.!]$/, '')}. Extract the ZIP and select the folder instead.`);
+  }
 }
 export async function scanChatGPT(input: string, signal?: AbortSignal): Promise<Scan> {
   const path = resolve(input.startsWith('~/') ? join(homedir(), input.slice(2)) : input);
@@ -163,11 +233,8 @@ export async function scanChatGPT(input: string, signal?: AbortSignal): Promise<
   if (info.isDirectory()) {
     for (const file of await filesUnder(path, accept, signal)) documents.push({ file, content: await readFile(file, { encoding: 'utf8', signal }) });
   } else if (path.toLowerCase().endsWith('.zip')) {
-    const listing = await exec('unzip', ['-Z1', path], { signal, maxBuffer: 10_000_000 });
-    for (const name of listing.stdout.split('\n').filter(accept)) {
-      const result = await exec('unzip', ['-p', path, name], { signal, maxBuffer: 1_000_000_000 });
-      documents.push({ file: `${path}:${name}`, content: result.stdout });
-    }
+    for (const name of (await unzip(path, undefined, signal)).split(/\r?\n/).filter(accept))
+      documents.push({ file: `${path}:${name}`, content: await unzip(path, name, signal) });
   } else documents.push({ file: path, content: await readFile(path, { encoding: 'utf8', signal }) });
   if (!documents.length) throw new Error('No conversations.json or numbered conversation JSON files found. Select a ChatGPT export ZIP, extracted folder, or JSON file.');
   const conversations: Conversation[] = [], warnings: string[] = [];
@@ -271,6 +338,21 @@ async function readMemory(c: Conversation, signal?: AbortSignal): Promise<{ entr
     receipt: `import:${digest(JSON.stringify([c.source, c.id, hash]))}` }] };
 }
 
+/** Entries of a Pi or OMP session that are not on the path from its last entry back to the root: branches left by a rewind. */
+async function rewound(file: string, signal?: AbortSignal): Promise<Set<string>> {
+  const parents = new Map<string, string | undefined>();
+  let leaf: string | undefined;
+  for await (const { value: v } of jsonLines(file, [], Infinity, signal)) {
+    const id = string(v.id);
+    if (v.type === 'session' || !id) continue;
+    parents.set(id, string(v.parentId)); leaf = id;
+  }
+  // Older logs without parent links are one straight line.
+  if (![...parents.values()].some(Boolean)) return new Set();
+  const path = new Set<string>();
+  for (let at = leaf; at && !path.has(at); at = parents.get(at)) path.add(at);
+  return new Set([...parents.keys()].filter(id => !path.has(id)));
+}
 export async function readConversation(c: Conversation, signal?: AbortSignal): Promise<{ entries: ImportedEntry[]; warnings: string[] }> {
   signal?.throwIfAborted();
   if (c.source === 'claude-memory') return readMemory(c, signal);
@@ -348,6 +430,7 @@ export async function readConversation(c: Conversation, signal?: AbortSignal): P
       if (final) finish();
     };
     try {
+      const offPath = c.source === 'pi' ? await rewound(c.file, signal) : new Set<string>();
       for await (const { value: v, line } of jsonLines(c.file, warnings, Infinity, signal)) {
         const date = timestamp(v.timestamp, c.date);
         // Context replay and compaction scaffolding are not new user requests.
@@ -379,6 +462,17 @@ export async function readConversation(c: Conversation, signal?: AbortSignal): P
             else if (!final) pending = [];
           }
         }
+        if (c.source === 'pi') {
+          const id = string(v.id) ?? `line:${line}`, typed = piUserText(v), m = v.type === 'message' ? v.message : undefined;
+          // Off the path to the session's last entry: rewound, so kept for its intent but marked as not the outcome.
+          const mark = (content: string) => offPath.has(id) ? `[alternate branch]\n${content}` : content;
+          if (typed !== undefined) add(id, 'user', mark(typed), date, typed);
+          // A turn's answer is a reply that ended on its own and calls no tool. Any other reply is work in progress.
+          else if (record(m) && m.role === 'assistant' && (m.stopReason === 'stop' || m.stopReason === 'length') && Array.isArray(m.content)
+            && !m.content.some(block => record(block) && block.type === 'toolCall')) m.content.forEach((block: unknown, index: number) => {
+            if (record(block) && block.type === 'text') add(`${id}:${index}`, 'talk', mark(text(block)), date, text(block));
+          });
+        }
         if (c.source === 'codex' && v.type === 'session_meta' && record(v.payload) && codexSubagent(v.payload)) return { entries: [], warnings };
         if (c.source === 'codex' && v.type === 'event_msg' && record(v.payload)) {
           if (v.payload.type === 'task_complete') finish();

package/src/import/ui.ts

@@ -5,14 +5,16 @@ import { scanLocal, scanChatGPT, scanClaudeMemories, readConversation, type Conv
 import { deduplicate, type ImportMode, type ImportJob, type ImportProgress } from './job.ts';
 import { selectMany } from './multi-select.ts';
 import { homedir } from 'node:os';
+import { sep } from 'node:path';
 
 type ImportUI = { ui: Pick<ExtensionUIContext, 'select' | 'input' | 'confirm' | 'notify' | 'setWidget' | 'custom'> };
 const clean = (s: string) => s.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ');
 const size = (n: number) => `${(n / 1_000_000).toFixed(1)} MB`;
 export async function chooseImport(ctx: ImportUI, profile: string, memory: Memory, model: string, signal: AbortSignal): Promise<{ entries: ImportedEntry[]; mode: ImportMode } | undefined> {
-  const sourceLabel = await ctx.ui.select(`Import into ${profile} · source`, ['Claude Code', 'Claude Code memories', 'Codex', 'ChatGPT export'], { signal });
+  const sourceLabel = await ctx.ui.select(`Import into ${profile} · source`, ['Claude Code', 'Claude Code memories', 'Codex', 'Pi / OMP', 'ChatGPT export'], { signal });
   if (!sourceLabel) return;
-  const source: Source = sourceLabel === 'Claude Code' ? 'claude' : sourceLabel === 'Claude Code memories' ? 'claude-memory' : sourceLabel === 'Codex' ? 'codex' : 'chatgpt';
+  const source: Source = sourceLabel === 'Claude Code' ? 'claude' : sourceLabel === 'Claude Code memories' ? 'claude-memory'
+    : sourceLabel === 'Codex' ? 'codex' : sourceLabel === 'Pi / OMP' ? 'pi' : 'chatgpt';
   const unit = source === 'claude-memory' ? 'memories' : 'conversations';
   ctx.ui.setWidget('optchat-import', ['Scanning local conversation metadata…']);
   let scan;
@@ -24,12 +26,12 @@ export async function chooseImport(ctx: ImportUI, profile: string, memory: Memor
     } else scan = source === 'claude-memory' ? await scanClaudeMemories(undefined, signal) : await scanLocal(source, undefined, signal);
   } finally { ctx.ui.setWidget('optchat-import', undefined); }
   let candidates = scan.conversations;
-  if (!candidates.length) throw new Error(`No ${unit} found for this source.${scan.warnings.length ? '\n' + scan.warnings.slice(0, 4).map(clean).join('\n') : ''}`);
+  if (!candidates.length) throw new Error(`No ${unit} found for this source.${[...scan.note ? [scan.note] : [], ...scan.warnings.slice(0, 4)].map(w => '\n' + clean(w)).join('')}`);
   if (source !== 'chatgpt') {
     const counts = new Map<string, number>();
     for (const c of candidates) counts.set(c.project, (counts.get(c.project) ?? 0) + 1);
     const projects = [...counts].sort(([a, x], [b, y]) => y - x || a.localeCompare(b)).map(([p]) => p);
-    const selected = await selectMany(ctx.ui, 'Projects', projects, p => `${p.startsWith(homedir() + '/') ? '~' + p.slice(homedir().length) : p} (${counts.get(p)} ${unit})`, signal);
+    const selected = await selectMany(ctx.ui, scan.note ? `Projects · ${scan.note}` : 'Projects', projects, p => `${p.startsWith(homedir() + sep) ? '~' + p.slice(homedir().length) : p} (${counts.get(p)} ${unit})`, signal);
     if (!selected) return;
     candidates = candidates.filter(c => selected.includes(c.project));
   }

package/src/inbox.ts

@@ -2,7 +2,7 @@ import { randomUUID } from 'node:crypto';
 import { existsSync, readFileSync } from 'node:fs';
 import { join } from 'node:path';
 import { record } from './cache.ts';
-import { atomicWrite } from './profiles.ts';
+import { atomicWrite } from './memory.ts';
 import type { Memory } from './memory.ts';
 
 interface Arrival { id: string; text: string; date: string }
@@ -11,6 +11,8 @@ export class Inbox {
   private readonly file: string;
   private items: Arrival[];
   private readonly claimed = new Set<string>();
+  /** Typed while a run was going: Pi holds these until a turn boundary, and Esc or dequeue hands them back to the editor without telling extensions. */
+  private readonly queued = new Set<string>();
   constructor(directory: string) {
     this.file = join(directory, 'pending-inputs.json');
     const saved: unknown = existsSync(this.file) ? JSON.parse(readFileSync(this.file, 'utf8')) : [];
@@ -19,9 +21,18 @@ export class Inbox {
     this.items = saved;
   }
   private save() { atomicWrite(this.file, JSON.stringify(this.items)); }
-  record(text: string) {
+  record(text: string, queued = false) {
     const item = { id: randomUUID(), text, date: new Date().toISOString() };
-    this.items.push(item); this.save(); return item.id;
+    this.items.push(item); this.save();
+    if (queued) this.queued.add(item.id);
+    return item.id;
+  }
+  /** Call once a run settles: Pi has delivered everything it still held, so a queued input nobody claimed went back to the editor. */
+  dropReturned() {
+    const returned = new Set([...this.queued].filter(id => !this.claimed.has(id)));
+    this.queued.clear();
+    if (!returned.size) return;
+    this.items = this.items.filter(i => !returned.has(i.id)); this.save();
   }
   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. */
@@ -43,6 +54,6 @@ export class Inbox {
     for (const item of this.items) {
       if (!receipts.has(item.id)) { memory.append('user', item.text, item.date, item.id); count++; }
     }
-    this.items = []; this.claimed.clear(); this.save(); return count;
+    this.items = []; this.claimed.clear(); this.queued.clear(); this.save(); return count;
   }
 }

package/src/index.ts

@@ -1,20 +1,20 @@
 import { execFile } from 'node:child_process';
-import { existsSync, readFileSync } from 'node:fs';
+import { existsSync, readFileSync, writeSync } 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';
-import { Memory } from './memory.ts';
+import { atomicWrite, 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 { createProfile, instructions, isWindows, 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, typedText } from './transcript.ts';
+import { saveImages } from './images.ts';
+import { asUser, boundedMessage, buildContext, logMessage, previousExchange, reportReceipt, REPORT_RECEIPT, REPORT_TYPE, RUN_BOUNDARY, textContent, typedText } from './transcript.ts';
 import { registerReportRenderer, type ReportDetails } from './report-message.ts';
-import { memoryTools, result, SEARCH_DOC, searchTool } from './tools.ts';
+import { allowSearch, 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';
@@ -23,26 +23,37 @@ import { memoryDirectory, pendingImport, prepareImport, runImport, discardImport
 import { chooseImport, showProgress } from './import/ui.ts';
 import { IMPORT_GUIDANCE } from './import/guidance.ts';
 import { UsageLedger } from './usage.ts';
-import { showInspector, type InspectorPage } from './inspector.ts';
+import { oneLine, showInspector, type InspectorPage } from './inspector.ts';
 import { showAgentView } from './agent-view.ts';
 import { inspectorShortcut, mountNavigation } from './navigation.ts';
-import { serveWindows } from './window-bridge.ts';
+import { joinHeadless, serveWindows } from './window-bridge.ts';
 import { openConnectedWindow, registerConnectedRenderer } from './connected-window.ts';
 import { createHandoffSummarizer } from './handoff.ts';
 import { mainTitle, TabTitle } from './title.ts';
 import { showModelPicker, showSettings } from './settings-page.ts';
 
 const binding = 'optchat.profile';
+const CONNECT_MODES = ['auto', 'join', 'off'] as const;
+/** Print mode routes `process.stdout` to stderr so only the answer reaches stdout; the joined reply goes to fd 1 itself. */
+async function printReply(text: string) {
+  const bytes = Buffer.from(`${text}\n`);
+  for (let at = 0; at < bytes.length;) {
+    try { at += writeSync(1, bytes, at); }
+    catch (error) { if (!record(error) || error.code !== 'EAGAIN') throw error; await new Promise(resolve => setTimeout(resolve, 10)); }
+  }
+}
 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.';
 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);
+  allowSearch(toggle(toggle(prompt, CONTINUITY, previousExchange, VIEW_DOC), SEARCH_DOC, memorySearch, previousExchange ? VIEW_DOC + CONTINUITY : VIEW_DOC), memorySearch);
 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) {
   let active: Active | undefined;
   let remote: Awaited<ReturnType<typeof openConnectedWindow>> | undefined;
+  /** `pi -p` on a profile another Pi owns: the prompt goes to a subagent in that Pi (--optchat-connect). */
+  let joined: Awaited<ReturnType<typeof joinHeadless>> | undefined;
   let closeWindows: (() => Promise<void>) | undefined;
   let recovery: Promise<void> | undefined;
   let run: AgentMessage[] = [];
@@ -73,9 +84,20 @@ export default function optchat(pi: ExtensionAPI) {
   /** 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' });
+  pi.registerFlag('optchat-connect', { description: 'pi -p on a profile open in another Pi: auto (join it if busy, default), join (only join), off (error if busy)', type: 'string', default: 'auto' });
+  const connectMode = () => {
+    const mode = pi.getFlag('optchat-connect') ?? 'auto';
+    const known = CONNECT_MODES.find(m => m === mode);
+    if (!known) { process.exitCode = 1; throw new Error(`--optchat-connect must be ${CONNECT_MODES.join(', ')}; got ${String(mode)}`); }
+    return known;
+  };
+  /** Pi exits 0 after an extension error; a pipeline must see a failed join. */
+  const joinProfile = async (name: string) => {
+    try { return await joinHeadless(profilePath(name)); }
+    catch (error) { process.exitCode = 1; throw error; }
+  };
   const required = () => { if (!active) throw new Error('Choose an OptChat profile first: /optchat profile'); return active; };
   const status = (ctx: ExtensionContext) => {
     const a = active;
@@ -93,7 +115,7 @@ export default function optchat(pi: ExtensionAPI) {
       const message = run[logged];
       const receipt = receipts.get(message);
       logMessage(active.memory, message, receipt); logged++;
-      if (receipt && !receipt.startsWith('report:')) active.inbox.acknowledge(receipt);
+      if (receipt && !receipt.startsWith(REPORT_RECEIPT)) active.inbox.acknowledge(receipt);
       receipts.delete(message);
       if (message.role === 'user') {
         const text = textContent(message.content), index = reports.findIndex(r => !r.batch && r.text === text);
@@ -117,7 +139,7 @@ export default function optchat(pi: ExtensionAPI) {
     saveReports();
   };
   const stop = async () => {
-    remote?.close(); remote = undefined;
+    remote?.close(); remote = undefined; joined?.close(); joined = undefined;
     inspectorController?.abort(); unmountNavigation?.(); unmountNavigation = undefined;
     stopping = true; importController?.abort(); await importTask?.catch(() => {});
     if (!active) return;
@@ -136,7 +158,8 @@ export default function optchat(pi: ExtensionAPI) {
   };
   const CONNECT = 'Start a connected subagent conversation here', BACK = 'Back';
   const chooseProfile = async (ctx: ExtensionContext): Promise<string | undefined> => {
-    if (!ctx.hasUI) return undefined;
+    // Outside the TUI (print, json, RPC hosts) never pick or create a profile: a dialog would hang the host, and a guess could write into the wrong memory.
+    if (ctx.mode !== 'tui') return undefined;
     const names = listProfiles(), last = lastProfile();
     if (last) names.sort((a, b) => Number(b === last) - Number(a === last));
     const selected = await ctx.ui.select('OptChat profile', [...names, '+ Create profile']);
@@ -207,10 +230,17 @@ export default function optchat(pi: ExtensionAPI) {
     try {
       if (boundName && typeof flag === 'string' && flag !== boundName) throw new Error(`Session belongs to ${boundName}; cannot resume it as ${flag}.`);
       let name = boundName ?? (typeof flag === 'string' ? flag : await chooseProfile(ctx));
+      // Only plain `pi -p` joins: JSON and RPC output carry Pi's own events, which a joined reply would bypass.
+      const connect = ctx.mode === 'print' ? connectMode() : 'off';
+      if (connect === 'join' && !name) { process.exitCode = 1; throw new Error('--optchat-connect join needs a profile: pass --optchat-profile'); }
       for (;;) {
         if (!name) { status(ctx); return; }
-        try { await openProfile(name, ctx); break; }
-        catch (error) {
+        try {
+          if (connect === 'join') joined = await joinProfile(name);
+          else await openProfile(name, ctx);
+          break;
+        } catch (error) {
+          if (error instanceof ProfileBusyError && connect === 'auto') { joined = await joinProfile(name); break; }
           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]);
@@ -222,7 +252,10 @@ export default function optchat(pi: ExtensionAPI) {
       if (name !== boundName) pi.appendEntry(binding, { name });
     } catch (error) {
       if (active) await stop().catch(() => {});
-      fault = errorText(error); ctx.ui.notify(fault, 'error');
+      fault = errorText(error);
+      // Pi reports a throwing handler on stderr (print) or as an extension_error event (RPC); notify there is a no-op or easy to miss.
+      if (ctx.mode !== 'tui') throw error;
+      ctx.ui.notify(fault, 'error');
     }
     // Pi sets its own title once every session_start handler has finished, so put ours back afterwards.
     for (const ms of [0, 250, 1000]) setTimeout(() => title.reapply(), ms).unref();
@@ -232,6 +265,13 @@ export default function optchat(pi: ExtensionAPI) {
   pi.on('session_before_switch', () => remote || importing || active?.children.active ? { cancel: true } : undefined);
   pi.on('session_before_fork', () => remote || importing || active?.children.active ? { cancel: true } : undefined);
   pi.on('input', async (event, ctx) => {
+    if (joined) {
+      try {
+        if (event.images?.length) throw new Error('Joining a running profile accepts text only; provide a file path for the agent to read.');
+        await printReply(await joined.ask(event.text, ctx.cwd));
+      } catch (error) { process.stderr.write(`OptChat: ${errorText(error)}\n`); process.exitCode = 1; }
+      return { action: 'handled' };
+    }
     if (remote) {
       try {
         if (event.images?.length) throw new Error('Connected windows currently accept text only; provide a file path for the agent to read.');
@@ -239,10 +279,14 @@ export default function optchat(pi: ExtensionAPI) {
       } catch (error) { ctx.ui.notify(errorText(error), 'error'); ctx.ui.setEditorText(event.text); }
       return { action: 'handled' };
     }
-    if (!active) { ctx.ui.notify(fault ?? 'Select a profile with /optchat profile before chatting.', 'error'); return { action: 'handled' }; }
+    if (!active) {
+      // Without a profile or flag, a headless run is plain Pi. A requested profile that failed to open refuses instead of running without memory.
+      if (ctx.mode !== 'tui' && !fault) return { action: 'continue' };
+      ctx.ui.notify(fault ?? 'Select a profile with /optchat profile before chatting.', 'error'); return { action: 'handled' };
+    }
     if (importing || pendingImport(active.dir)) { ctx.ui.notify('This profile has an import in progress. Use /optchat import to resume or discard it, or switch profiles.', 'info'); return { action: 'handled' }; }
     if (event.source !== 'extension') {
-      try { active.inbox.record(event.text); }
+      try { active.inbox.record(event.text, event.streamingBehavior !== undefined); }
       catch (error) { ctx.ui.notify(`Could not save input: ${errorText(error)}`, 'error'); return { action: 'handled' }; }
     }
     return { action: 'continue' };
@@ -259,24 +303,32 @@ export default function optchat(pi: ExtensionAPI) {
     if (active && !runStarted) startRun(ctx);
   });
   pi.on('before_agent_start', (event, ctx) => {
+    if (!active) return; // Plain Pi run: leave Pi's own prompt untouched.
     startRun(ctx);
     const a = required();
     // Pi's own prompt sections (AGENTS.md files, skills, cwd) stay; the profile's instructions go last.
     syncSearch(a.config);
-    event.systemPromptOptions.customPrompt = `${MASTER}\n\n${VIEW_DOC}${a.config.previousExchange ? CONTINUITY : ''}${a.config.memorySearch ? SEARCH_DOC : ''}`;
+    event.systemPromptOptions.customPrompt = allowSearch(`${MASTER}\n\n${VIEW_DOC}${a.config.previousExchange ? CONTINUITY : ''}${a.config.memorySearch ? SEARCH_DOC : ''}`, a.config.memorySearch);
     event.systemPromptOptions.sections.instructions = `${instructions(a.dir)}\n\n${IMPORT_GUIDANCE}`;
     prompt = event.systemPrompt;
   });
-  pi.on('message_end', (event, ctx) => {
+  pi.on('message_end', async (event, ctx) => {
     if (!active || !runStarted) return;
     const bounded = boundedMessage(event.message);
     const message = asUser(bounded);
+    // Before the message is logged, so the image its text names is already there for zoom; zoom's own images are kept already.
+    if (message.role === 'user' || message.role === 'toolResult' && message.toolName !== 'zoom') {
+      try { await saveImages(active.memory.directory, message.content); }
+      catch (error) { ctx.ui.notify(`OptChat could not keep an image: ${errorText(error)}`, 'warning'); }
+    }
+    if (!active) return;
     if (message.role === 'user') {
       try {
         const text = textContent(message.content);
-        if (reports.some(r => !r.batch && r.text === text)) receipts.set(message, reportReceipt(text));
+        // A report is shown as our custom message, or sent as plain text before the first run has a prompt to reuse.
+        if (bounded.role === 'custom' && bounded.customType === REPORT_TYPE || 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.
+          // The inbox journaled the typed input: match without image references 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);
@@ -293,12 +345,21 @@ export default function optchat(pi: ExtensionAPI) {
   });
   pi.on('context_with_system', async (event, ctx) => {
     try {
+      if (!active) return; // Plain Pi run: pass context through unmodified.
       const a = required();
       if (importing || pendingImport(a.dir)) throw new Error('Profile is unavailable while importing.');
       if (fault) throw new Error(fault);
       if (view === undefined) {
-        ctx.ui.setWorkingMessage('Waiting for OptChat summaries…');
-        try { await a.memory.settle(ctx.signal); } finally { ctx.ui.setWorkingMessage(); }
+        // A misconfigured summarizer retries forever, so say why instead of spinning silently.
+        let shown: string | undefined;
+        const show = () => {
+          const error = a.memory.lastError;
+          const text = `Waiting for OptChat summaries…${error ? ` failing: ${oneLine(error)}${error.includes('/optchat') ? '' : ' (see /optchat model)'}` : ''}`;
+          if (text !== shown) ctx.ui.setWorkingMessage(shown = text);
+        };
+        show();
+        const unsubscribe = a.memory.onChange(show);
+        try { await a.memory.settle(ctx.signal); } finally { unsubscribe(); ctx.ui.setWorkingMessage(); }
         view = a.memory.render(); // Capture old history before logging the new input.
         flush();
       }
@@ -324,7 +385,7 @@ export default function optchat(pi: ExtensionAPI) {
   pi.on('turn_end', (_event, ctx) => collectUsage(ctx));
   pi.on('agent_settled', async (_event, ctx) => {
     collectUsage(ctx);
-    try { flush(); } catch (error) { fault = errorText(error); ctx.ui.notify(fault, 'error'); }
+    try { flush(); active?.inbox.dropReturned(); } catch (error) { fault = errorText(error); ctx.ui.notify(fault, 'error'); }
     if (runStarted) pi.appendEntry(RUN_BOUNDARY, { state: 'end' });
     runStarted = false; status(ctx);
     working = false; showTitle(ctx);
@@ -438,6 +499,7 @@ export default function optchat(pi: ExtensionAPI) {
     }
     if (action === 'profile') {
       if (!ctx.isIdle() || active?.children.active) throw new Error('Finish or stop active work before switching profiles.');
+      if (ctx.mode !== 'tui') throw new Error('/optchat profile requires interactive Pi. Start headless runs with --optchat-profile <name>.');
       const selected = await chooseProfile(ctx);
       if (!selected || selected === active?.name) return;
       await ctx.newSession({ setup: async manager => { manager.appendCustomEntry(binding, { name: selected }); } });
@@ -459,7 +521,8 @@ export default function optchat(pi: ExtensionAPI) {
     }
     if (action === 'browse') {
       const a = required(), file = exportBrowser(a.memory, a.name, a.dir);
-      if (ctx.hasUI) execFile(process.platform === 'darwin' ? 'open' : 'xdg-open', [file], error => { if (error) ctx.ui.notify(`Open ${file}`, 'info'); });
+      // explorer.exe exits 1 even when it opened the file, so only its launch failing counts there.
+      if (ctx.hasUI) execFile(isWindows ? 'explorer.exe' : process.platform === 'darwin' ? 'open' : 'xdg-open', [file], error => { if (error && (!isWindows || error.code === 'ENOENT')) ctx.ui.notify(`Open ${file}`, 'info'); });
       ctx.ui.notify(file, 'info'); return;
     }
     if (action) throw new Error('Use /optchat [profile|settings|model|agents|usage|activity|instructions|browse|import].');

package/src/inspector.ts

@@ -60,6 +60,8 @@ export class Inspector implements Component, Focusable {
   private lineCount = 0;
   private hintLines = 1;
   private range: UsageRange = 'This session';
+  private confirmDelete?: string;
+  private notice = '';
   private ended = false;
   private readonly unsubscribe: (() => void)[];
   private readonly timer: ReturnType<typeof setInterval>;
@@ -87,6 +89,7 @@ export class Inspector implements Component, Focusable {
   handleInput(data: string) {
     if (this.ended) return;
     if (matchesKey(data, 'escape') || matchesKey(data, 'ctrl+c')) return this.finish();
+    const deleting = this.confirmDelete; this.confirmDelete = undefined; this.notice = '';
     if (matchesKey(data, 'tab')) {
       this.page = nextPage(this.page); this.scroll = 0;
     } else if (this.page === 'activity') this.scrollInput(data);
@@ -103,10 +106,22 @@ export class Inspector implements Component, Focusable {
       else if (matchesKey(data, 'home')) this.select(-Infinity);
       else if (matchesKey(data, 'end')) this.select(Infinity);
       else if (data === 'm') return this.finish('model');
+      else if ((data === 'd' || matchesKey(data, 'delete')) && this.selected) {
+        if (deleting === this.selected) this.remove(this.selected);
+        else this.confirmDelete = this.selected;
+      }
       else if (matchesKey(data, 'return') && this.selected) return this.finish({ open: this.selected });
     }
     this.options.redraw();
   }
+  /** Once the run is gone, the cursor moves to the next row that is not, else the one above. */
+  private remove(id: string) {
+    const { children } = this.options, list = children.history.list(), doomed = new Set([id, ...children.history.descendants(id).map(r => r.id)]);
+    const index = list.findIndex(r => r.id === id), next = list.slice(index).find(r => !doomed.has(r.id)) ?? list.slice(0, index).findLast(r => !doomed.has(r.id));
+    children.remove(id).then(() => { if (!children.history.records.has(this.selected ?? '')) this.selected = next?.id; },
+      (error: unknown) => { this.notice = `Not deleted: ${error instanceof Error ? error.message : String(error)}`; })
+      .finally(() => { if (!this.ended) this.options.redraw(); });
+  }
   private scrollInput(data: string) {
     const delta = matchesKey(data, 'up') ? -1 : matchesKey(data, 'down') ? 1 : matchesKey(data, 'pageUp') ? -this.height : matchesKey(data, 'pageDown') ? this.height : 0;
     if (delta || matchesKey(data, 'home') || matchesKey(data, 'end')) {
@@ -191,10 +206,12 @@ export class Inspector implements Component, Focusable {
       });
       if (!body.length) body.push(color('muted', 'No agents yet. Ask the main agent to delegate a task.'));
       info = `${list.filter(isActiveRun).length} active · ${list.length} saved${list.length ? ` · ${cursor + 1}/${list.length}` : ''}`;
-      hint = '↑↓ select · Enter open · m model · Tab usage · Esc close';
+      hint = this.confirmDelete ? `Press d again to ${children.live(this.confirmDelete) ? 'stop and delete' : 'delete'} this agent and the agents it started`
+        : this.notice || '↑↓ select · Enter open · m model · d delete · Tab usage · Esc close';
     }
     title = fit(title, Math.max(1, inner - visibleWidth(info) - 2));
-    const footer = wrapTextWithAnsi(hint, inner).map(line => color('dim', line));
+    const tone = this.page !== 'agents' ? 'dim' : this.confirmDelete ? 'warning' : this.notice ? 'error' : 'dim';
+    const footer = wrapTextWithAnsi(hint, inner).map(line => color(tone, line));
     this.hintLines = footer.length;
     const rule = color('border', '─'.repeat(Math.max(1, width)));
     // Same layout as Pi's own selectors: rules above and below, content indented by one column.