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

package/lib/types/dsh-adapter/jobs.js

@@ -8,17 +8,11 @@ const STATUS_SUFFIX_PATTERN = /^\s*\[status:\s/;
 function isTerminal(status) {
     return status === 'completed' || status === 'killed' || status === 'failed';
 }
-/**
- * Ordered store of the current conversation's background jobs. Fed by
- * {@link BackgroundJobStore.replace} with a fresh `list()` after every
- * `onJobsChanged` commit, and by {@link BackgroundJobStore.onOutputSeen}
- * with the tail of every `job_output` tool result. Emits no React state of
- * its own — the channel wires the events into its version bump, exactly
- * like the subagent projection.
- */
 export class BackgroundJobStore {
     events;
     jobs = new Map();
+    /** Kernel-ring read state per job id (own cursor — never the model's). */
+    kernelReads = new Map();
     /** Commands captured from start acks that arrived before the registry
      *  registered the job (the tool/result stream and the registry commit can
      *  race); consumed on registration. */
@@ -52,16 +46,24 @@ export class BackgroundJobStore {
                     ...(command === undefined ? {} : { command }),
                     status: snap.status,
                     ...(snap.detail === undefined ? {} : { detail: snap.detail }),
+                    ...(snap.progress === undefined ? {} : { progress: snap.progress }),
                     startedAt: snap.startedAt,
                     ...(snap.finishedAt === undefined ? {} : { finishedAt: snap.finishedAt }),
                     outputLines: [],
+                    ...(snap.output === undefined ? {} : {
+                        outputTotalBytes: snap.output.total,
+                        ...(snap.output.spillPaths === undefined || snap.output.spillPaths.length === 0 ? {} : { spillPaths: [...snap.output.spillPaths] }),
+                    }),
                 });
+                if (snap.output !== undefined)
+                    this.seedKernelRead(snap.id, snap.output.earliest);
                 changed = true;
                 continue;
             }
             if (prev.status === snap.status &&
                 prev.detail === snap.detail &&
                 prev.label === snap.label &&
+                prev.progress === snap.progress &&
                 prev.finishedAt === snap.finishedAt)
                 continue;
             const wasLive = !isTerminal(prev.status);
