pi-optchat 0.5.0

package/src/import/job.ts

@@ -0,0 +1,104 @@
+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 { atomicWrite } from '../profiles.ts';
+import { record } from '../cache.ts';
+import type { ImportedEntry } from './sources.ts';
+
+export type ImportMode = 'append' | 'rebuild';
+export interface ImportJob {
+  id: string; mode: ImportMode; previous: string; target: string; created: string;
+  added: number; skipped: number; total: number; inputBytes: number;
+}
+const pendingFile = (dir: string) => join(dir, 'imports', 'pending.json');
+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);
+}
+export function memoryDirectory(dir: string): string {
+  const file = join(dir, 'active-memory.json');
+  if (!existsSync(file)) return dir;
+  const name: unknown = JSON.parse(readFileSync(file, 'utf8'));
+  if (typeof name !== 'string') throw new Error('Invalid active memory pointer.');
+  const path = generationPath(dir, name);
+  if (!existsSync(join(path, 'main'))) throw new Error('Active memory generation is missing.');
+  return path;
+}
+export function pendingImport(dir: string): ImportJob | undefined {
+  if (!existsSync(pendingFile(dir))) return undefined;
+  const j: unknown = JSON.parse(readFileSync(pendingFile(dir), 'utf8'));
+  if (!record(j) || typeof j.id !== 'string' || !/^[a-f0-9-]{36}$/.test(j.id)
+    || !['append', 'rebuild'].includes(String(j.mode)) || typeof j.previous !== 'string' || j.target !== `memories/${j.id}`
+    || typeof j.created !== 'string' || !['added', 'skipped', 'total', 'inputBytes'].every(k => Number.isSafeInteger(j[k]) && Number(j[k]) >= 0))
+    throw new Error('Invalid import journal. Refusing to change profile memory.');
+  generationPath(dir, j.previous);
+  return { id: j.id, mode: j.mode === 'append' ? 'append' : 'rebuild', previous: j.previous, target: `memories/${j.id}`,
+    created: j.created, added: Number(j.added), skipped: Number(j.skipped), total: Number(j.total), inputBytes: Number(j.inputBytes) };
+}
+export function deduplicate(existing: readonly Entry[], incoming: readonly ImportedEntry[]) {
+  const receipts = new Set(existing.map(e => e.receipt).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);
+  }
+  return { added, skipped };
+}
+/** Imported conversations remain contiguous; existing native history is grouped by user turn. */
+export function chronological(entries: readonly ImportedEntry[]) {
+  const groups = new Map<string, { date: string; entries: ImportedEntry[] }>();
+  let native = 0;
+  for (const entry of entries) {
+    if (!entry.origin && entry.kind === 'user') native++;
+    const id = entry.origin ? JSON.stringify([entry.origin.source, entry.origin.conversation]) : `native:${native}`;
+    const group = groups.get(id) ?? { date: entry.date, entries: [] };
+    group.date = group.date < entry.date ? group.date : entry.date;
+    group.entries.push(entry); groups.set(id, group);
+  }
+  return [...groups.values()].sort((a, b) => a.date.localeCompare(b.date)).flatMap(g => g.entries);
+}
+/** Call only while holding the profile lock, after closing its old Memory worker. */
+export function prepareImport(dir: string, old: Memory, incoming: readonly ImportedEntry[], mode: ImportMode): ImportJob | undefined {
+  if (pendingImport(dir)) throw new Error('Resume or discard the pending import first.');
+  const { added, skipped } = deduplicate(old.root, incoming);
+  if (!added.length) return undefined;
+  const id = randomUUID(), target = `memories/${id}`, path = generationPath(dir, target);
+  // 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');
+  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,
+    inputBytes: (mode === 'rebuild' ? entries : added).reduce((n, e) => n + bytes(e.text), 0) };
+  atomicWrite(pendingFile(dir), JSON.stringify(job, null, 2));
+  return job;
+}
+export function discardImport(dir: string) {
+  const job = pendingImport(dir); if (!job) return;
+  if (memoryDirectory(dir) === generationPath(dir, job.target)) throw new Error('Import is already activated; it cannot be discarded.');
+  // Remove the journal first: any interruption leaves only an unused staging directory.
+  rmSync(pendingFile(dir)); rmSync(generationPath(dir, job.target), { recursive: true, force: true });
+}
+export interface ImportProgress { messages: number; total: number; summaries: number; error?: string }
+export async function runImport(dir: string, compress: Compressor, signal: AbortSignal,
+  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 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 timer = setInterval(report, 500);
+  try {
+    report(); 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;
+  } finally { clearInterval(timer); await memory.close(); }
+}

