pi-optchat 0.6.7 → 0.7.0

package/src/compactor.ts

@@ -1,16 +1,21 @@
-import type { AssistantMessage, Message } from '@earendil-works/pi-ai';
+import { clampThinkingLevel, type Api, type AssistantMessage, type Message, type Model } from '@earendil-works/pi-ai';
 import type { ThinkingLevel } from '@earendil-works/pi-agent-core';
 import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
 import { COMPACT } from './prompts.ts';
 import { bytes, NODE, type Compressor } from './memory.ts';
 import { cachePayload, splitView } from './cache.ts';
 import { IMPORT_GUIDANCE } from './import/guidance.ts';
+import { DEFAULT_SETTINGS } from './settings.ts';
 
 export interface ModelChoice { provider: string; model: string; thinking: ThinkingLevel }
-const scaleBase = 'user: Keep work and personal memory separate; use a binary summary tree and inspect original messages before acting. talk: Implemented the append-only log with durable writes and a stable view. echo: Checked caching, chronological summaries, cancellation, and profile locks. user: Main agent uses Opus; compactor uses Sonnet at medium effort. work: Worker completed the parser; tests cover invalid records and repeated imports. talk: The browser opens original messages, preserving dates and sources.';
-export const SCALE = scaleBase.padEnd(NODE, '.').slice(0, NODE);
-/** The model is asked for 512 bytes; a small overshoot costs less view space than a retry costs money. */
-export const ACCEPTED = NODE * 1.25;
+/** A level the model can't take would be sent as no level, which Sonnet 5.5 runs at high effort; Pi's own sessions clamp the same way. */
+export const reasoningFor = (model: Model<Api>, level: ThinkingLevel) => {
+  const thinking = clampThinkingLevel(model, level);
+  return thinking === 'off' ? undefined : thinking;
+};
+/** The size example: a line of exactly NODE bytes about OptChat itself. Every claim in it is true and timeless (no ids, PRs or decisions),
+ * so a summary that copies it states nothing false; the request also fences it off from the input. */
+export const SCALE = 'note: How OptChat memory works. Each message becomes a leaf line: a short message is its own line, a longer one is compressed to about 512 bytes. Adjacent lines merge in pairs into a binary tree: two lines into one line covering both, two of those into one covering four, and so on. The view shows recent messages one per line and older ones more per line, within a fixed byte budget. zoom(id, n) opens line id+n into the two lines it was made from, down to the original message; date(id) tells when it was sent.';
 const WARM_MS = 4 * 60_000; // Anthropic's short cache lives 5 minutes from its last use.
 
 /** Parallel calls can't read a cache entry that isn't written yet, so one call primes a cold prefix and the rest wait until it answers. */
@@ -38,24 +43,29 @@ function primeFirst() {
     };
   };
 }