@@ -71,10 +73,20 @@ export class BackgroundJobStore {
                 delete prev.detail;
             else
                 prev.detail = snap.detail;
+            if (snap.progress === undefined)
+                delete prev.progress;
+            else
+                prev.progress = snap.progress;
             if (snap.finishedAt === undefined)
                 delete prev.finishedAt;
             else
                 prev.finishedAt = snap.finishedAt;
+            if (snap.output !== undefined) {
+                prev.outputTotalBytes = snap.output.total;
+                if (snap.output.spillPaths !== undefined && snap.output.spillPaths.length > 0)
+                    prev.spillPaths = [...snap.output.spillPaths];
+                this.seedKernelRead(snap.id, snap.output.earliest);
+            }
             changed = true;
             if (wasLive && isTerminal(snap.status))
                 this.events.onSettled?.(prev);
@@ -132,13 +144,95 @@ export class BackgroundJobStore {
         const lines = text
             .split(/\r?\n/)
             .map(line => line.replace(/\s+$/, ''))
-            .filter(line => line !== '' && !STATUS_SUFFIX_PATTERN.test(line));
+            .filter(line => line !== '' && !STATUS_SUFFIX_PATTERN.test(line))
+            .map(text => ({ text }));
         if (lines.length === 0)
             return;
         job.outputLines = [...job.outputLines, ...lines].slice(-JOBS_MAX_OUTPUT_LINES);
         job.lastOutputAt = at;
         this.events.onChanged?.();
     }
+    /**
+     * Seed the kernel-ring cursor for one job at its retained head. Called from
+     * replace() whenever a snapshot carries ring facts — before any output
+     * pull — so the first readAt starts at `earliest`, never at 0 (bytes
+     * before `earliest` are already evicted).
+     */
+    seedKernelRead(id, earliest) {
+        const read = this.kernelReads.get(id);
+        if (read === undefined)
+            this.kernelReads.set(id, { cursor: earliest, partial: '' });
+        else if (read.cursor < earliest) {
+            // Ring evicted past our cursor: resync and mark the discontinuity.
+            read.cursor = earliest;
+            read.partial = '';
+            const job = this.jobs.get(id);
+            if (job !== undefined)
+                job.outputDropped = true;
+        }
+    }
+    /**
+     * Pull one non-consuming increment from the kernel ring after an `output`
+     * event. Chunks split into lines; a chunk without a trailing newline parks
+     * its tail until the next pull (producers append streaming bytes, so line
+     * boundaries routinely straddle chunks). `gapBefore`/`lossy` mark bytes
+     * lost before the retained tail — surfaced as the dropped banner.
+     */
+    onKernelOutput(id, read, at = Date.now()) {
+        const job = this.jobs.get(id);
+        if (job === undefined)
+            return;
+        const state = this.kernelReads.get(id) ?? { cursor: 0, partial: '' };
+        this.kernelReads.set(id, state);
+        const appended = [];
+        let gapPending = read.lossy === true;
+        let gapSeen = read.lossy === true;
+        for (const chunk of read.chunks) {
+            if (chunk.gapBefore === true) {
+                gapPending = true;
+                gapSeen = true;
+            }
+            let text = state.partial + chunk.text;
+            state.partial = '';
+            // A \r not followed by \n is a same-line rewrite (progress spinners);
+            // keep the tail after the last one so the panel shows the newest form.
+            const lines = text.split(/\r?\n/);
+            if (!text.endsWith('\n')) {
+                state.partial = lines.pop() ?? '';
+            }
+            else {
+                lines.pop();
+            }
+            for (const raw of lines) {
+                const trimmed = raw.replace(/\s+$/, '');
+                if (trimmed === '')
+                    continue;
+                appended.push({ text: trimmed, ...(chunk.channel === undefined ? {} : { channel: chunk.channel }), ...(gapPending ? { gapBefore: true } : {}) });
+                gapPending = false;
+            }
+            if (state.partial !== '') {
+                // Re-split parked tail the same way so an embedded \r refreshes it.
+                const parts = state.partial.split(/\r(?!\n)/);
+                state.partial = parts[parts.length - 1];
+            }
+        }
+        state.cursor = read.next;
+        if (gapSeen)
+            job.outputDropped = true;
+        if (appended.length > 0) {
+            job.outputLines = [...job.outputLines, ...appended].slice(-JOBS_MAX_OUTPUT_LINES);
+            job.lastOutputAt = at;
+            this.events.onChanged?.();
+        }
+        else if (job.outputTotalBytes !== read.next) {
+            this.events.onChanged?.();
+        }
+        job.outputTotalBytes = Math.max(job.outputTotalBytes ?? 0, read.next);
+    }
+    /** Kernel read state accessor for tests and cursor diagnostics. */
+    kernelCursorOf(id) {
+        return this.kernelReads.get(id)?.cursor;
+    }
     /** A fresh snapshot in registration order (newest tracked job last). */
     snapshot() {
         return [...this.jobs.values()];
@@ -160,6 +254,7 @@ export class BackgroundJobStore {
         if (this.jobs.size === 0)
             return;
         this.jobs.clear();
+        this.kernelReads.clear();
         this.events.onChanged?.();
     }
 }

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/claude-code.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAmC,gBAAgB,EAA+D,MAAM,aAAa,CAAA;AA8DjJ,eAAO,MAAM,iBAAiB,EAAE,gBA8C/B,CAAA"}

package/lib/types/dsh-adapter/migrate/adapters/claude-code.js

@@ -0,0 +1,131 @@
+/**
+ * Claude Code adapter: `~/.claude/projects/<munged-cwd>/<session>.jsonl`.
+ * File discovery lives here; the line format is parsed by the pure
+ * claude-code.parse.ts. The browse scan derives each summary from the same
+ * parser run over the file's head, plus a tail window for the /rename title
+ * (renames append, the last one wins).
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/claude-code
+ */
+import { readdirSync, readFileSync, statSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { basename, dirname, join } from 'node:path';
+import { parseJsonl } from '../parse/jsonl.js';
+import { normalizeTitle } from '../parse/title.js';
+import { parseClaudeTranscript } from './claude-code.parse.js';
+import { countEntries } from './scan.js';
+import { fingerprintOf, loadText, readTail, runScan, walkFiles, withHead } from './scan-fs.js';
+/** Sub-agent transcripts (`<session>/subagents/*.jsonl`) belong to their
+ *  parent session; they are never conversations of their own. */
+const SUBAGENT_DIR = 'subagents';
+const WALK = { maxDepth: 3, match: name => name.endsWith('.jsonl'), skipDirs: [SUBAGENT_DIR] };
+/** Tail window searched for the latest /rename title. */
+const TITLE_TAIL_BYTES = 64 * 1024;
+/** File name without `.jsonl`: the session's stable source id. */
+const fileStemOf = (path) => basename(path).replace(/\.jsonl$/u, '');
+/** cwd guessed from the project directory name, for logs whose lines record none. */
+const fallbackCwdOf = (path) => unmunge(basename(dirname(path))) ?? homedir();
+/** The last /rename title in a tail window, when there is one. */
+function tailRenameTitle(tail) {
+    let title;
+    for (const record of parseJsonl(tail).records) {
+        if (record.type === 'custom-title' && typeof record.customTitle === 'string' && record.customTitle.trim() !== '')
+            title = record.customTitle;
+    }
+    return title;
+}
+async function summarize({ ref, fp }) {
+    const input = { fileStem: fileStemOf(ref), fallbackCwd: fallbackCwdOf(ref) };
+    const found = await withHead(ref, fp.size, (raw, whole) => {
+        const session = parseClaudeTranscript({ ...input, raw });
+        return session === undefined ? undefined : { session, whole };
+    });
+    if (found === undefined)
+        return null;
+    const { session, whole } = found;
+    const renamed = whole ? undefined : tailRenameTitle(await readTail(ref, TITLE_TAIL_BYTES, fp.size));
+    return {
+        agentId: 'claude-code',
+        sessionKey: session.sourceId,
+        ref,
+        title: renamed === undefined ? session.title ?? '' : normalizeTitle(renamed),
+        cwd: session.cwd,
+        lastMessageAt: fp.mtimeMs,
+        createdAt: session.startedAt || fp.mtimeMs,
+    };
+}
+function readOne(path, fallbackCwd) {
+    let raw;
+    try {
+        raw = readFileSync(path, 'utf8');
+    }
+    catch {
+        return undefined;
+    }
+    // basename(), not split('/'): join() produces `\` separators on Windows, so
+    // splitting on '/' would leave the WHOLE absolute path as the id — and the
+    // id is the dedupe key (moving the source store would re-import everything).
+    return parseClaudeTranscript({ raw, fileStem: fileStemOf(path), fallbackCwd });
+}
+export const claudeCodeAdapter = {
+    id: 'claude-code',
+    label: 'Claude Code',
+    roots: () => [join(homedir(), '.claude', 'projects')],
+    discover() {
+        const roots = this.roots();
+        const sessions = [];
+        const walk = (dir, depth, fallbackCwd) => {
+            if (depth > 3)
+                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()) {
+                    if (entry.name !== SUBAGENT_DIR)
+                        walk(path, depth + 1, unmunge(entry.name) ?? fallbackCwd);
+                }
+                else if (entry.isFile() && entry.name.endsWith('.jsonl')) {
+                    try {
+                        if (statSync(path).size > 64 * 1024 * 1024)
+                            continue;
+                    }
+                    catch {
+                        continue;
+                    }
+                    const session = readOne(path, fallbackCwd);
+                    if (session !== undefined)
+                        sessions.push(session);
+                }
+            }
+        };
+        for (const root of roots)
+            walk(root, 0, homedir());
+        return { roots, sessions };
+    },
+    count() {
+        return countEntries(this.roots(), { maxDepth: WALK.maxDepth, fileMatch: WALK.match, skipDirs: WALK.skipDirs });
+    },
+    walk: WALK,
+    async scan(options) {
+        const files = walkFiles(this.roots(), { ...WALK, signal: options?.signal });
+        return runScan(files, file => file.path, fingerprintOf, options, summarize);
+    },
+    async load(ref) {
+        const raw = await loadText(ref);
+        if (typeof raw !== 'string')
+            return raw;
+        return parseClaudeTranscript({ raw, fileStem: fileStemOf(ref), fallbackCwd: fallbackCwdOf(ref) }) ?? { skip: 'not-a-session' };
+    },
+};
+/** Best-effort inverse of Claude Code's dash-munged directory names. */
+function unmunge(name) {
+    if (!name.startsWith('-'))
+        return undefined;
+    return `/${name.split('-').filter(Boolean).join('/')}`;
+}

