@deepseek-harness-tui/dsh-tui 0.11.1 → 0.11.2

package/lib/types/dsh-adapter/migrate/adapters/codex.parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codex.parse.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/codex.parse.ts"],"names":[],"mappings":"AA4BA,OAAO,KAAK,EAA4C,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE7F,+DAA+D;AAC/D,MAAM,WAAW,iBAAiB;IAChC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,kEAAkE;IAClE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;CAC1B;AA4ED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,iBAAiB,GAAG,gBAAgB,GAAG,SAAS,CAkKxF"}

package/lib/types/dsh-adapter/migrate/adapters/codex.parse.js

@@ -0,0 +1,289 @@
+/**
+ * Codex rollout parsing (pure): one `rollout-*.jsonl` → one
+ * {@link MigrationSession}.
+ *
+ * Rows are `{ timestamp, type, payload }` envelopes. `session_meta` and
+ * `turn_context` carry metadata (cwd, the model in effect); `response_item`
+ * rows are the model-visible history (OpenAI Responses items); `event_msg`
+ * rows are UI housekeeping that repeats response items and is skipped.
+ *
+ * Codex writes its harness context as user-role blocks: `<environment_context>`,
+ * `<user_instructions>` and other `<…>` blocks, and the
+ * `# AGENTS.md instructions` block that opens most rollouts. Those blocks are
+ * dropped; a user message made only of them opens no turn and never titles
+ * the session.
+ *
+ * Tool traffic: `function_call` / `custom_tool_call` items are tool calls of
+ * the step in progress; their `*_output` items pair back by `call_id`. A
+ * step is one model call: an output ends it, and the next model-produced
+ * item opens the next one. `agent_message` items (a sub-agent's report to
+ * this thread) are inputs of the next model call.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/codex.parse
+ */
+import { isRecord, parseJsonl } from '../parse/jsonl.js';
+import { isInjectedText, unwrapUserText } from '../parse/injection.js';
+import { emptyStats } from '../parse/role-turns.js';
+import { normalizeTitle } from '../parse/title.js';
+import { CallIndex, IMAGE_PLACEHOLDER, closeToolPairs, newStep } from '../parse/tools.js';
+function toMillis(iso) {
+    return typeof iso === 'string' ? Date.parse(iso) || 0 : 0;
+}
+/** Text of the blocks of one kind (`input_text` / `output_text`). */
+function blocksText(content, want) {
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (isRecord(block) && block.type === want && typeof block.text === 'string' && block.text !== '')
+            parts.push(block.text);
+    }
+    return parts.join('\n\n');
+}
+/**
+ * Codex-only frames around or beside the human's words: the text blocks that
+ * wrap an attached image, the aborted-turn marker, and shell-command echoes.
+ * Matched as prefixes like the shared table — a user text that merely starts
+ * with `<` (an HTML or XML question) is the human's and must stay.
+ */
+const CODEX_FRAME_PREFIXES = ['<image name=', '</image>', '<turn_aborted>', '<user_shell_command>'];
+function isCodexFrame(text) {
+    const head = text.trimStart();
+    return CODEX_FRAME_PREFIXES.some(prefix => head.startsWith(prefix));
+}
+/** The human part of a user message: harness blocks dropped, images kept as
+ *  placeholders. Returns the text and how many blocks were dropped. */
+function userPrompt(content) {
+    if (!Array.isArray(content))
+        return { text: '', dropped: 0 };
+    const parts = [];
+    let dropped = 0;
+    for (const block of content) {
+        if (!isRecord(block))
+            continue;
+        if (block.type === 'input_image') {
+            parts.push(IMAGE_PLACEHOLDER);
+        }
+        else if (block.type === 'input_text' && typeof block.text === 'string' && block.text.trim() !== '') {
+            if (isCodexFrame(block.text) || isInjectedText(block.text))
+                dropped += 1;
+            else
+                parts.push(block.text);
+        }
+    }
+    return { text: parts.join('\n\n').trim(), dropped };
+}
+/**
+ * Model-facing text of a tool output. Codex writes three shapes: a plain
+ * string, a JSON string `{"output": "...", "metadata": …}` (the inner output
+ * is what the model saw), and an array of `input_text` / `input_image`
+ * blocks (the most common shape in current rollouts).
+ */
+function toolOutputText(output) {
+    if (Array.isArray(output)) {
+        const parts = [];
+        for (const block of output) {
+            if (!isRecord(block))
+                continue;
+            if (block.type === 'input_text' && typeof block.text === 'string')
+                parts.push(block.text);
+            else if (block.type === 'input_image')
+                parts.push(IMAGE_PLACEHOLDER);
+        }
+        return parts.join('\n');
+    }
+    if (isRecord(output))
+        return typeof output.output === 'string' ? output.output : JSON.stringify(output);
+    if (typeof output !== 'string')
+        return '';
+    if (output.startsWith('{')) {
+        try {
+            const parsed = JSON.parse(output);
+            if (isRecord(parsed) && typeof parsed.output === 'string')
+                return parsed.output;
+        }
+        catch {
+            // Plain text that happens to start with a brace.
+        }
+    }
+    return output;
+}
+/**
+ * Parse one Codex rollout.
+ * @returns The session, or undefined when it records no cwd or no prompt, or
+ *   is a sub-agent thread (`thread_source: 'subagent'` / `source.subagent`):
+ *   those are spawned by a main session and are not conversations of their
+ *   own. Forks (`forked_from_id` without the sub-agent marker) are kept.
+ */
+export function parseCodexRollout(input) {
+    const { records, badLines } = parseJsonl(input.raw);
+    const stats = { ...emptyStats(), badLines };
+    let turns = [];
+    let current;
+    let cwd;
+    let startedAt = 0;
+    let model;
+    const calls = new CallIndex();
+    /** The model call in progress; a tool output ends it (see modelStep). */
+    let step;
+    let sawOutput = false;
+    let unnamedCalls = 0;
+    let sawMeta = false;
+    /** Messages from sub-agents waiting for the next model call. */
+    let pendingInputs = [];
+    let subagent = false;
+    /** A compaction summary waiting for the turn that follows the boundary. */
+    let pendingCompaction;
+    const openTurn = (prompt) => {
+        // Sub-agent messages no model call consumed before a new prompt are stale.
+        if (prompt !== '') {
+            stats.filtered += pendingInputs.length;
+            pendingInputs = [];
+        }
+        current = pendingCompaction === undefined ? { prompt, steps: [] } : { prompt, compaction: pendingCompaction, steps: [] };
+        pendingCompaction = undefined;
+        turns.push(current);
+        step = undefined;
+    };
+    /**
+     * The step a model-produced item belongs to. One model call returns its
+     * reasoning, message and tool calls together, then the harness appends the
+     * tool outputs; so the first model item AFTER an output starts the next
+     * call.
+     */
+    const modelStep = () => {
+        if (current === undefined)
+            openTurn('');
+        if (step === undefined || sawOutput) {
+            step = newStep(model);
+            step.inputs = pendingInputs;
+            pendingInputs = [];
+            current.steps.push(step);
+            sawOutput = false;
+        }
+        return step;
+    };
+    const acceptItem = (payload) => {
+        switch (payload.type) {
+            case 'message': {
+                if (payload.role === 'user') {
+                    const { text: prompt, dropped } = userPrompt(payload.content);
+                    stats.filtered += dropped;
+                    if (prompt === '')
+                        return;
+                    openTurn(prompt);
+                }
+                else if (payload.role === 'assistant') {
+                    const text = blocksText(payload.content, 'output_text');
+                    if (text !== '')
+                        modelStep().blocks.push({ type: 'text', text });
+                }
+                return;
+            }
+            case 'agent_message': {
+                // A sub-agent's report delivered to this thread: model-visible input
+                // of the next model call, not a turn of its own.
+                const text = blocksText(payload.content, 'input_text');
+                if (text === '')
+                    return;
+                pendingInputs.push(text);
+                stats.meta += 1;
+                sawOutput = true;
+                return;
+            }
+            case 'reasoning': {
+                // The readable part is the summary; `encrypted_content` is opaque
+                // provider state and is never copied.
+                const text = Array.isArray(payload.summary)
+                    ? payload.summary.filter(isRecord).map(part => part.text).filter((part) => typeof part === 'string' && part.trim() !== '').join('\n\n')
+                    : '';
+                if (text !== '')
+                    modelStep().blocks.push({ type: 'reasoning', text });
+                return;
+            }
+            case 'function_call':
+            case 'custom_tool_call': {
+                const id = typeof payload.call_id === 'string' && payload.call_id !== '' ? payload.call_id : `codex-call-${++unnamedCalls}`;
+                const name = typeof payload.name === 'string' && payload.name !== '' ? payload.name : 'unknown';
+                // function_call arguments are the model's JSON text; a custom tool's
+                // input is free-form (a patch, a JS snippet), kept as one JSON field.
+                const args = payload.type === 'function_call'
+                    ? (typeof payload.arguments === 'string' ? payload.arguments : JSON.stringify(payload.arguments ?? {}))
+                    : JSON.stringify({ input: payload.input ?? '' });
+                const target = modelStep();
+                target.blocks.push({ type: 'tool-call', id, name, arguments: args });
+                calls.register(target);
+                return;
+            }
+            case 'function_call_output':
+            case 'custom_tool_call_output': {
+                if (typeof payload.call_id === 'string')
+                    calls.attach(payload.call_id, toolOutputText(payload.output), false);
+                else
+                    calls.orphans += 1;
+                sawOutput = true;
+            }
+        }
+    };
+    for (const record of records) {
+        const payload = record.payload;
+        if (!isRecord(payload))
+            continue;
+        const time = toMillis(record.timestamp);
+        if (record.type === 'session_meta') {
+            // Only the FIRST meta describes this rollout: a forked or spawned
+            // thread repeats its parent's meta after its own, with the inherited
+            // history.
+            if (!sawMeta) {
+                sawMeta = true;
+                if (typeof payload.cwd === 'string' && payload.cwd !== '')
+                    cwd = payload.cwd;
+                startedAt ||= toMillis(payload.timestamp) || time;
+                subagent = payload.thread_source === 'subagent' || (isRecord(payload.source) && payload.source.subagent !== undefined);
+            }
+            continue;
+        }
+        // Codex records the active model per turn; it applies to the steps after it.
+        // Compaction boundary: Codex folded the window before it into a handoff
+        // summary and kept writing the same rollout. The summary becomes a
+        // native checkpoint in front of the next turn; a turn cut in half by the
+        // boundary continues as a prompt-less turn after it.
+        if (record.type === 'compacted') {
+            const summary = typeof payload.message === 'string' ? payload.message.trim() : '';
+            if (summary !== '') {
+                pendingCompaction = model === undefined ? { summary } : { summary, model };
+                current = undefined;
+                step = undefined;
+            }
+            continue;
+        }
+        // The only event_msg that carries meaning the response items lack: the
+        // turn was interrupted (the recorded reason is always a coarse
+        // 'interrupted').
+        if (record.type === 'event_msg' && payload.type === 'turn_aborted') {
+            if (current !== undefined)
+                current.aborted = true;
+            continue;
+        }
+        if (record.type === 'turn_context') {
+            if (typeof payload.model === 'string' && payload.model !== '')
+                model = payload.model;
+            continue;
+        }
+        if (record.type !== 'response_item')
+            continue;
+        startedAt ||= time;
+        acceptItem(payload);
+    }
+    stats.filtered += pendingInputs.length;
+    if (pendingCompaction !== undefined)
+        turns.push({ prompt: '', compaction: pendingCompaction, steps: [] });
+    turns = turns.filter(turn => turn.prompt !== '' || turn.steps.length > 0 || turn.compaction !== undefined);
+    stats.droppedToolResults = calls.orphans + closeToolPairs(turns);
+    if (subagent || cwd === undefined || !turns.some(turn => turn.prompt !== ''))
+        return undefined;
+    // Codex keeps no title of its own: the first real prompt is the fallback.
+    const firstPrompt = turns.find(turn => turn.prompt !== '')?.prompt;
+    const title = normalizeTitle(firstPrompt === undefined ? undefined : unwrapUserText(firstPrompt));
+    return { sourceId: input.sourceId, cwd, ...(title === '' ? {} : { title }), titleExplicit: false, startedAt, turns, stats };
+}