+/** The model is asked for 512 bytes; `accepted` is the longest line kept without a retry (the profile's summary size tolerance). */
 export function createCompressor(registry: ModelRegistry, choice: () => ModelChoice,
-  onUsage: (message: AssistantMessage) => void = () => {}): Compressor {
+  onUsage: (message: AssistantMessage) => void = () => {}, accepted = () => DEFAULT_SETTINGS.summaryAcceptBytes): Compressor {
   const gate = primeFirst();
   return async (input, signal) => {
     const selected = choice();
     const model = registry.find(selected.provider, selected.model);
     if (!model) throw new Error(`Compactor model unavailable: ${selected.provider}/${selected.model}. Use /optchat model.`);
-    const step = `${input.historical ? IMPORT_GUIDANCE + '\n\n' : ''}For scale, this line is exactly 512 bytes:\n${SCALE}\n\n${input.merge ? 'Merge these two lines into one' : 'Compress this message into one line'}, in at most 512 bytes:\n${input.source}`;
+    const thinking = reasoningFor(model, selected.thinking);
+    // Shown bare between the view and the input, the example was sometimes summarized as if it were chat, so it is labelled and both are tagged.
+    const step = `${input.historical ? IMPORT_GUIDANCE + '\n\n' : ''}For scale only, here is an example line, not from this chat; it is exactly 512 bytes and is never part of your input or your line:\n<example>${SCALE}</example>\n\n${input.merge ? 'Merge these two lines into one' : 'Compress this message into one line'}, in at most 512 bytes:\n<input>\n${input.source}\n</input>`;
     const messages: Message[] = [{ role: 'user', content: [{ type: 'text', text: input.context }, { type: 'text', text: step }], timestamp: Date.now() }];
     const view = splitView(input.context);
-    const prefix = model.api === 'anthropic-messages' && view.length > 1 ? `${model.provider}/${model.id}/${selected.thinking}\n${view.slice(0, -1).join('')}` : undefined;
+    const prefix = model.api === 'anthropic-messages' && view.length > 1 ? `${model.provider}/${model.id}/${thinking ?? 'off'}\n${view.slice(0, -1).join('')}` : undefined;
     const tries: string[] = [];
     for (let attempt = 0; attempt < 5; attempt++) {
       const warmed = prefix ? await gate(prefix, signal) : () => {};
       let reply: AssistantMessage;
       try {
         const stream = registry.streamSimple(model, { systemPrompt: COMPACT, messages }, {
-          reasoning: selected.thinking === 'off' ? undefined : selected.thinking, signal, cacheRetention: 'short',
+          // A shared session id is the OpenAI prompt-cache key; SSE because over a websocket Codex would chain unrelated parallel calls on one cached connection.
+          sessionId: 'optchat-compactor', transport: 'sse',
+          reasoning: thinking, signal, cacheRetention: 'short',
           onPayload: payload => model.api === 'anthropic-messages' ? cachePayload(payload) : payload,
         });
         // The cache entry is usable once the model starts answering.
@@ -67,7 +77,8 @@ export function createCompressor(registry: ModelRegistry, choice: () => ModelCho
       const line = reply.content.filter(c => c.type === 'text').map(c => c.text).join('').trim();
       if (!line) throw new Error('Compactor returned no text.');
       tries.push(line);
-      if (bytes(line) <= ACCEPTED) break;
+      // A merge of two short lines can come back nearly as big as both, so a line must also shrink what it replaces.
+      if (bytes(line) <= accepted() && bytes(line) < bytes(input.source)) break;
       messages.push(reply);
       const cut = Buffer.from(line).subarray(0, NODE).toString('utf8').replace(/\uFFFD$/, '');
       messages.push({ role: 'user', content: `That line is ${bytes(line)} bytes; the limit is 512. It must end where it is cut here:\n${cut}| ← LIMIT`, timestamp: Date.now() });

package/src/handoff.ts

@@ -1,7 +1,7 @@
 import type { ModelRegistry } from '@earendil-works/pi-coding-agent';
 import type { AgentMessage } from '@earendil-works/pi-agent-core';
 import type { AssistantMessage } from '@earendil-works/pi-ai';
-import type { ModelChoice } from './compactor.ts';
+import { reasoningFor, type ModelChoice } from './compactor.ts';
 import type { RunInfo } from './runs.ts';
 import { textContent } from './transcript.ts';
 
@@ -53,7 +53,7 @@ export function createHandoffSummarizer(registry: ModelRegistry, choice: () => M
       const reply = await registry.streamSimple(model, {
         systemPrompt: SYSTEM,
         messages: [{ role: 'user', timestamp: Date.now(), content: prefix + transcript.subarray(offset, end).toString('utf8') }],
-      }, { reasoning: selected.thinking === 'off' ? undefined : selected.thinking, maxTokens, signal: AbortSignal.timeout(300_000) }).result();
+      }, { reasoning: reasoningFor(model, selected.thinking), maxTokens, signal: AbortSignal.timeout(300_000) }).result();
       usage(reply);
       if (reply.stopReason === 'error' || reply.stopReason === 'aborted') throw new Error(reply.errorMessage ?? reply.stopReason);
       if (reply.stopReason === 'length') throw new Error('Handoff hit the model output limit before finishing');

package/src/import/job.ts

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

package/src/import/multi-select.ts

@@ -44,8 +44,8 @@ export class MultiSelect implements Component, Focusable {
     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')) {
+      this.error = 'Select at least one item with Tab.';
+    } else if (matchesKey(data, 'tab') || (matchesKey(data, 'space') && !this.filter.getValue())) {
       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));
@@ -82,7 +82,7 @@ export class MultiSelect implements Component, Focusable {
     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', 'Tab toggle · Space toggle (empty filter) · Enter continue · Esc cancel'));
     lines.push(color('dim', 'Ctrl+A select matches · Ctrl+D clear matches'));
     return lines.map(line => truncateToWidth(line, width));
   }

package/src/import/sources.ts

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

package/src/import/ui.ts

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