package/lib/types/dsh-adapter/migrate/adapters/claude-code.parse.d.ts

@@ -0,0 +1,17 @@
+import type { MigrationSession } from '../types.js';
+/** What the adapter knows about a transcript besides its text. */
+export interface ClaudeTranscriptInput {
+    readonly raw: string;
+    /** File name without `.jsonl` — the session's stable source id. */
+    readonly fileStem: string;
+    /** cwd derived from the project directory name, used when no line records one. */
+    readonly fallbackCwd: string;
+}
+/**
+ * Parse one Claude Code transcript.
+ * @returns The session, or undefined when it holds no human prompt or is an
+ *   auxiliary transcript (its records name another session: only the main
+ *   `<sessionId>.jsonl` is a conversation of its own).
+ */
+export declare function parseClaudeTranscript(input: ClaudeTranscriptInput): MigrationSession | undefined;
+//# sourceMappingURL=claude-code.parse.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"claude-code.parse.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/claude-code.parse.ts"],"names":[],"mappings":"AAsCA,OAAO,KAAK,EAA4C,gBAAgB,EAAE,MAAM,aAAa,CAAA;AAE7F,kEAAkE;AAClE,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAA;IACpB,mEAAmE;IACnE,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAA;IACzB,kFAAkF;IAClF,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAA;CAC7B;AAwFD;;;;;GAKG;AACH,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,qBAAqB,GAAG,gBAAgB,GAAG,SAAS,CA+KhG"}

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

