trajectories 0.0.0 → 0.1.1

package/dist/writers/fx.js

@@ -0,0 +1,135 @@
+import { destination, droppedRecord, timestampOf, toolNames } from './helpers.js';
+/** FX legacy session.json schema 1 with presentation execution-memory schema 3. */
+export const writeFx = (records, options, entropy) => {
+    const { id, timestamp } = destination(options, entropy);
+    const names = toolNames(records);
+    const diagnostics = [];
+    const portable = records.filter((record) => !droppedRecord(record, diagnostics) && record.role !== 'meta');
+    const history = [];
+    let index = 0;
+    while (index < portable.length) {
+        const user = portable[index++];
+        if (!user || user.role !== 'user')
+            throw new Error('FX completed history must begin each turn with a user record.');
+        const steps = [];
+        let finalAssistant = null;
+        let stepAssistant;
+        while (index < portable.length) {
+            const record = portable[index];
+            if (record.role === 'user')
+                break;
+            if (record.role !== 'assistant')
+                throw new Error('FX completed history contains a tool result outside an assistant tool batch.');
+            index += 1;
+            if (!('tool_calls' in record)) {
+                const next = portable[index];
+                if (next?.role === 'assistant') {
+                    if ('tool_calls' in next) {
+                        if (stepAssistant !== undefined)
+                            throw new Error('FX tool step has multiple assistant prefaces.');
+                        stepAssistant = record.content;
+                    }
+                    else {
+                        // FX execution-memory steps retain intermediate assistant text even
+                        // when no tool call followed that message.
+                        steps.push({ assistant: record.content, tool_calls: [], tool_results: [] });
+                    }
+                    continue;
+                }
+                if (finalAssistant !== null)
+                    throw new Error('FX completed history contains multiple final assistant replies in one turn.');
+                finalAssistant = record.content;
+                break;
+            }
+            const callRecords = [record];
+            while (index < portable.length) {
+                const next = portable[index];
+                if (next.role !== 'assistant' || !('tool_calls' in next))
+                    break;
+                callRecords.push(next);
+                index += 1;
+            }
+            const calls = callRecords.flatMap((item) => item.tool_calls);
+            const callIds = new Set(calls.map((call) => call.id));
+            const results = [];
+            while (index < portable.length && portable[index].role === 'tool') {
+                const result = portable[index++];
+                if (!callIds.delete(result.tool_call_id)) {
+                    throw new Error(`FX tool result ${result.tool_call_id} does not belong to its assistant tool batch.`);
+                }
+                if (result.ok === undefined && !diagnostics.some((item) => item.code === 'unknown-tool-status')) {
+                    diagnostics.push({ code: 'unknown-tool-status', message: 'FX requires a terminal tool status. Unknown source status is represented as failure; the central snapshot retains the source value.' });
+                }
+                const createdAt = Date.parse(timestampOf(result));
+                if (!Number.isSafeInteger(createdAt) || createdAt < 0)
+                    throw new Error('FX tool result timestamp must be a non-negative millisecond timestamp.');
+                const bytes = Buffer.byteLength(result.content);
+                results.push({
+                    tool_call_id: result.tool_call_id,
+                    tool_name: names.get(result.tool_call_id),
+                    status: result.ok === true ? 'success' : 'failure',
+                    output: result.content,
+                    output_bytes: bytes,
+                    stored_output_bytes: bytes,
+                    truncated: false,
+                    provider_native: false,
+                    created_at_ms: createdAt,
+                    permission_feedback: [],
+                });
+            }
+            if (callIds.size)
+                throw new Error(`FX tool batch is missing results: ${[...callIds].join(', ')}`);
+            steps.push({
+                assistant: stepAssistant ?? null,
+                tool_calls: calls.map((call) => ({
+                    id: call.id,
+                    name: call.name,
+                    arguments_json: call.args,
+                    provider_result: null,
+                })),
+                tool_results: results,
+            });
+            stepAssistant = undefined;
+        }
+        if (finalAssistant === null)
+            throw new Error('FX cannot export a turn without a completed final assistant reply.');
+        const turn = { kind: 'assistant', user: { text: user.content, images: [] }, assistant: finalAssistant };
+        if (steps.length)
+            turn.execution = { schema_version: 3, tool_steps: steps, files: [] };
+        history.push(turn);
+    }
+    const timeMs = Date.parse(timestamp);
+    const session = {
+        schema_version: 1,
+        id,
+        created_at_ms: timeMs,
+        updated_at_ms: timeMs,
+        workspace_root: options.cwd,
+        conversation_language: 'en',
+        history_len: history.length,
+        history,
+    };
+    const entrypoint = `.fx/sessions/${id}/session.json`;
+    return {
+        harness: 'fx',
+        sessionId: id,
+        entrypoint,
+        files: [{ path: entrypoint, content: `${JSON.stringify(session, null, 2)}\n` }],
+        resume: {
+            cwd: options.cwd,
+            command: 'env',
+            args: [
+                `HOME=${options.directory}`,
+                'fx',
+                ...(options.provider ? ['--provider', options.provider] : []),
+                ...(options.model ? ['--model', options.model] : []),
+                'resume',
+                id,
+            ],
+        },
+        diagnostics: [...diagnostics, {
+                code: 'isolated-native-home',
+                message: 'FX discovers sessions under $HOME/.fx. Resume with HOME set to the export directory; credentials, settings, permissions, provider replay, images, and file evidence are not imported.',
+            }],
+    };
+};