package/src/import/multi-select.ts

@@ -0,0 +1,98 @@
+import { Input, matchesKey, truncateToWidth, type Component, type Focusable } from '@earendil-works/pi-tui';
+import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+
+const clean = (text: string) => text.replace(/[\x00-\x1f\x7f-\x9f]/g, ' ');
+interface Options {
+  title: string;
+  labels: string[];
+  rows: () => number;
+  redraw: () => void;
+  done: (indices: number[] | undefined) => void;
+  color: (tone: 'accent' | 'dim' | 'error', text: string) => string;
+  signal?: AbortSignal;
+}
+
+/** One mounted picker: toggling never recreates the dialog or resets its viewport. */
+export class MultiSelect implements Component, Focusable {
+  private readonly filter = new Input({ prompt: 'Filter: ', placeholder: 'type to filter' });
+  private readonly labels: string[];
+  private readonly selected = new Set<number>();
+  private visible: number[];
+  private cursor = 0;
+  private top = 0;
+  private ended = false;
+  private error = '';
+  constructor(private readonly options: Options) {
+    this.labels = options.labels.map(clean);
+    this.visible = this.labels.map((_, i) => i);
+    options.signal?.addEventListener('abort', this.abort, { once: true });
+    if (options.signal?.aborted) queueMicrotask(this.abort);
+  }
+  get focused() { return this.filter.focused; }
+  set focused(value: boolean) { this.filter.focused = value; }
+  private get pageSize() { return Math.max(1, Math.min(20, this.options.rows() - 12)); }
+  private readonly abort = () => this.finish(undefined);
+  private finish(result: number[] | undefined) {
+    if (this.ended) return;
+    this.dispose(); this.options.done(result);
+  }
+  dispose() { this.ended = true; this.options.signal?.removeEventListener('abort', this.abort); }
+  invalidate() { this.filter.invalidate(); }
+  handleInput(data: string) {
+    if (this.ended) return;
+    this.error = '';
+    if (matchesKey(data, 'escape') || matchesKey(data, 'ctrl+c')) return this.finish(undefined);
+    if (matchesKey(data, 'return')) {
+      if (this.selected.size) return this.finish([...this.selected].sort((a, b) => a - b));
+      this.error = 'Select at least one item with Space.';
+    } else if (matchesKey(data, 'space')) {
+      const index = this.visible[this.cursor];
+      if (index !== undefined) { if (this.selected.has(index)) this.selected.delete(index); else this.selected.add(index); }
+    } else if (matchesKey(data, 'ctrl+a')) this.visible.forEach(i => this.selected.add(i));
+    else if (matchesKey(data, 'ctrl+d')) this.visible.forEach(i => this.selected.delete(i));
+    else if (matchesKey(data, 'down')) this.cursor++;
+    else if (matchesKey(data, 'up')) this.cursor--;
+    else if (matchesKey(data, 'pageDown')) this.cursor += this.pageSize;
+    else if (matchesKey(data, 'pageUp')) this.cursor -= this.pageSize;
+    else if (matchesKey(data, 'home')) this.cursor = 0;
+    else if (matchesKey(data, 'end')) this.cursor = this.visible.length - 1;
+    else {
+      const before = this.filter.getValue(); this.filter.handleInput(data);
+      if (this.filter.getValue() !== before) {
+        const query = clean(this.filter.getValue()).toLocaleLowerCase();
+        this.visible = this.labels.map((_, i) => i).filter(i => this.labels[i].toLocaleLowerCase().includes(query));
+        this.cursor = 0; this.top = 0;
+      }
+    }
+    this.cursor = Math.max(0, Math.min(this.cursor, this.visible.length - 1));
+    this.options.redraw();
+  }
+  render(width: number): string[] {
+    const { color } = this.options;
+    const page = this.pageSize;
+    this.top = Math.max(0, Math.min(this.top, this.visible.length - page));
+    if (this.cursor < this.top) this.top = this.cursor;
+    if (this.cursor >= this.top + page) this.top = this.cursor - page + 1;
+    const lines = [color('accent', `${clean(this.options.title)} · ${this.selected.size} selected`), ...this.filter.render(width), ''];
+    for (let row = this.top; row < Math.min(this.visible.length, this.top + page); row++) {
+      const index = this.visible[row];
+      const label = `${row === this.cursor ? '→' : ' '} [${this.selected.has(index) ? 'x' : ' '}] ${index + 1}. ${this.labels[index]}`;
+      lines.push(row === this.cursor ? color('accent', truncateToWidth(label, width)) : truncateToWidth(label, width));
+    }
+    if (!this.visible.length) lines.push('No matches. Ctrl+U clears the filter.');
+    lines.push(color('dim', `${this.visible.length ? this.cursor + 1 : 0}/${this.visible.length} matching · ${this.labels.length} total`));
+    lines.push(color(this.error ? 'error' : 'dim', this.error || '↑↓ move · PgUp/PgDn page · Home/End jump'));
+    lines.push(color('dim', 'Space toggle · Enter continue · Esc cancel'));
+    lines.push(color('dim', 'Ctrl+A select matches · Ctrl+D clear matches'));
+    return lines.map(line => truncateToWidth(line, width));
+  }
+}
+
+export async function selectMany<T>(ui: Pick<ExtensionUIContext, 'custom'>, title: string, items: T[], label: (item: T) => string, signal: AbortSignal): Promise<T[] | undefined> {
+  if (signal.aborted) return undefined;
+  const indices = await ui.custom<number[] | undefined>((tui, theme, _keys, done) => new MultiSelect({
+    title, labels: items.map(label), rows: () => tui.terminal.rows,
+    redraw: () => tui.requestRender(), done, color: (tone, text) => theme.fg(tone, text), signal,
+  }));
+  return indices?.map(i => items[i]);
+}