@@ -0,0 +1,329 @@
+/**
+ * Claude Code transcript parsing (pure): one `<session>.jsonl` → one
+ * {@link MigrationSession}.
+ *
+ * Lines are self-describing (`type`). A human prompt is a `user` line whose
+ * content is a string or text blocks; an assistant line carries ONE content
+ * block of a model response, and one response spans several lines sharing
+ * `message.id` (thinking, text, each tool_use — tool results can land
+ * between them). Those lines are merged back into one step: one step is one
+ * model call.
+ *
+ * Tool results arrive as `user` lines of `tool_result` blocks, usually
+ * after every tool_use of the response has been written; each is paired to
+ * the step that made the call by `tool_use_id` (never to the newest step).
+ *
+ * Machine text in the user role: `isMeta` lines are context the model saw
+ * mid-turn and become the next step's inputs (never a turn); slash-command
+ * echoes become `/name args` prompts, dropped when the model never answered
+ * them (local commands); local-command output and other injection is
+ * dropped. Everything dropped is counted in `stats.filtered`.
+ *
+ * A `user` line flagged `isCompactSummary` is a compaction boundary: its
+ * text becomes the checkpoint in front of the next turn (sessionize writes
+ * the native compaction transaction). The legacy 2.0.x `summary` record is
+ * a one-line leaf title written at the head of a file, not a boundary.
+ *
+ * Title authority: `custom-title` (the user's /rename; the LAST one wins —
+ * renames append) > legacy `summary` > `ai-title` (the FIRST one; later
+ * ones are rewritten per turn and drift) > the first real prompt as a
+ * fallback that is not written to the log.
+ *
+ * @module @deepseek-harness-tui/dsh-tui/migrate/adapters/claude-code.parse
+ */
+import { isRecord, parseJsonl } from '../parse/jsonl.js';
+import { isInjectedText, stripSystemReminders, 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 a string or block-array content; each image becomes a placeholder. */
+function textOf(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (!isRecord(block))
+            continue;
+        if (block.type === 'text' && typeof block.text === 'string' && block.text !== '')
+            parts.push(block.text);
+        else if (block.type === 'image')
+            parts.push(IMAGE_PLACEHOLDER);
+    }
+    return parts.join('\n\n');
+}
+/** Model-facing text of a tool_result's content: a string, or text blocks
+ *  with each image replaced by a placeholder. */
+function toolResultText(content) {
+    if (typeof content === 'string')
+        return content;
+    if (!Array.isArray(content))
+        return '';
+    const parts = [];
+    for (const block of content) {
+        if (!isRecord(block))
+            continue;
+        if (block.type === 'text' && typeof block.text === 'string')
+            parts.push(block.text);
+        else if (block.type === 'image')
+            parts.push(IMAGE_PLACEHOLDER);
+    }
+    return parts.join('\n');
+}
+/** Whether a user text is Claude Code's echo of a slash command. */
+function isCommandEcho(text) {
+    return text.startsWith('<command-name>') || text.startsWith('<command-message>');
+}
+/** Body of the first `<tag>…</tag>` in text, or ''. */
+function tagBody(text, tag) {
+    const open = `<${tag}>`;
+    const start = text.indexOf(open);
+    if (start === -1)
+        return '';
+    const end = text.indexOf(`</${tag}>`, start + open.length);
+    return text.slice(start + open.length, end === -1 ? undefined : end).trim();
+}
+/** A slash-command echo as the user typed it: `/name args`. */
+function commandPrompt(text) {
+    const name = tagBody(text, 'command-name');
+    const args = tagBody(text, 'command-args');
+    return `${name} ${args}`.trim() || text;
+}
+/**
+ * Drop failed-dispatch ghosts: when a response's tool calls got no result,
+ * Claude Code re-sends the SAME calls (same ids, same arguments) in the next
+ * response. Kept, the id would appear twice in the log. A step is a ghost
+ * when it holds only tool calls, none answered, and the very next step
+ * re-sends every one of them verbatim; its inputs move to the retry.
+ * @returns How many steps were dropped.
+ */
+function dropGhostRetries(steps) {
+    let dropped = 0;
+    for (let i = 0; i < steps.length - 1;) {
+        const ghost = steps[i];
+        const retry = steps[i + 1];
+        const isGhost = ghost.blocks.length > 0 && ghost.results.length === 0
+            && ghost.blocks.every(block => block.type === 'tool-call'
+                && retry.blocks.some(again => again.type === 'tool-call' && again.id === block.id
+                    && again.name === block.name && again.arguments === block.arguments));
+        if (!isGhost) {
+            i += 1;
+            continue;
+        }
+        retry.inputs = [...ghost.inputs, ...retry.inputs];
+        steps.splice(i, 1);
+        dropped += 1;
+        // Stay at i: the retry may itself be a ghost of the step after it.
+    }
+    return dropped;
+}
+/** Whether a user line is a tool-result carrier rather than a prompt. */
+function isToolResultLine(content) {
+    return Array.isArray(content) && content.some(block => isRecord(block) && block.type === 'tool_result');
+}
+/**
+ * Parse one Claude Code transcript.
+ * @returns The session, or undefined when it holds no human prompt or is an
+ *   auxiliary transcript (its records name another session: only the main
+ *   `<sessionId>.jsonl` is a conversation of its own).
+ */
+export function parseClaudeTranscript(input) {
+    const { records, badLines } = parseJsonl(input.raw);
+    const owner = records.find(record => typeof record.sessionId === 'string' && record.sessionId !== '')?.sessionId;
+    if (owner !== undefined && owner !== input.fileStem)
+        return undefined;
+    const stats = { ...emptyStats(), badLines };
+    let turns = [];
+    let current;
+    /** message.id → its step, within the current turn. */
+    let stepOfMessage = new Map();
+    let startedAt = 0;
+    let lineCwd;
+    const calls = new CallIndex();
+    /** A compaction summary waiting for the turn that follows the boundary. */
+    let pendingCompaction;
+    let lastModel;
+    let renamedTitle;
+    let legacyTitle;
+    let aiTitle;
+    /** isMeta texts waiting for the next step of the current turn. */
+    let pendingInputs = [];
+    /** Turns opened by a slash-command echo rather than typed words. */
+    const commandTurns = new Set();
+    const openTurn = (prompt) => {
+        current = pendingCompaction === undefined ? { prompt, steps: [] } : { prompt, compaction: pendingCompaction, steps: [] };
+        pendingCompaction = undefined;
+        turns.push(current);
+        stepOfMessage = new Map();
+    };
+    const appendAssistant = (message) => {
+        if (current === undefined)
+            openTurn('');
+        const turn = current;
+        const messageId = typeof message.id === 'string' && message.id !== '' ? message.id : undefined;
+        let step = messageId === undefined ? undefined : stepOfMessage.get(messageId);
+        if (typeof message.model === 'string' && message.model !== '')
+            lastModel = message.model;
+        if (step === undefined) {
+            step = newStep(typeof message.model === 'string' && message.model !== '' ? message.model : undefined);
+            step.inputs = pendingInputs;
+            pendingInputs = [];
+            turn.steps.push(step);
+            if (messageId !== undefined)
+                stepOfMessage.set(messageId, step);
+        }
+        const content = message.content;
+        if (typeof content === 'string') {
+            if (content !== '')
+                step.blocks.push({ type: 'text', text: content });
+            return;
+        }
+        if (!Array.isArray(content))
+            return;
+        for (const block of content) {
+            if (!isRecord(block))
+                continue;
+            if (block.type === 'text' && typeof block.text === 'string' && block.text !== '') {
+                step.blocks.push({ type: 'text', text: block.text });
+            }
+            else if (block.type === 'thinking') {
+                // The trace lives in `thinking` (not `text`); accept both.
+                const text = typeof block.thinking === 'string' ? block.thinking : typeof block.text === 'string' ? block.text : '';
+                if (text !== '')
+                    step.blocks.push({ type: 'reasoning', text });
+            }
+            else if (block.type === 'tool_use' && typeof block.id === 'string' && block.id !== '') {
+                const name = typeof block.name === 'string' && block.name !== '' ? block.name : 'unknown';
+                step.blocks.push({ type: 'tool-call', id: block.id, name, arguments: JSON.stringify(block.input ?? {}) });
+            }
+        }
+        calls.register(step);
+    };
+    const attachResults = (content) => {
+        for (const block of content) {
+            if (!isRecord(block) || block.type !== 'tool_result' || typeof block.tool_use_id !== 'string')
+                continue;
+            calls.attach(block.tool_use_id, toolResultText(block.content), block.is_error === true);
+        }
+    };
+    const acceptUserText = (record, content) => {
+        const raw = textOf(content);
+        const text = stripSystemReminders(raw);
+        if (record.isMeta === true) {
+            // Machine context the model saw mid-turn (skill bodies, image notes,
+            // "Continue from where you left off."): it enters the NEXT step as a
+            // user input instead of opening a turn. Local-command caveats carry
+            // no model reply and are dropped.
+            if (text === '' || isInjectedText(raw)) {
+                stats.filtered += 1;
+                return;
+            }
+            pendingInputs.push(text);
+            stats.meta += 1;
+            return;
+        }
+        if (isCommandEcho(text)) {
+            openTurn(commandPrompt(text));
+            commandTurns.add(current);
+            return;
+        }
+        if (text === '')
+            return;
+        if (isInjectedText(text)) {
+            stats.filtered += 1;
+            return;
+        }
+        // Mid-turn context that no step consumed before the next prompt is
+        // stale; the prompt starts over.
+        stats.filtered += pendingInputs.length;
+        pendingInputs = [];
+        openTurn(text);
+    };
+    for (const record of records) {
+        const type = record.type;
+        if (type === 'custom-title' && typeof record.customTitle === 'string' && record.customTitle.trim() !== '')
+            renamedTitle = record.customTitle;
+        else if (type === 'summary' && typeof record.summary === 'string' && record.summary.trim() !== '')
+            legacyTitle = record.summary;
+        else if (type === 'ai-title' && typeof record.aiTitle === 'string' && record.aiTitle.trim() !== '')
+            aiTitle ??= record.aiTitle;
+        if (type !== 'user' && type !== 'assistant')
+            continue;
+        if (record.isSidechain === true)
+            continue;
+        const message = record.message;
+        if (!isRecord(message))
+            continue;
+        // Claude Code writes the authoritative cwd on every message line; the
+        // dash-munged directory name cannot preserve `_`/`.`/`-`.
+        if (typeof record.cwd === 'string' && record.cwd !== '')
+            lineCwd = record.cwd;
+        if (startedAt === 0)
+            startedAt = toMillis(record.timestamp);
+        if (type === 'user') {
+            if (isToolResultLine(message.content)) {
+                attachResults(message.content);
+            }
+            else if (record.isCompactSummary === true) {
+                // Compaction boundary: the summary becomes a native checkpoint in
+                // front of the next turn; the turn in progress is over.
+                const summary = stripSystemReminders(textOf(message.content));
+                if (summary !== '') {
+                    pendingCompaction = lastModel === undefined ? { summary } : { summary, model: lastModel };
+                    current = undefined;
+                }
+            }
+            else {
+                acceptUserText(record, message.content);
+            }
+            continue;
+        }
+        appendAssistant(message);
+    }
+    stats.filtered += pendingInputs.length;
+    // The transcript stopped right at a boundary: keep the checkpoint.
+    if (pendingCompaction !== undefined)
+        turns.push({ prompt: '', compaction: pendingCompaction, steps: [] });
+    // A response that produced nothing importable leaves no step behind, and
+    // a slash command the model never answered (/model, /clear, …) is local
+    // housekeeping, not conversation.
+    for (const turn of turns)
+        turn.steps = turn.steps.filter(step => step.blocks.length > 0 || step.inputs.length > 0);
+    turns = turns.filter(turn => {
+        if (commandTurns.has(turn) && turn.steps.length === 0 && turn.compaction === undefined) {
+            stats.filtered += 1;
+            return false;
+        }
+        return turn.prompt !== '' || turn.steps.length > 0 || turn.compaction !== undefined;
+    });
+    for (const turn of turns)
+        dropGhostRetries(turn.steps);
+    stats.droppedToolResults = calls.orphans + closeToolPairs(turns);
+    if (!turns.some(turn => turn.prompt !== ''))
+        return undefined;
+    // cwd precedence: the per-line `cwd` field → the first prompt's
+    // "Primary working directory:" note → the unmunged directory name.
+    let cwd = lineCwd ?? input.fallbackCwd;
+    if (lineCwd === undefined) {
+        const noted = turns.find(turn => turn.prompt.includes('Primary working directory:'));
+        const match = noted === undefined ? null : /Primary working directory: (\S+)/u.exec(noted.prompt);
+        if (match !== null)
+            cwd = match[1];
+    }
+    const explicit = normalizeTitle(renamedTitle ?? legacyTitle ?? aiTitle);
+    const firstPrompt = turns.find(turn => turn.prompt !== '' && !commandTurns.has(turn))?.prompt;
+    const title = explicit !== '' ? explicit : normalizeTitle(firstPrompt === undefined ? undefined : unwrapUserText(firstPrompt));
+    return {
+        sourceId: input.fileStem,
+        cwd,
+        ...(title === '' ? {} : { title }),
+        titleExplicit: explicit !== '',
+        startedAt,
+        turns,
+        stats,
+    };
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"codex.d.ts","sourceRoot":"","sources":["../../../../../src/dsh-adapter/migrate/adapters/codex.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAmC,gBAAgB,EAA+D,MAAM,aAAa,CAAA;AAyCjJ,eAAO,MAAM,YAAY,EAAE,gBA6C1B,CAAA"}