package/dist/writers/github-copilot.d.ts

@@ -0,0 +1,3 @@
+import type { NativeWriter } from '../types.js';
+/** GitHub Copilot CLI 1.0.91 local session event history. */
+export declare const writeGitHubCopilot: NativeWriter;

package/dist/writers/github-copilot.js

@@ -0,0 +1,71 @@
+import { destination, droppedRecord, jsonl, parseArguments, timestampOf, toolNames } from './helpers.js';
+import { randomNativeEntropy } from './entropy.js';
+/** GitHub Copilot CLI 1.0.91 local session event history. */
+export const writeGitHubCopilot = (records, options, entropy = randomNativeEntropy) => {
+    const { id, timestamp } = destination(options, entropy);
+    const names = toolNames(records);
+    const diagnostics = [];
+    const events = [];
+    let parentId = null;
+    const emit = (type, data, at) => {
+        const event = { id: entropy.uuid(), timestamp: at, parentId, type, data };
+        events.push(event);
+        parentId = event.id;
+        return event;
+    };
+    emit('session.start', { sessionId: id, version: 1, producer: 'copilot-agent',
+        copilotVersion: '1.0.91', startTime: timestamp, context: { cwd: options.cwd },
+        ...(options.model ? { selectedModel: options.model } : {}) }, timestamp);
+    const calls = new Map();
+    for (const record of records) {
+        if (droppedRecord(record, diagnostics) || record.role === 'meta')
+            continue;
+        const at = timestampOf(record);
+        if (record.role === 'user') {
+            const messageId = entropy.uuid();
+            emit('hook.start', { hookInvocationId: entropy.uuid(), hookType: 'userPromptSubmitted',
+                input: { prompt: record.content, sessionId: id, cwd: options.cwd, timestamp: at } }, at);
+            emit('user.message', { content: record.content, messageId }, at);
+        }
+        else if (record.role === 'assistant') {
+            if ('tool_calls' in record) {
+                const requests = record.tool_calls.map(call => {
+                    const args = parseArguments(call.args);
+                    calls.set(call.id, { name: call.name, args });
+                    return { toolCallId: call.id, name: call.name, arguments: args, type: 'function' };
+                });
+                emit('assistant.message', { messageId: entropy.uuid(), content: '', toolRequests: requests,
+                    ...(options.model ? { model: options.model } : {}) }, at);
+                for (const call of record.tool_calls) {
+                    const request = calls.get(call.id);
+                    emit('tool.execution_start', { toolCallId: call.id, toolName: request.name,
+                        arguments: request.args, ...(options.model ? { model: options.model } : {}) }, at);
+                }
+            }
+            else
+                emit('assistant.message', { messageId: entropy.uuid(), content: record.content,
+                    ...(options.model ? { model: options.model } : {}) }, at);
+        }
+        else if (record.role === 'tool') {
+            const request = calls.get(record.tool_call_id);
+            if (!request || names.get(record.tool_call_id) !== request.name)
+                throw new Error(`Missing Copilot tool request: ${record.tool_call_id}`);
+            emit('tool.execution_complete', { toolCallId: record.tool_call_id, success: record.ok !== false,
+                ...(record.ok === false ? { error: { message: record.content } } : { result: { content: record.content } }),
+                ...(options.model ? { model: options.model } : {}) }, at);
+            calls.delete(record.tool_call_id);
+            if (record.ok === undefined && !diagnostics.some(item => item.code === 'unknown-tool-status')) {
+                diagnostics.push({ code: 'unknown-tool-status', message: 'Unknown source tool status maps to Copilot success without asserting source success; the central snapshot retains unknown status.' });
+            }
+        }
+    }
+    const prefix = `session-state/${id}`;
+    const entrypoint = `${prefix}/events.jsonl`;
+    const workspace = { id, cwd: options.cwd, summary_count: 0, created_at: timestamp, updated_at: timestamp };
+    return { harness: 'github-copilot', sessionId: id, entrypoint,
+        files: [{ path: entrypoint, content: jsonl(events) },
+            { path: `${prefix}/workspace.yaml`, content: JSON.stringify(workspace, null, 2) + '\n' }],
+        resume: { command: 'env', args: [`COPILOT_HOME=${options.directory}`, 'copilot', `--resume=${id}`,
+                ...(options.model ? ['--model', options.model] : [])], cwd: options.cwd },
+        diagnostics: [...diagnostics, { code: 'native-home-required', message: 'Set COPILOT_HOME to the export directory before resuming. Authentication, provider credentials, permissions, tools, and workspace files are not transferred.' }] };
+};