package/lib/types/dsh-adapter/migrate/adapters/grok-build.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationAdapter } from '../types.js';
+export declare const grokBuildAdapter: MigrationAdapter;
+//# sourceMappingURL=grok-build.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/grok-build.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok-build.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/grok-build.ts"],"names":[],"mappings":"AAaA,OAAO,KAAK,EAAgD,gBAAgB,EAA+D,MAAM,aAAa,CAAA;AA+C9J,eAAO,MAAM,gBAAgB,EAAE,gBAkD9B,CAAA"}

package/lib/types/dsh-adapter/migrate/adapters/grok-build.js

@@ -0,0 +1,117 @@
+/**
+ * grok-build adapter: `~/.grok/sessions/<encoded-cwd>/<uuid>/` — each session
+ * directory holds a `summary.json` and a `chat_history.jsonl`. Discovery and
+ * the `GROK_HOME` override live here; both files are parsed by the pure
+ * grok-build.parse.ts. A session directory is one browse entry: its
+ * fingerprint combines both files, and its summary comes from the whole
+ * summary.json plus the head of the history.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/grok-build
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { parseGrokSession } from './grok-build.parse.js';
+import { countEntries } from './scan.js';
+import { fingerprintOf, loadText, runScan, walkFiles, withHead } from './scan-fs.js';
+const HISTORY_FILE = 'chat_history.jsonl';
+const SUMMARY_FILE = 'summary.json';
+const WALK = { maxDepth: 2, match: name => name === HISTORY_FILE };
+/** One change token for both files of a session directory. */
+async function directoryFingerprint(dir) {
+    const history = await fingerprintOf(join(dir, HISTORY_FILE));
+    const summary = await fingerprintOf(join(dir, SUMMARY_FILE));
+    if (history === undefined || summary === undefined)
+        return undefined;
+    return { mtimeMs: Math.max(history.mtimeMs, summary.mtimeMs), size: history.size + summary.size };
+}
+async function summarize({ ref, fp }) {
+    const summaryJson = await loadText(join(ref, SUMMARY_FILE));
+    const history = await fingerprintOf(join(ref, HISTORY_FILE));
+    if (typeof summaryJson !== 'string' || history === undefined)
+        return null;
+    const session = await withHead(join(ref, HISTORY_FILE), history.size, chatHistory => parseGrokSession({ summaryJson, chatHistory }));
+    if (session === undefined)
+        return null;
+    return {
+        agentId: 'grok-build',
+        sessionKey: session.sourceId,
+        ref,
+        title: session.title ?? '',
+        cwd: session.cwd,
+        lastMessageAt: fp.mtimeMs,
+        createdAt: session.startedAt || fp.mtimeMs,
+    };
+}
+function readOne(dir) {
+    let summaryJson;
+    let chatHistory;
+    try {
+        summaryJson = readFileSync(join(dir, 'summary.json'), 'utf8');
+        chatHistory = readFileSync(join(dir, 'chat_history.jsonl'), 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    return parseGrokSession({ summaryJson, chatHistory });
+}
+export const grokBuildAdapter = {
+    id: 'grok-build',
+    label: 'Grok Build',
+    roots() {
+        const grokHome = process.env.GROK_HOME?.trim();
+        return [join(grokHome !== undefined && grokHome !== '' ? grokHome : join(homedir(), '.grok'), 'sessions')];
+    },
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth) => {
+            if (depth > 2)
+                return;
+            let entries;
+            try {
+                entries = readdirSync(dir, { withFileTypes: true });
+            }
+            catch {
+                return;
+            }
+            for (const entry of entries) {
+                const path = join(dir, entry.name);
+                if (entry.isDirectory())
+                    walk(path, depth + 1);
+                else if (entry.isFile() && entry.name === 'chat_history.jsonl') {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(dir);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0);
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: WALK.maxDepth, fileMatch: WALK.match });
+    },
+    walk: WALK,
+    async scan(options) {
+        const files = walkFiles(this.roots(), { ...WALK, signal: options?.signal });
+        return runScan(files, file => file.dir, directoryFingerprint, options, summarize);
+    },
+    async load(ref) {
+        const summaryJson = await loadText(join(ref, SUMMARY_FILE));
+        if (typeof summaryJson !== 'string')
+            return summaryJson;
+        const chatHistory = await loadText(join(ref, HISTORY_FILE));
+        if (typeof chatHistory !== 'string')
+            return chatHistory;
+        return parseGrokSession({ summaryJson, chatHistory }) ?? { skip: 'not-a-session' };
+    },
+};