package/src/import/sources.ts

@@ -0,0 +1,278 @@
+import { createReadStream } from 'node:fs';
+import { readdir, readFile, stat } from 'node:fs/promises';
+import { createInterface } from 'node:readline';
+import { basename, dirname, join, relative, resolve } from 'node:path';
+import { homedir } from 'node:os';
+import { execFile } from 'node:child_process';
+import { promisify } from 'node:util';
+import { createHash } from 'node:crypto';
+import { record } from '../cache.ts';
+import { bytes, type Entry, type Kind, type Origin } from '../memory.ts';
+
+export type Source = Origin['source'];
+export type ImportedEntry = Omit<Entry, 'i' | 'size'>;
+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[] }
+const exec = promisify(execFile);
+const string = (v: unknown) => typeof v === 'string' ? v : undefined;
+const codexSubagent = (metadata: Record<string, unknown>) => metadata.source === 'subagent'
+  || record(metadata.source) && 'subagent' in metadata.source;
+const missingSource = (error: unknown) => record(error) && (error.code === 'ENOENT' || error.code === 'ENOTDIR');
+const missingWarning = (file: string) => `${file}: source file is no longer available; conversation skipped. Rescan to retry if it returns.`;
+export function timestamp(value: unknown, fallback: string): string {
+  const time = typeof value === 'number' ? value * 1000 : typeof value === 'string' ? Date.parse(value) : NaN;
+  return Number.isFinite(time) ? new Date(time).toISOString() : fallback;
+}
+function text(value: unknown): string {
+  if (typeof value === 'string') return value;
+  if (Array.isArray(value)) return value.map(text).filter(Boolean).join('\n');
+  if (!record(value)) return '';
+  if (['thinking', 'redacted_thinking', 'reasoning', 'encrypted_content'].includes(String(value.type))) return '';
+  if (typeof value.text === 'string') return value.text;
+  if (['image', 'image_url', 'input_image', 'image_asset_pointer'].includes(String(value.type ?? value.content_type))) return '[image attachment; image bytes are not imported]';
+  if (value.content !== undefined) return text(value.content);
+  if (value.parts !== undefined) return text(value.parts);
+  if (typeof value.content_type === 'string') return `[${value.content_type} attachment; binary content is not imported]`;
+  return '';
+}
+const digest = (s: string) => createHash('sha256').update(s).digest('hex');
+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}`,
+    receipt: `import:${digest(JSON.stringify([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 });
+  const lines = createInterface({ input: stream, crlfDelay: Infinity });
+  let n = 0;
+  try {
+    for await (const line of lines) {
+      n++; if (!line.trim()) continue;
+      try { const value: unknown = JSON.parse(line); if (record(value)) yield { value, line: n }; }
+      catch { warnings.push(`${file}:${n}: invalid JSON record skipped`); }
+      if (n >= limit) break;
+    }
+  } finally { lines.close(); stream.destroy(); }
+}
+async function filesUnder(path: string, accept: (name: string) => boolean, signal?: AbortSignal): Promise<string[]> {
+  signal?.throwIfAborted();
+  const entries = await readdir(path, { withFileTypes: true }).catch(error => {
+    if (record(error) && error.code === 'ENOENT') return [];
+    throw error;
+  });
+  const files: string[] = [];
+  for (const entry of entries) {
+    if (entry.isDirectory()) files.push(...await filesUnder(join(path, entry.name), accept, signal));
+    else if (entry.isFile() && accept(entry.name)) files.push(join(path, entry.name));
+  }
+  return files.sort();
+}
+export async function scanLocal(source: 'claude' | 'codex', roots?: string[], signal?: AbortSignal): Promise<Scan> {
+  const folders = roots ?? (source === 'claude' ? [join(homedir(), '.claude/projects')]
+    : [join(homedir(), '.codex/sessions'), join(homedir(), '.codex/archived_sessions')]);
+  const conversations: Conversation[] = [], warnings: string[] = [];
+  // 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;
+    try {
+      const info = await stat(file);
+      let id = basename(file, '.jsonl'), project = dirname(file), date = info.mtime.toISOString(), title = '';
+      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.
+        if (source === 'claude' && v.isSidechain === true) { sidechain = true; break; }
+        if (line > 60) continue;
+        if (source === 'codex' && v.type === 'session_meta' && record(v.payload)) {
+          if (codexSubagent(v.payload)) { sidechain = true; break; }
+          id = string(v.payload.id) ?? id; project = string(v.payload.cwd) ?? project; date = timestamp(v.payload.timestamp ?? v.timestamp, date);
+        }
+        if (source === 'claude') {
+          id = string(v.sessionId) ?? id;
+          project = string(v.cwd) ?? project;
+          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);
+          date = timestamp(v.timestamp, date);
+        }
+      }
+      if (sidechain) continue;
+      conversations.push({ source, file, id, project, date, title: 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 };
+}
+export async function scanChatGPT(input: string, signal?: AbortSignal): Promise<Scan> {
+  const path = resolve(input.startsWith('~/') ? join(homedir(), input.slice(2)) : input);
+  const info = await stat(path);
+  const documents: { file: string; content: string }[] = [];
+  const accept = (name: string) => /^conversations(?:[-_]?\d+)?\.json$/i.test(basename(name));
+  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 });
+    }
+  } 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[] = [];
+  for (const doc of documents) {
+    const data: unknown = JSON.parse(doc.content);
+    if (!Array.isArray(data)) throw new Error(`${doc.file}: expected an array of exported ChatGPT conversations.`);
+    for (const value of data) {
+      if (!record(value) || !record(value.mapping) || typeof (value.id ?? value.conversation_id) !== 'string') {
+        warnings.push(`${doc.file}: unrecognized conversation skipped`); continue;
+      }
+      const id = String(value.id ?? value.conversation_id);
+      conversations.push({ source: 'chatgpt', id, file: doc.file, title: string(value.title) ?? id,
+        project: 'ChatGPT', date: timestamp(value.create_time, info.mtime.toISOString()), size: bytes(JSON.stringify(value)), exported: value });
+    }
+  }
+  return { conversations: conversations.sort((a, b) => b.date.localeCompare(a.date)), warnings };
+}
+
+export async function readConversation(c: Conversation, signal?: AbortSignal): Promise<{ entries: ImportedEntry[]; warnings: string[] }> {
+  signal?.throwIfAborted();
+  const entries: ImportedEntry[] = [], warnings: string[] = [];
+  const add = (id: string, kind: Kind, value: string, date: string, identity = value) => { const entry = imported(c, id, kind, value, date, identity); if (entry) entries.push(entry); };
+  if (c.source === 'chatgpt') {
+    const mapping = c.exported?.mapping;
+    if (!record(mapping)) throw new Error('ChatGPT conversation has no message mapping.');
+    // Include every branch once. Parent-first traversal handles missing child timestamps.
+    const nodes = Object.entries(mapping).filter((pair): pair is [string, Record<string, unknown>] => record(pair[1]));
+    nodes.sort((a, b) => timestamp(record(a[1].message) ? a[1].message.create_time : undefined, c.date)
+      .localeCompare(timestamp(record(b[1].message) ? b[1].message.create_time : undefined, c.date)));
+    const ordered: typeof nodes = [], visited = new Set<string>(), visiting = new Set<string>();
+    const visit = (key: string, node: Record<string, unknown>) => {
+      if (visited.has(key)) return;
+      if (visiting.has(key)) throw new Error(`${c.title}: cycle in ChatGPT conversation mapping.`);
+      visiting.add(key);
+      const parent = typeof node.parent === 'string' ? mapping[node.parent] : undefined;
+      if (typeof node.parent === 'string' && record(parent)) visit(node.parent, parent);
+      visiting.delete(key); visited.add(key); ordered.push([key, node]);
+    };
+    for (const [key, node] of nodes) visit(key, node);
+    const selected = new Set<string>();
+    let cursor = string(c.exported?.current_node);
+    const hasSelectedBranch = !!cursor;
+    while (cursor && !selected.has(cursor)) {
+      const node = mapping[cursor]; if (!record(node)) break;
+      selected.add(cursor); cursor = string(node.parent);
+    }
+    const dates = new Map<string, string>();
+    // For legacy exports without final/end_turn markers, exclude replies followed by
+    // more assistant/tool work before the next user message, on the same branch.
+    const intermediate = new Set<string>();
+    for (const [, node] of ordered) {
+      if (!record(node.message) || !record(node.message.author) || !['assistant', 'tool'].includes(String(node.message.author.role))) continue;
+      let parent = string(node.parent);
+      while (parent) {
+        const ancestor = mapping[parent]; if (!record(ancestor)) break;
+        if (record(ancestor.message) && record(ancestor.message.author) && ancestor.message.author.role === 'user') break;
+        if (intermediate.has(parent)) break;
+        intermediate.add(parent); parent = string(ancestor.parent);
+      }
+    }
+    for (const [key, node] of ordered) {
+      signal?.throwIfAborted();
+      const m = node.message;
+      const date = timestamp(record(m) ? m.create_time : undefined, dates.get(String(node.parent)) ?? c.date);
+      dates.set(key, date);
+      if (!record(m) || !record(m.author) || !['user', 'assistant'].includes(String(m.author.role))) continue;
+      if (m.channel === 'analysis' || m.channel === 'commentary'
+        || m.recipient && m.recipient !== 'all'
+        || record(m.content) && ['thoughts', 'reasoning', 'reasoning_recap'].includes(String(m.content.content_type))) continue;
+      const kind = m.author.role === 'user' ? 'user' : 'talk';
+      if (kind === 'talk' && (m.status && m.status !== 'finished_successfully'
+        || m.end_turn === false || m.channel !== 'final' && m.end_turn !== true && intermediate.has(key))) continue;
+      const content = text(m.content); if (!content) continue;
+      const branch = hasSelectedBranch ? selected.has(key) ? 'selected branch at export' : 'alternate branch, not the selected outcome' : 'branch selection unavailable';
+      add(string(m.id) ?? key, kind, `[message ${key}; parent ${String(node.parent ?? 'root')}; ${branch}${m.recipient ? `; recipient ${String(m.recipient)}` : ''}]\n${content}`, date, content);
+    }
+    if (hasSelectedBranch) {
+      const snapshot = timestamp(c.exported?.update_time, c.date);
+      add('export:selected-branch', 'note', `Selected ChatGPT branch in the ${snapshot} export snapshot ends at message ${String(c.exported?.current_node)}. Other branches are alternatives.`, snapshot);
+    }
+  } else {
+    let pending: ImportedEntry[] = [];
+    const finish = () => { entries.push(...pending); pending = []; };
+    const assistant = (parts: { id: string; content: string }[], date: string, final: boolean) => {
+      pending = parts.flatMap(part => {
+        const entry = imported(c, part.id, 'talk', part.content, date);
+        return entry ? [entry] : [];
+      });
+      if (final) finish();
+    };
+    try {
+      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.
+        if (c.source === 'claude' && v.type === 'system' && v.subtype === 'compact_boundary') { pending = []; continue; }
+        if (c.source === 'claude' && (v.isMeta === true || v.isCompactSummary === true)) continue;
+        if (c.source === 'claude' && v.isSidechain === true) return { entries: [], warnings };
+        if (c.source === 'claude' && ['user', 'assistant'].includes(String(v.type)) && record(v.message)) {
+          const m = v.message, id = string(v.uuid) ?? `line:${line}`;
+          if (m.role === 'user' && typeof m.content === 'string' && /^\[Request interrupted by user(?: for tool use)?\]$/.test(m.content)) { pending = []; continue; }
+          const blocks = Array.isArray(m.content) ? m.content : [];
+          const toolActivity = blocks.some(b => record(b) && (['tool_use', 'server_tool_use', 'tool_result'].includes(String(b.type)) || String(b.type).endsWith('_tool_result')));
+          if (toolActivity) pending = [];
+          const parts = typeof m.content === 'string' ? [{ id, content: m.content }] : blocks.flatMap((b, index) => {
+            if (!record(b)) return [];
+            if (['text', 'image', 'image_url', 'document'].includes(String(b.type))) {
+              const content = b.type === 'document' ? '[document attachment; binary content is not imported]' : text(b);
+              return content ? [{ id: `${id}:${index}`, content }] : [];
+            }
+            if (!['tool_use', 'server_tool_use', 'tool_result', 'thinking', 'redacted_thinking', 'reasoning', 'encrypted_content'].includes(String(b.type)) && !String(b.type).endsWith('_tool_result'))
+              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); }
+          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 = [];
+            else if (parts.length) assistant(parts, date, final);
+            else if (!final) pending = [];
+          }
+        }
+        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();
+          if (['turn_aborted', 'task_started', 'task_failed'].includes(String(v.payload.type))) pending = [];
+        }
+        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); }
+          else if (m.type === 'message' && m.role === 'assistant') {
+            pending = [];
+            const channel = m.channel ?? m.phase;
+            const final = channel === 'final' || channel === 'final_answer';
+            if (!channel || final) assistant([{ id, content: text(m.content) }], date, final);
+          } else if (['function_call', 'custom_tool_call', 'function_call_output', 'custom_tool_call_output', 'web_search_call', 'image_generation_call', 'local_shell_call', 'agent_message'].includes(String(m.type))) pending = [];
+          else if (!['message', 'reasoning'].includes(String(m.type))) { pending = []; warnings.push(`${c.file}:${line}: unsupported response item ${String(m.type)} skipped`); }
+        }
+      }
+      finish(); // Older exports may omit explicit final markers; retain only the last text reply.
+    } catch (error) {
+      signal?.throwIfAborted();
+      if (!missingSource(error)) throw error;
+      // Do not stage a partial conversation if the source becomes unavailable mid-read.
+      return { entries: [], warnings: [...warnings, missingWarning(c.file)] };
+    }
+  }
+  const unique = new Map(entries.map(e => [e.receipt, e]));
+  return { entries: [...unique.values()], warnings };
+}