package/dist/writers/grok-build.d.ts

@@ -0,0 +1,3 @@
+import type { NativeWriter } from '../types.js';
+/** Grok Build's version-1 ConversationItem history and session summary. */
+export declare const writeGrokBuild: NativeWriter;

package/dist/writers/grok-build.js

@@ -0,0 +1,43 @@
+import { destination, droppedRecord, jsonl, toolNames } from './helpers.js';
+/** Grok Build's version-1 ConversationItem history and session summary. */
+export const writeGrokBuild = (records, options, entropy) => {
+    const { id, timestamp } = destination(options, entropy);
+    toolNames(records);
+    const diagnostics = [];
+    // Native session/load and session/resume restore this journal directly.
+    // The caller supplies destination instructions/workspace through the runtime.
+    const history = [];
+    let promptIndex = 0;
+    for (const record of records) {
+        if (droppedRecord(record, diagnostics))
+            continue;
+        if (record.role === 'user') {
+            history.push({ type: 'user', content: [{ type: 'text', text: record.content }], prompt_index: promptIndex++ });
+        }
+        else if (record.role === 'assistant') {
+            history.push('tool_calls' in record
+                ? { type: 'assistant', content: '', tool_calls: record.tool_calls.map(call => ({ id: call.id, name: call.name, arguments: call.args })) }
+                : { type: 'assistant', content: record.content });
+        }
+        else if (record.role === 'tool') {
+            history.push({ type: 'tool_result', tool_call_id: record.tool_call_id, content: record.content });
+            if (record.ok !== undefined && !diagnostics.some(d => d.code === 'untranslated-tool-status')) {
+                diagnostics.push({ code: 'untranslated-tool-status', message: 'Grok ConversationItem tool results have no success-status field. Source status remains in the central snapshot.' });
+            }
+        }
+    }
+    // Rust urlencoding::encode percent-encodes every non-unreserved UTF-8 byte.
+    const encodedCwd = encodeURIComponent(options.cwd).replace(/[!'()*]/g, c => `%${c.charCodeAt(0).toString(16).toUpperCase()}`);
+    if (Buffer.byteLength(encodedCwd) > 255)
+        throw new Error('Grok native cwd encoding exceeds 255 bytes; use a shorter workspace path. Hashed Grok cwd directories are not supported by this writer yet.');
+    const prefix = `sessions/${encodedCwd}/${id}`;
+    const entrypoint = `${prefix}/chat_history.jsonl`;
+    const summary = { info: { id, cwd: options.cwd }, session_summary: 'Imported conversation', created_at: timestamp,
+        updated_at: timestamp, num_messages: history.length, num_chat_messages: history.length,
+        current_model_id: options.model ?? 'grok-build', chat_format_version: 1, next_trace_turn: 0,
+        session_kind: 'headless', grok_home: options.directory };
+    return { harness: 'grok-build', sessionId: id, entrypoint,
+        files: [{ path: entrypoint, content: jsonl(history) }, { path: `${prefix}/summary.json`, content: JSON.stringify(summary, null, 2) + '\n' }],
+        resume: { cwd: options.cwd, command: 'env', args: [`GROK_HOME=${options.directory}`, 'grok', '--resume', id, '--cwd', options.cwd, ...(options.model ? ['--model', options.model] : [])] },
+        diagnostics: [...diagnostics, { code: 'native-home-required', message: `Set GROK_HOME to the export directory before resuming. Only conversation history is transferred; runtime permissions, credentials, plans, and rewind state are not imported.` }] };
+};

package/dist/writers/helpers.d.ts

@@ -0,0 +1,17 @@
+import type { NormalizedRecord } from '@letta-ai/trajectory';
+import type { ConversionDiagnostic, NativeEntropy, WriteOptions } from '../types.js';
+export declare function destination(options: WriteOptions, entropy?: NativeEntropy): {
+    id: string;
+    timestamp: string;
+};
+export declare function jsonl(entries: readonly unknown[]): string;
+/** Refuse incomplete execution history: a writer cannot decide a pending tool's outcome. */
+export declare function toolNames(records: readonly NormalizedRecord[]): Map<string, string>;
+export declare function parseArguments(args: string): Record<string, unknown>;
+export declare function droppedRecord(record: NormalizedRecord, diagnostics: ConversionDiagnostic[]): boolean;
+export declare function timestampOf(record: Exclude<NormalizedRecord, {
+    role: 'meta';
+}>): string;
+/** Target files require numeric usage; these placeholders are never measured usage. */
+export declare function placeholderUsage(): Record<string, unknown>;
+export declare function usageDiagnostic(): ConversionDiagnostic;

package/dist/writers/helpers.js

@@ -0,0 +1,75 @@
+import { isAbsolute } from 'node:path';
+import { randomNativeEntropy } from './entropy.js';
+export function destination(options, entropy = randomNativeEntropy) {
+    if (!isAbsolute(options.directory) || !isAbsolute(options.cwd)) {
+        throw new Error('Native export directory and cwd must be absolute paths.');
+    }
+    const id = options.sessionId ?? entropy.uuid();
+    if (!/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(id)) {
+        throw new Error('Native sessionId must be a UUID.');
+    }
+    const timestamp = options.timestamp ?? new Date().toISOString();
+    if (!Number.isFinite(Date.parse(timestamp)))
+        throw new Error('Invalid export timestamp.');
+    return { id, timestamp: new Date(timestamp).toISOString() };
+}
+export function jsonl(entries) {
+    return entries.map((entry) => JSON.stringify(entry)).join('\n') + '\n';
+}
+/** Refuse incomplete execution history: a writer cannot decide a pending tool's outcome. */
+export function toolNames(records) {
+    const names = new Map();
+    const pending = new Set();
+    for (const record of records) {
+        if (record.role === 'assistant' && 'tool_calls' in record) {
+            for (const call of record.tool_calls) {
+                if (!call.id || !call.name || names.has(call.id))
+                    throw new Error(`Invalid or duplicate tool call: ${call.id}`);
+                parseArguments(call.args);
+                names.set(call.id, call.name);
+                pending.add(call.id);
+            }
+        }
+        else if (record.role === 'tool') {
+            if (!pending.delete(record.tool_call_id))
+                throw new Error(`Orphan or duplicate tool result: ${record.tool_call_id}`);
+        }
+        else if (pending.size && (record.role === 'user' || record.role === 'assistant')) {
+            throw new Error('Cannot migrate an unfinished tool batch.');
+        }
+    }
+    if (pending.size)
+        throw new Error(`Cannot migrate pending tool calls: ${[...pending].join(', ')}`);
+    return names;
+}
+export function parseArguments(args) {
+    const parsed = JSON.parse(args);
+    if (parsed === null || typeof parsed !== 'object' || Array.isArray(parsed)) {
+        throw new Error('Native tool arguments must be a JSON object.');
+    }
+    return parsed;
+}
+export function droppedRecord(record, diagnostics) {
+    if (record.role === 'meta')
+        return true;
+    if (record.role === 'reasoning' || record.role === 'system' || record.role === 'observation') {
+        if (!diagnostics.some((item) => item.code === `untranslated-${record.role}`)) {
+            diagnostics.push({ code: `untranslated-${record.role}`, message: `Source ${record.role} records remain in the central snapshot; they are not installed as target runtime instructions or provider reasoning.` });
+        }
+        return true;
+    }
+    return false;
+}
+export function timestampOf(record) {
+    if (!Number.isFinite(Date.parse(record.timestamp)))
+        throw new Error('Invalid source record timestamp.');
+    return new Date(record.timestamp).toISOString();
+}
+/** Target files require numeric usage; these placeholders are never measured usage. */
+export function placeholderUsage() {
+    return { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, totalTokens: 0,
+        cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 } };
+}
+export function usageDiagnostic() {
+    return { code: 'synthetic-native-usage', message: 'Imported messages have unknown usage. Native-required usage fields contain zero placeholders; they are not measured token or cost values. Original evidence remains in the central snapshot.' };
+}

package/dist/writers/omp.d.ts

@@ -0,0 +1,3 @@
+import type { NativeWriter } from '../types.js';
+/** OMP v3 shares Pi's message subset. No Pi-only entries, cache keys, or blobs are emitted. */
+export declare const writeOmp: NativeWriter;

package/dist/writers/omp.js

@@ -0,0 +1,7 @@
+import { writePi } from './pi.js';
+/** OMP v3 shares Pi's message subset. No Pi-only entries, cache keys, or blobs are emitted. */
+export const writeOmp = (records, options, entropy) => {
+    const exported = writePi(records, options, entropy);
+    return { ...exported, harness: 'omp', resume: { cwd: options.cwd, command: 'omp', args: exported.resume.args.map(arg => arg === '--session' ? '--resume' : arg) },
+        diagnostics: [...exported.diagnostics, { code: 'omp-portable-subset', message: 'OMP import uses its v3 inline message subset. Native context snapshots, blob references, credential pins, and session_init runtime configuration are not transferred.' }] };
+};

package/dist/writers/opencode.d.ts

@@ -0,0 +1,3 @@
+import type { NativeWriter } from '../types.js';
+/** The public `opencode import` JSON format; never writes OpenCode's SQLite database. */
+export declare const writeOpenCode: NativeWriter;

package/dist/writers/opencode.js

@@ -0,0 +1,65 @@
+import { resolve } from 'node:path';
+import { destination, droppedRecord, parseArguments, timestampOf, toolNames, usageDiagnostic } from './helpers.js';
+import { randomNativeEntropy } from './entropy.js';
+/** The public `opencode import` JSON format; never writes OpenCode's SQLite database. */
+export const writeOpenCode = (records, options, entropy = randomNativeEntropy) => {
+    const { id, timestamp } = destination(options, entropy);
+    toolNames(records);
+    const diagnostics = [usageDiagnostic()];
+    const sessionId = `ses_${id.replaceAll('-', '')}`;
+    const modelID = options.model ?? 'unknown';
+    const providerID = options.provider ?? 'trajectories-import';
+    const at = Date.parse(timestamp);
+    let sequence = 0;
+    // OpenCode orders messages by its monotonic, 48-bit timestamp-prefixed ids.
+    const makeId = (prefix) => `${prefix}_${((BigInt(at) * 4096n + BigInt(++sequence)) & 0xffffffffffffn).toString(16).padStart(12, '0')}${Buffer.from(entropy.bytes(7)).toString('hex')}`;
+    const tokens = { input: 0, output: 0, reasoning: 0, cache: { read: 0, write: 0 } };
+    const messages = [];
+    const tools = new Map();
+    let parentID;
+    for (const record of records) {
+        if (droppedRecord(record, diagnostics) || record.role === 'meta')
+            continue;
+        const created = Date.parse(timestampOf(record));
+        if (record.role === 'tool') {
+            const pending = tools.get(record.tool_call_id);
+            pending.part.state = record.ok === false
+                ? { status: 'error', input: pending.input, error: record.content, time: { start: pending.start, end: created } }
+                : { status: 'completed', input: pending.input, output: record.content, title: String(pending.part.tool), metadata: {}, time: { start: pending.start, end: created } };
+            if (record.ok === undefined && !diagnostics.some(d => d.code === 'unknown-tool-status'))
+                diagnostics.push({ code: 'unknown-tool-status', message: 'Unknown source tool status maps to OpenCode completed without asserting source success; the source snapshot retains unknown status.' });
+            continue;
+        }
+        if (record.role !== 'user' && record.role !== 'assistant')
+            continue;
+        const messageID = makeId('msg');
+        if (record.role === 'user')
+            parentID = messageID;
+        if (!parentID)
+            throw new Error('OpenCode import requires a user message before assistant messages.');
+        const info = record.role === 'user'
+            ? { id: messageID, sessionID: sessionId, role: 'user', time: { created }, agent: 'build', model: { providerID, modelID } }
+            : { id: messageID, sessionID: sessionId, role: 'assistant', parentID, modelID, providerID, mode: 'build', agent: 'build',
+                path: { cwd: options.cwd, root: options.cwd }, cost: 0, tokens, time: { created, completed: created }, finish: 'tool_calls' in record ? 'tool-calls' : 'stop' };
+        const parts = [];
+        if (record.role === 'assistant' && 'tool_calls' in record) {
+            for (const call of record.tool_calls) {
+                const input = parseArguments(call.args);
+                const part = { id: makeId('prt'), sessionID: sessionId, messageID, type: 'tool', callID: call.id, tool: call.name, state: {} };
+                parts.push(part);
+                tools.set(call.id, { part, input, start: created });
+            }
+        }
+        else
+            parts.push({ id: makeId('prt'), sessionID: sessionId, messageID, type: 'text', text: record.content });
+        messages.push({ info, parts });
+    }
+    const entrypoint = `${sessionId}.json`;
+    const data = { info: { id: sessionId, slug: `import-${id.slice(0, 8)}`, projectID: 'global', directory: options.cwd,
+            title: 'Imported conversation', version: '1.18.34', time: { created: at, updated: at } }, messages };
+    const isolated = [`XDG_DATA_HOME=${resolve(options.directory, 'data')}`, `XDG_CONFIG_HOME=${resolve(options.directory, 'config')}`,
+        `XDG_STATE_HOME=${resolve(options.directory, 'state')}`, `XDG_CACHE_HOME=${resolve(options.directory, 'cache')}`, 'opencode'];
+    return { harness: 'opencode', sessionId, entrypoint, files: [{ path: entrypoint, content: JSON.stringify(data, null, 2) + '\n' }],
+        prepare: [{ cwd: options.cwd, command: 'env', args: [...isolated, 'import', resolve(options.directory, entrypoint)] }],
+        resume: { cwd: options.cwd, command: 'env', args: [...isolated, 'run', '--session', sessionId, '--dir', options.cwd, ...(options.model && options.provider ? ['--model', `${options.provider}/${options.model}`] : [])] }, diagnostics };
+};

package/dist/writers/pi.d.ts

@@ -0,0 +1,3 @@
+import type { NativeWriter } from '../types.js';
+/** Pi SessionManager v3 JSONL; no runtime dependency is required to produce a file. */
+export declare const writePi: NativeWriter;

package/dist/writers/pi.js

@@ -0,0 +1,45 @@
+import { resolve } from 'node:path';
+import { destination, droppedRecord, jsonl, parseArguments, placeholderUsage, timestampOf, toolNames, usageDiagnostic } from './helpers.js';
+import { randomNativeEntropy } from './entropy.js';
+/** Pi SessionManager v3 JSONL; no runtime dependency is required to produce a file. */
+export const writePi = (records, options, entropy = randomNativeEntropy) => {
+    const { id, timestamp } = destination(options, entropy);
+    const names = toolNames(records);
+    const diagnostics = [usageDiagnostic()];
+    const sourceModel = records.find((record) => record.role === 'meta')?.model ?? 'unknown';
+    const entries = [{ type: 'session', version: 3, id, timestamp, cwd: options.cwd }];
+    let parentId = null;
+    for (const record of records) {
+        if (droppedRecord(record, diagnostics) || record.role === 'meta')
+            continue;
+        const at = timestampOf(record);
+        let message;
+        if (record.role === 'user') {
+            message = { role: 'user', content: record.content, timestamp: Date.parse(at) };
+        }
+        else if (record.role === 'assistant') {
+            const content = 'tool_calls' in record
+                ? record.tool_calls.map((call) => ({ type: 'toolCall', id: call.id, name: call.name, arguments: parseArguments(call.args) }))
+                : [{ type: 'text', text: record.content }];
+            message = { role: 'assistant', content, api: 'openai-completions', provider: 'trajectories-import', model: sourceModel,
+                usage: placeholderUsage(), stopReason: 'tool_calls' in record ? 'toolUse' : 'stop', timestamp: Date.parse(at) };
+        }
+        else if (record.role === 'tool') {
+            message = { role: 'toolResult', toolCallId: record.tool_call_id, toolName: names.get(record.tool_call_id),
+                content: [{ type: 'text', text: record.content }], isError: record.ok === false, timestamp: Date.parse(at) };
+            if (record.ok === undefined && !diagnostics.some((d) => d.code === 'unknown-tool-status'))
+                diagnostics.push({ code: 'unknown-tool-status', message: 'Source tool status is unknown; target isError defaults to false without asserting source success.' });
+        }
+        else
+            continue;
+        const entryId = entropy.uuid();
+        entries.push({ type: 'message', id: entryId, parentId, timestamp: at, message });
+        parentId = entryId;
+    }
+    // Pi's CLI migrates root-level *.jsonl before resolving --session. A file
+    // at the agent home root would move, then its old path starts an empty session.
+    const projectKey = `--${options.cwd.replace(/^[/\\]/, '').replace(/[/\\:]/g, '-')}--`;
+    const entrypoint = `sessions/${projectKey}/${id}.jsonl`;
+    return { harness: 'pi', sessionId: id, files: [{ path: entrypoint, content: jsonl(entries) }], entrypoint,
+        resume: { cwd: options.cwd, command: 'pi', args: ['--session', resolve(options.directory, entrypoint), ...(options.model ? ['--model', options.model] : []), ...(options.provider ? ['--provider', options.provider] : [])] }, diagnostics };
+};

package/docs/cline-native-format.md

@@ -0,0 +1,43 @@
+# Cline native history
+
+The codec reads Cline Core version-1 `<id>.messages.json` and the
+`@cline/agents` AgentMessage array persisted as `history.json` by Vercel's
+Cline adapter. Source pins: Cline `39ff2359f7e08231281539696e48a166ce49270c`,
+Core/Agents 0.0.79, compatible adapter 1.0.29. The native CLI probe uses
+`cline@3.0.68`, which bundles Core/Agents 0.0.90; these are distinct receipts.
+
+Core stores sessions under `CLINE_SESSION_DATA_DIR`, normally
+`~/.cline/data/sessions/<id>/<id>.messages.json`, with a `<id>.json` manifest
+and optional compaction state. File inputs archive the manifest and contained
+compaction sidecars. A declared compaction path blocks conversion even when its
+state is unavailable or lies outside the session directory.
+
+The reader keeps full text, tool arguments/results, native IDs, source order,
+timestamps, reasoning and `system_prompt`. JSON tool outputs project to text;
+their original structure remains in raw history. Core's text-only
+`ToolOperationResult[]` (`query`, string `result`, boolean `success`, optional
+`error`/`duration`) is supported without flattening away its envelope. Media,
+unknown result envelopes and provider replay
+signatures require native context reconstruction and cannot be converted.
+Pending tools, mixed identities, display-only and compacted histories also fail
+portable-context validation. Source instructions and reasoning are diagnosed
+and omitted from the destination.
+
+The writer emits a Core payload/manifest, adapter `history.json`, and an explicit
+`prepare-cline.mjs` action. The action calls public `SqliteSessionStore` and
+`CoreSessionService` APIs to index and persist a fresh session; it refuses an
+already indexed UUID. It requires a compatible `@cline/core` in the caller's
+Node resolution path. The SDK never installs or starts that runtime.
+
+Zero-inference loader proof uses public `ClineCore.create({backendMode:'local'})`
+and `readMessages(id)`, recovering the user, assistant calls, complete 4 KB tool
+result and final assistant. Native `cline history --json` separately finds the
+indexed UUID. Model continuation is a separate experiment.
+
+The live probe uses public Core `readMessages → start` (same ID, loaded history,
+no prompt) `→ send`. CLI `--json --id` rejects continuation. Core selects
+`zai-coding-plan`/`glm-5.3`; the fetch guard requires the exact ZAI coding-plan
+chat-completions URL and model. Its managed credential enters Core configuration
+at runtime, never argv.
+Historical provider measurements are preserved; target model selection does
+not rewrite them or fabricate usage.

package/docs/copilot-native-format.md

@@ -0,0 +1,78 @@
+# GitHub Copilot CLI native event format
+
+This codec targets GitHub Copilot CLI @github/copilot 1.0.91 (commit 659e4652ac910f8046dc64480bd6beda8f0ad2a6). Loader acceptance uses @github/copilot-sdk 1.0.16 with the 1.0.91 CLI runtime.
+
+## Export
+
+writeGitHubCopilot emits:
+
+~~~text
+session-state/<session-id>/events.jsonl
+session-state/<session-id>/workspace.yaml
+~~~
+
+The event stream uses the CLI's native event schema:
+
+- session.start supplies session identity, version, producer, start time, cwd, and selected model.
+- hook.start with userPromptSubmitted records the prompt submission.
+- user.message preserves the runtime's displayed conversation history.
+- assistant.message carries text or native toolRequests.
+- tool.execution_start and tool.execution_complete carry tool linkage, arguments, result text, and known success state.
+
+Every event has a UUID, timestamp, and a linear parentId chain. workspace.yaml is emitted as JSON, which is valid YAML and matches the SDK's own transcript-recovery fixture fields.
+
+No prepare command is needed. Resume uses:
+
+~~~text
+env COPILOT_HOME=<export> copilot --resume=<session-id>
+~~~
+
+An optional model becomes --model <model>. Authentication, provider secrets, permissions, tools, and workspace files are caller-owned and are never copied.
+
+## Continuation guard
+
+assertGitHubCopilotHistory fails closed on:
+
+- compaction events;
+- branched, disconnected, duplicate, or missing event identities;
+- orphan, duplicate, pending, or interrupted tool executions.
+
+The local reader extends Letta 0.4.3: direct `user.message` records are authoritative,
+an immediately associated matching hook is consumed once, and hook-only legacy
+prompts remain visible. Repeated identical prompts keep separate native IDs.
+Native text `system.message` records and every assistant/tool component remain
+in order. Old snapshots using the lossy upstream projection must be recaptured
+before conversion.
+
+Only the pinned version-1 text context is portable. Unknown event types, provider
+reasoning/replay payloads, model-facing media, notifications and unsupported
+transformed user inputs are archived but block conversion. The runtime's known
+ISO datetime wrapper is metadata; all other added prompt text is unsupported.
+System text blocks must exactly reconstruct the recorded text. Raw journals keep
+UI/cache layout and other native metadata; those are not transferred as runtime
+state. Copilot tool `result.content` is the model-facing body, which may already
+have been shortened by the native runtime; `detailedContent` remains in raw bytes.
+
+CLI ingestion uses a bounded complete journal so hook/message pairs cannot split
+across independent chunks. This trades append-path efficiency for complete native
+context. Existing Copilot cursors are invalidated by a source-specific projection
+fingerprint; other readers retain their current cache and append behavior.
+
+## Z.AI GLM-5.3 BYOK
+
+Copilot CLI 1.0.91 supports an OpenAI-compatible provider through environment variables:
+
+~~~text
+COPILOT_PROVIDER_BASE_URL=https://api.z.ai/api/coding/paas/v4
+COPILOT_PROVIDER_API_KEY=<managed secret>
+COPILOT_PROVIDER_MODEL_ID=glm-5.3
+COPILOT_PROVIDER_WIRE_MODEL=glm-5.3
+COPILOT_MODEL=glm-5.3
+COPILOT_OFFLINE=true
+~~~
+
+The caller must explicitly supply that provider configuration. The codec does not inspect credentials and does not silently fall back to GitHub-hosted Copilot models.
+
+## Native acceptance
+
+All nine generated events validated against the session-events.schema.json bundled with Copilot CLI 1.0.91. The public SDK then called resumeSession through the standalone 1.0.91 CLI runtime, loaded all nine events, and disconnected without sending a prompt or making a model request. The recovered types included the session start, user hook/message, assistant messages, two tool starts, and two tool completions. Evidence is under /root/.local/share/harness-parity-implementation-2026-10-05/evidence.