package/lib/types/dsh-adapter/migrate/adapters/grok-build.parse.d.ts

@@ -0,0 +1,13 @@
+import type { MigrationSession } from '../types.js';
+/** One session directory's two files, as text. */
+export interface GrokSessionInput {
+    readonly summaryJson: string;
+    readonly chatHistory: string;
+}
+/**
+ * Parse one Grok Build session.
+ * @returns The session, or undefined when the summary lacks an id or cwd,
+ *   or the history holds no prompt.
+ */
+export declare function parseGrokSession(input: GrokSessionInput): MigrationSession | undefined;
+//# sourceMappingURL=grok-build.parse.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/grok-build.parse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"grok-build.parse.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/grok-build.parse.ts"],"names":[],"mappings":"AAuBA,OAAO,KAAK,EAAgC,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAMjF,kDAAkD;AAClD,MAAM,WAAW,gBAAgB;IAC/B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;IAC5B,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AA2BD;;;;GAIG;AACH,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,gBAAgB,GAAG,gBAAgB,GAAG,SAAS,CAwGtF"}

package/lib/types/dsh-adapter/migrate/adapters/grok-build.parse.js

@@ -0,0 +1,178 @@
+/**
+ * Grok Build session parsing (pure): one session directory's `summary.json`
+ * + `chat_history.jsonl` → one {@link MigrationSession}.
+ *
+ * `summary.json` carries the metadata (`info.id`, `info.cwd`, titles, clock).
+ * `chat_history.jsonl` rows are tagged conversation items: `user` rows carry
+ * block-array content, `assistant` rows a plain string, and a `reasoning`
+ * row precedes the assistant row it explains. Rows carry no per-row
+ * timestamp. The legacy v0 shape (`{role, content}`) is accepted alongside.
+ *
+ * Tool traffic: an assistant row lists its calls in a top-level `tool_calls`
+ * array (`{ id, name, arguments }`); each result is a `tool_result` row
+ * naming `tool_call_id`, with optional `images` (replaced by placeholders).
+ * `backend_tool_call` rows are provider-side tools (web search) the model
+ * never called through the harness; they are counted, not imported.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/grok-build.parse
+ */
+import { isInjectedText, unwrapUserText } from '../parse/injection.js';
+import { isRecord, parseJsonl } from '../parse/jsonl.js';
+import { emptyStats } from '../parse/role-turns.js';
+import { normalizeTitle } from '../parse/title.js';
+import { CallIndex, IMAGE_PLACEHOLDER, closeToolPairs, newStep } from '../parse/tools.js';
+/** How a compaction summary row opens (the other compaction_meta rows are
+ *  the re-injected environment block). */
+const COMPACTION_SUMMARY_LEAD = 'This session is being continued';
+function toMillis(iso) {
+    return typeof iso === 'string' ? Date.parse(iso) || 0 : 0;
+}
+/** Text of string content, or of the text blocks of block-array content. */
+function blocksText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const part of content) {
+        if (isRecord(part) && part.type === 'text' && typeof part.text === 'string' && part.text !== '')
+            parts.push(part.text);
+    }
+    return parts.join('\n\n');
+}
+/** The readable summary of a reasoning row (its encrypted state is never copied). */
+function reasoningText(row) {
+    if (!Array.isArray(row.summary))
+        return '';
+    const parts = [];
+    for (const part of row.summary) {
+        if (isRecord(part) && typeof part.text === 'string' && part.text !== '')
+            parts.push(part.text);
+    }
+    return parts.join('\n\n');
+}
+/**
+ * Parse one Grok Build session.
+ * @returns The session, or undefined when the summary lacks an id or cwd,
+ *   or the history holds no prompt.
+ */
+export function parseGrokSession(input) {
+    let summaryDoc;
+    try {
+        summaryDoc = JSON.parse(input.summaryJson);
+    }
+    catch {
+        return undefined;
+    }
+    if (!isRecord(summaryDoc) || !isRecord(summaryDoc.info))
+        return undefined;
+    const { id, cwd } = summaryDoc.info;
+    if (typeof id !== 'string' || id === '' || typeof cwd !== 'string' || cwd === '')
+        return undefined;
+    const startedAt = toMillis(summaryDoc.created_at) || toMillis(summaryDoc.updated_at);
+    // Title authority: generated_title > session_summary (both the source's
+    // own, written to the log) > the first real prompt (fallback, not written).
+    const ownTitle = normalizeTitle([summaryDoc.generated_title, summaryDoc.session_summary]
+        .find((candidate) => typeof candidate === 'string' && candidate.trim() !== ''));
+    const { records, badLines } = parseJsonl(input.chatHistory);
+    const stats = { ...emptyStats(), badLines };
+    let turns = [];
+    let current;
+    let pendingReasoning = [];
+    /** A compaction summary waiting for the turn that follows the boundary. */
+    let pendingCompaction;
+    let lastModel;
+    const openTurn = (prompt) => {
+        const turn = pendingCompaction === undefined ? { prompt, steps: [] } : { prompt, compaction: pendingCompaction, steps: [] };
+        pendingCompaction = undefined;
+        turns.push(turn);
+        return turn;
+    };
+    const calls = new CallIndex();
+    for (const row of records) {
+        const kind = row.type === undefined ? row.role : row.type;
+        if (kind === 'user') {
+            // Tagged synthetic injections (system reminders, compaction meta, …)
+            // are not the human's words; the default `human` tag is omitted.
+            if (row.synthetic_reason !== undefined && row.synthetic_reason !== 'human') {
+                // A compaction leaves its summary as a synthetic row: the boundary
+                // becomes a native checkpoint in front of the next turn.
+                const text = blocksText(row.content).trim();
+                if (row.synthetic_reason === 'compaction_meta' && text.startsWith(COMPACTION_SUMMARY_LEAD)) {
+                    pendingCompaction = lastModel === undefined ? { summary: text } : { summary: text, model: lastModel };
+                    current = undefined;
+                }
+                else {
+                    stats.filtered += 1;
+                }
+                continue;
+            }
+            const raw = blocksText(row.content);
+            // Untagged injection: the environment block (`<user_info>`) that opens
+            // every session and follows every compaction.
+            if (isInjectedText(raw)) {
+                stats.filtered += 1;
+                continue;
+            }
+            // The human words sit inside `<user_query>`, possibly behind an
+            // interrupt or "sent while you were working" notice.
+            const prompt = unwrapUserText(raw);
+            if (prompt === '')
+                continue;
+            // Speaking over a running turn cut that turn short.
+            if (row.prior_turn_interrupt !== undefined && current !== undefined)
+                current.aborted = true;
+            current = openTurn(prompt);
+        }
+        else if (kind === 'assistant') {
+            const text = blocksText(row.content);
+            const toolCalls = Array.isArray(row.tool_calls) ? row.tool_calls.filter(isRecord) : [];
+            if (text === '' && pendingReasoning.length === 0 && toolCalls.length === 0)
+                continue;
+            current ??= openTurn('');
+            if (typeof row.model_id === 'string' && row.model_id !== '')
+                lastModel = row.model_id;
+            const step = newStep(typeof row.model_id === 'string' && row.model_id !== '' ? row.model_id : undefined);
+            // A reasoning row is the pre-sibling of the assistant row it explains.
+            for (const reasoning of pendingReasoning)
+                step.blocks.push({ type: 'reasoning', text: reasoning });
+            pendingReasoning = [];
+            if (text !== '')
+                step.blocks.push({ type: 'text', text });
+            for (const call of toolCalls) {
+                if (typeof call.id !== 'string' || call.id === '')
+                    continue;
+                const name = typeof call.name === 'string' && call.name !== '' ? call.name : 'unknown';
+                const args = typeof call.arguments === 'string' ? call.arguments : JSON.stringify(call.arguments ?? {});
+                step.blocks.push({ type: 'tool-call', id: call.id, name, arguments: args });
+            }
+            calls.register(step);
+            current.steps.push(step);
+        }
+        else if (kind === 'tool_result') {
+            if (typeof row.tool_call_id !== 'string') {
+                calls.orphans += 1;
+                continue;
+            }
+            const images = Array.isArray(row.images) ? row.images.length : 0;
+            const text = [blocksText(row.content), ...Array.from({ length: images }, () => IMAGE_PLACEHOLDER)].filter(part => part !== '').join('\n');
+            calls.attach(row.tool_call_id, text, row.is_error === true);
+        }
+        else if (kind === 'backend_tool_call') {
+            stats.filtered += 1;
+        }
+        else if (kind === 'reasoning') {
+            const text = reasoningText(row);
+            if (text !== '')
+                pendingReasoning.push(text);
+        }
+    }
+    if (pendingCompaction !== undefined)
+        turns.push({ prompt: '', compaction: pendingCompaction, steps: [] });
+    turns = turns.filter(turn => turn.prompt !== '' || turn.steps.length > 0 || turn.compaction !== undefined);
+    stats.droppedToolResults = calls.orphans + closeToolPairs(turns);
+    if (!turns.some(turn => turn.prompt !== ''))
+        return undefined;
+    const title = ownTitle !== '' ? ownTitle : normalizeTitle(turns.find(turn => turn.prompt !== '')?.prompt);
+    return { sourceId: id, cwd, ...(title === '' ? {} : { title }), titleExplicit: ownTitle !== '', startedAt, turns, stats };
+}

package/lib/types/dsh-adapter/migrate/adapters/omp.d.ts

@@ -0,0 +1,3 @@
+import type { MigrationAdapter } from '../types.js';
+export declare const ompAdapter: MigrationAdapter;
+//# sourceMappingURL=omp.d.ts.map

package/lib/types/dsh-adapter/migrate/adapters/omp.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"omp.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/omp.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,gBAAgB,EAAuD,MAAM,aAAa,CAAA;AAyExG,eAAO,MAAM,UAAU,EAAE,gBAmCxB,CAAA"}