package/src/import/ui.ts

@@ -0,0 +1,105 @@
+import type { ExtensionUIContext } from '@earendil-works/pi-coding-agent';
+import type { Memory } from '../memory.ts';
+import { bytes } from '../memory.ts';
+import { scanLocal, scanChatGPT, readConversation, type Conversation, type ImportedEntry, type Source } from './sources.ts';
+import { deduplicate, type ImportMode, type ImportJob, type ImportProgress } from './job.ts';
+import { selectMany } from './multi-select.ts';
+import { homedir } from 'node:os';
+
+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', 'Codex', 'ChatGPT export'], { signal });
+  if (!sourceLabel) return;
+  const source: Source = sourceLabel === 'Claude Code' ? 'claude' : sourceLabel === 'Codex' ? 'codex' : 'chatgpt';
+  ctx.ui.setWidget('optchat-import', ['Scanning local conversation metadata…']);
+  let scan;
+  try {
+    if (source === 'chatgpt') {
+      const path = await ctx.ui.input('ChatGPT export ZIP, extracted folder, or conversations JSON path', undefined, { signal });
+      if (!path?.trim()) return;
+      scan = await scanChatGPT(path.trim(), signal);
+    } else scan = await scanLocal(source, undefined, signal);
+  } finally { ctx.ui.setWidget('optchat-import', undefined); }
+  let candidates = scan.conversations;
+  if (!candidates.length) throw new Error(`No conversations found for this source.${scan.warnings.length ? '\n' + scan.warnings.slice(0, 4).map(clean).join('\n') : ''}`);
+  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)} conversations)`, signal);
+    if (!selected) return;
+    candidates = candidates.filter(c => selected.includes(c.project));
+  }
+  const range = await ctx.ui.select('Conversation dates', ['All history', 'Filter by start date'], { signal });
+  if (!range) return;
+  if (range === 'Filter by start date') {
+    const after = await ctx.ui.input('Started on/after YYYY-MM-DD (blank = no lower bound)', undefined, { signal }); if (after === undefined) return;
+    const before = await ctx.ui.input('Started on/before YYYY-MM-DD (blank = no upper bound)', undefined, { signal }); if (before === undefined) return;
+    for (const day of [after, before]) if (day && (!/^\d{4}-\d{2}-\d{2}$/.test(day) || !Number.isFinite(Date.parse(day)) || new Date(day).toISOString().slice(0, 10) !== day)) throw new Error('Enter dates as YYYY-MM-DD.');
+    if (after && before && after > before) throw new Error('Start date must precede end date.');
+    candidates = candidates.filter(c => (!after || c.date.slice(0, 10) >= after) && (!before || c.date.slice(0, 10) <= before));
+  }
+  if (!candidates.length) throw new Error('No conversations match these dates.');
+  const scope = await ctx.ui.select(`${candidates.length} conversations · ${size(candidates.reduce((n, c) => n + c.size, 0))} source files`, ['All matching conversations', 'Choose individual conversations'], { signal });
+  if (!scope) return;
+  const conversations: Conversation[] | undefined = scope === 'Choose individual conversations'
+    ? await selectMany(ctx.ui, 'Conversations', candidates, c => `${c.date.slice(0, 10)} · ${c.title} · ${c.id}`, signal) : candidates;
+  if (!conversations) return;
+  const entries: ImportedEntry[] = [], warnings = [...scan.warnings];
+  try {
+    for (const [i, c] of conversations.entries()) {
+      ctx.ui.setWidget('optchat-import', [`Reading ${i + 1}/${conversations.length}: ${clean(c.title)}`]);
+      const parsed = await readConversation(c, signal);
+      for (const entry of parsed.entries) entries.push(entry);
+      for (const warning of parsed.warnings) warnings.push(warning);
+    }
+  } finally { ctx.ui.setWidget('optchat-import', undefined); }
+  if (warnings.length) {
+    const choice = await ctx.ui.select(`${warnings.length} source issues: unavailable conversations or unsupported records.\n${warnings.slice(0, 4).map(clean).join('\n')}`, ['Cancel', 'Continue with supported records'], { signal });
+    if (choice !== 'Continue with supported records') return;
+  }
+  if (!entries.length) { ctx.ui.notify('No readable messages remain to import. Rescan or choose different conversations.', 'info'); return; }
+  const { added, skipped } = deduplicate(memory.root, entries);
+  if (!added.length) { ctx.ui.notify(`Nothing new to import (${skipped} messages already present).`, 'info'); return; }
+  let mode: ImportMode = 'append';
+  if (memory.root.length) {
+    const selected = await ctx.ui.select('How should this history join your memory?', [
+      `Append · keep ${memory.tree.size} existing summaries`,
+      `Rebuild by conversation start date · recompress ${memory.root.length + added.length} messages`,
+    ], { signal });
+    if (!selected) return;
+    mode = selected.startsWith('Rebuild') ? 'rebuild' : 'append';
+  }
+  const affected = mode === 'rebuild' ? [...memory.root, ...added] : added;
+  const inputBytes = affected.reduce((n, e) => n + bytes(e.text), 0);
+  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}\nHistorical user messages and final replies; tool activity excluded.\n${conversations.length} conversations selected · ${added.length} new 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.`;
+  if (!await ctx.ui.confirm('Start import?', preview, { signal })) return;
+  return { entries, mode };
+}
+export async function showProgress(ctx: { ui: Pick<ExtensionUIContext, 'select' | 'setWidget'> }, job: ImportJob,
+  run: (signal: AbortSignal, progress: (value: ImportProgress) => void) => Promise<unknown>, outerSignal: AbortSignal) {
+  const controller = new AbortController(), finished = new AbortController();
+  const abort = () => controller.abort(); outerSignal.addEventListener('abort', abort, { once: true });
+  if (outerSignal.aborted) abort();
+  const task = run(controller.signal, p => ctx.ui.setWidget('optchat-import', [
+    `${job.mode} import · ${p.messages}/${p.total} messages indexed · ${p.summaries} summary nodes`,
+    p.error ? `Retrying: ${clean(p.error)} · you can pause` : 'The original memory stays intact until this finishes.',
+  ]));
+  // Attach a rejection handler immediately; UI and model failures can happen independently.
+  const outcome = task.then(() => ({ complete: true as const }), error => ({ complete: false as const, error })).finally(() => finished.abort());
+  try {
+    await ctx.ui.select('Import in progress', ['Pause import'], { signal: finished.signal });
+    if (!finished.signal.aborted) controller.abort();
+    const result = await outcome;
+    if (!result.complete && !controller.signal.aborted) throw result.error;
+    return result.complete;
+  } finally {
+    controller.abort(); await outcome;
+    outerSignal.removeEventListener('abort', abort); ctx.ui.setWidget('optchat-import', undefined);
+  }
+}

package/src/inbox.ts

@@ -0,0 +1,42 @@
+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 type { Memory } from './memory.ts';
+
+interface Arrival { id: string; text: string; date: string }
+/** Durable arrivals bridge the period before a new turn's old-history snapshot is ready. */
+export class Inbox {
+  private readonly file: string;
+  private items: Arrival[];
+  private readonly claimed = 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')) : [];
+    if (!Array.isArray(saved) || !saved.every(v => record(v) && typeof v.id === 'string' && typeof v.text === 'string' && typeof v.date === 'string'))
+      throw new Error('Invalid pending input journal.');
+    this.items = saved;
+  }
+  private save() { atomicWrite(this.file, JSON.stringify(this.items)); }
+  record(text: string) {
+    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);
+    if (!item) return undefined;
+    this.claimed.add(item.id); return item.id;
+  }
+  acknowledge(id: string) {
+    this.items = this.items.filter(i => i.id !== id); this.claimed.delete(id); this.save();
+  }
+  recover(memory: Memory) {
+    let count = 0;
+    const receipts = new Set(memory.root.map(e => e.receipt));
+    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;
+  }
+}