trajectories 0.0.0 → 0.1.1

package/dist/readers/github-copilot.js

@@ -0,0 +1,216 @@
+import { normalizeToCanonical } from '@letta-ai/trajectory';
+import { canonicalFromRecords } from './canonical.js';
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function unsupported(reason) {
+    throw new Error(`Unsupported github-copilot continuation history: ${reason}. Native bytes can be archived, but this bootstrap cannot safely export their active context.`);
+}
+function parseRows(raw) {
+    return raw.split('\n').filter(line => line.trim()).map((line, index) => {
+        let value;
+        try {
+            value = JSON.parse(line);
+        }
+        catch {
+            throw new Error(`Invalid GitHub Copilot JSON at line ${index + 1}.`);
+        }
+        if (!object(value))
+            throw new Error(`Invalid GitHub Copilot event at line ${index + 1}.`);
+        return value;
+    });
+}
+const transportTypes = new Set([
+    'abort', 'assistant.turn_end', 'assistant.turn_start', 'hook.end', 'hook.start',
+    'session.info', 'session.resume', 'session.shutdown', 'session.start',
+    'session.task_complete', 'tool.execution_start',
+    'permission.requested', 'permission.completed',
+]);
+const contextTypes = new Set(['user.message', 'system.message', 'assistant.message', 'tool.execution_complete']);
+const userKeys = new Set(['content', 'messageId', 'transformedContent', 'attachments', 'delivery',
+    'interactionId', 'turnId', 'parentAgentTaskId', 'agentMode', 'source', 'isAutopilotContinuation',
+    'nativeDocumentPathFallbackPaths', 'supportedNativeDocumentMimeTypes', 'responsesReasoning']);
+const assistantKeys = new Set(['content', 'messageId', 'model', 'reasoningText', 'toolRequests',
+    'originatingMessageId', 'interactionId', 'turnId', 'rte', 'apiCallId', 'outputTokens',
+    'clientRequestId', 'requestId', 'serviceRequestId', 'chunkCount', 'chunkIndex']);
+const systemKeys = new Set(['role', 'content', 'contentBlocks', 'interactionId', 'metadata', 'name']);
+/** Extend Letta's archive projection with native direct prompts and system text.
+ * A hook is only a duplicate when its next submission carries the same prompt.
+ * Repeated user messages remain distinct and keep their own native identities.
+ */
+export function readGitHubCopilot(raw) {
+    const rows = parseRows(raw);
+    const base = normalizeToCanonical({ source: 'copilot-cli', transcript: raw,
+        bounds: { toolArguments: { maxCharacters: null }, toolResults: { maxCharacters: null } },
+        filters: { systemMessages: 'include', toolResults: 'include' } });
+    const meta = base.records.find(record => record.record_type === 'meta');
+    const entries = [{ record: JSON.parse(meta.record_json) }];
+    const byId = new Map();
+    for (const record of base.records.filter(record => record.record_type !== 'meta')) {
+        const group = byId.get(record.stable_source_record_id) ?? [];
+        group.push(record);
+        byId.set(record.stable_source_record_id, group);
+    }
+    const appendBase = (row, index) => {
+        for (const canonical of byId.get(String(row.id)) ?? []) {
+            const record = JSON.parse(canonical.record_json);
+            const previous = entries.at(-1);
+            if (record.role === 'assistant' && 'tool_calls' in record && previous && previous.nativeId === row.id &&
+                previous.record.role === 'assistant' && 'tool_calls' in previous.record) {
+                previous.record.tool_calls.push(...record.tool_calls);
+                continue;
+            }
+            entries.push({ record, nativeId: typeof row.id === 'string' ? row.id : undefined, sourceSequence: index,
+                ...(canonical.source_timestamp ? { sourceTimestamp: canonical.source_timestamp } : {}) });
+        }
+    };
+    let pendingHook;
+    const flushHook = () => {
+        if (pendingHook)
+            appendBase(pendingHook.row, pendingHook.index);
+        pendingHook = undefined;
+    };
+    for (const [index, row] of rows.entries()) {
+        const data = object(row.data) ? row.data : {};
+        if (row.type === 'hook.start' && data.hookType === 'userPromptSubmitted') {
+            flushHook();
+            pendingHook = { row, index };
+            continue;
+        }
+        if (row.type === 'user.message') {
+            const hookData = pendingHook && object(pendingHook.row.data) ? pendingHook.row.data : {};
+            const input = object(hookData.input) ? hookData.input : {};
+            if (typeof data.content === 'string' && input.prompt === data.content)
+                pendingHook = undefined;
+            else
+                flushHook();
+        }
+        else if (contextTypes.has(String(row.type)) || String(row.type).startsWith('session.') ||
+            row.type === 'assistant.turn_start' || row.type === 'assistant.turn_end') {
+            flushHook();
+        }
+        if ((row.type === 'user.message' || row.type === 'system.message') && typeof data.content === 'string') {
+            const timestamp = row.timestamp;
+            if (typeof timestamp !== 'string' || !Number.isFinite(Date.parse(timestamp)))
+                throw new Error('Invalid Copilot native message timestamp.');
+            entries.push({ record: { role: row.type === 'user.message' ? 'user' : 'system', content: data.content, timestamp },
+                nativeId: typeof row.id === 'string' ? row.id : undefined, sourceSequence: index, sourceTimestamp: timestamp });
+        }
+        else
+            appendBase(row, index);
+    }
+    flushHook();
+    const diagnostics = base.diagnostics.filter(diagnostic => diagnostic.code !== 'noise_record_dropped' ||
+        !['system.message', 'permission.requested', 'permission.completed'].includes(String(rows[(diagnostic.inputLine ?? 0) - 1]?.type)));
+    const canonical = canonicalFromRecords('copilot-cli', meta.source_group_id, entries, diagnostics);
+    const components = new Map();
+    for (const record of canonical.records) {
+        const index = components.get(record.source_order_id) ?? 0;
+        record.component_index = index;
+        components.set(record.source_order_id, index + 1);
+    }
+    return canonical;
+}
+/** Reject native state that the supported text projection cannot continue. */
+export function assertGitHubCopilotHistory(raw) {
+    const rows = parseRows(raw);
+    if (!rows.length)
+        throw new Error('GitHub Copilot event history is empty.');
+    const starts = rows.filter(row => row.type === 'session.start');
+    const start = starts[0];
+    if (starts.length !== 1 || rows[0] !== start || !start || !object(start.data) || start.data.version !== 1 ||
+        typeof start.data.sessionId !== 'string' || !start.data.sessionId)
+        unsupported('requires one identified leading version-1 session.start');
+    const ids = new Set();
+    let previous = null;
+    const pending = new Set();
+    for (const [index, row] of rows.entries()) {
+        const id = typeof row.id === 'string' ? row.id : '';
+        if (!id || ids.has(id))
+            unsupported('events require unique native ids');
+        const parent = row.parentId;
+        if (index === 0 ? parent !== null : parent !== previous)
+            unsupported('branched or disconnected native event chain');
+        ids.add(id);
+        previous = id;
+        const type = String(row.type);
+        const data = object(row.data) ? row.data : {};
+        if (row.agentId !== undefined)
+            unsupported('subagent history needs separate context reconstruction');
+        if (!transportTypes.has(type) && !contextTypes.has(type))
+            unsupported(`unsupported context event ${type}`);
+        if (type === 'user.message') {
+            if (typeof data.content !== 'string' || (Array.isArray(data.attachments) && data.attachments.length) ||
+                (data.attachments !== undefined && !Array.isArray(data.attachments)))
+                unsupported('user attachments or nontext content');
+            if (Object.keys(data).some(key => !userKeys.has(key)) || data.responsesReasoning != null ||
+                ['nativeDocumentPathFallbackPaths', 'supportedNativeDocumentMimeTypes'].some(key => data[key] !== undefined &&
+                    (!Array.isArray(data[key]) || data[key].length > 0)))
+                unsupported('unrepresented user context fields');
+            if (data.transformedContent !== undefined && data.transformedContent !== data.content) {
+                const transformed = typeof data.transformedContent === 'string' ? data.transformedContent : '';
+                const time = /^<current_datetime>([^<>\r\n]+)<\/current_datetime>\n\n/.exec(transformed)?.[1];
+                if (!time || !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/.test(time) || !Number.isFinite(Date.parse(time)) ||
+                    transformed.replace(/^<current_datetime>[^<>\r\n]+<\/current_datetime>\n\n/, '') !== data.content)
+                    unsupported('unrepresented transformed user context');
+            }
+        }
+        if (type === 'system.message') {
+            if (data.role !== 'system' || typeof data.content !== 'string' ||
+                Object.keys(data).some(key => !systemKeys.has(key)))
+                unsupported('nontext or unrepresented system message');
+            if (data.contentBlocks !== undefined && (!Array.isArray(data.contentBlocks) ||
+                data.contentBlocks.some(block => !object(block) || typeof block.content !== 'string' ||
+                    Object.keys(block).some(key => !['content', 'isStatic', 'cacheBreakpoint'].includes(key))) ||
+                data.contentBlocks.map(block => block.content).join('\n\n') !== data.content))
+                unsupported('unrepresented system content blocks');
+        }
+        if (type === 'hook.start' && data.hookType === 'userPromptSubmitted' &&
+            (!object(data.input) || typeof data.input.prompt !== 'string'))
+            unsupported('nontext submitted prompt');
+        if (type === 'assistant.message' && ((data.content !== undefined && typeof data.content !== 'string') ||
+            (data.reasoningText !== undefined && typeof data.reasoningText !== 'string') ||
+            (data.toolRequests !== undefined && !Array.isArray(data.toolRequests)) ||
+            Object.keys(data).some(key => !assistantKeys.has(key))))
+            unsupported('unrepresented assistant content');
+        if (type === 'session.compaction_start' || type === 'session.compaction_complete') {
+            unsupported('compaction requires native context reconstruction');
+        }
+        if (type === 'assistant.message' && Array.isArray(data.toolRequests)) {
+            for (const request of data.toolRequests) {
+                if (!object(request) || typeof request.toolCallId !== 'string' || !request.toolCallId || pending.has(request.toolCallId) ||
+                    typeof request.name !== 'string' || !request.name ||
+                    (typeof request.arguments !== 'string' && !object(request.arguments)) ||
+                    Object.keys(request).some(key => !['toolCallId', 'name', 'arguments', 'type', 'intentionSummary', 'toolTitle', 'mcpServerName', 'mcpToolName'].includes(key)) ||
+                    (request.type !== undefined && request.type !== 'function')) {
+                    unsupported('malformed or duplicate pending tool request');
+                }
+                if (typeof request.arguments === 'string') {
+                    try {
+                        if (!object(JSON.parse(request.arguments)))
+                            unsupported('tool arguments must be a JSON object');
+                    }
+                    catch {
+                        unsupported('tool arguments must be a JSON object');
+                    }
+                }
+                pending.add(request.toolCallId);
+            }
+        }
+        else if (type === 'tool.execution_complete') {
+            if (typeof data.toolCallId !== 'string' || !pending.delete(data.toolCallId)) {
+                unsupported('orphan or duplicate tool completion');
+            }
+            if ((!object(data.result) || !Object.hasOwn(data.result, 'content')) && data.error === undefined)
+                unsupported('unrepresented tool result');
+            if (object(data.result) && (typeof data.result.content !== 'string' ||
+                Object.keys(data.result).some(key => !['content', 'detailedContent'].includes(key))))
+                unsupported('nontext or provider-native tool result');
+        }
+        else if ((type === 'abort' || type === 'session.shutdown') && pending.size) {
+            unsupported('interrupted tool execution');
+        }
+    }
+    if (pending.size)
+        unsupported(`pending tool execution: ${[...pending].join(', ')}`);
+}

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

@@ -0,0 +1,12 @@
+/** ACP replay ported from archeism/ledger 43081aef54c23b4bd017b6c0e11fc42a9a1cb381.
+ * See legacy/NOTICE.md. Pure in-memory projection; native bytes stay in Snapshot.raw.
+ */
+import { type CanonicalResult } from '@letta-ai/trajectory';
+/** Normalize native ConversationItem history or ACP updates without reading a store.
+ * Native chat_history.jsonl has no header: callers may provide summary.json metadata.
+ */
+export declare function normalizeGrokBuild(transcript: string, metadata?: {
+    sessionId?: string;
+    cwd?: string;
+    model?: string;
+}): CanonicalResult;

package/dist/readers/grok-build.js

@@ -0,0 +1,391 @@
+/** ACP replay ported from archeism/ledger 43081aef54c23b4bd017b6c0e11fc42a9a1cb381.
+ * See legacy/NOTICE.md. Pure in-memory projection; native bytes stay in Snapshot.raw.
+ */
+import { normalizeToCanonical } from '@letta-ai/trajectory';
+import { createHash } from 'node:crypto';
+class NativeInputError extends Error {
+}
+function object(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value);
+}
+function safeNativeId(value) {
+    return typeof value === 'string' && value.trim().length > 0 && value !== '.' && value !== '..' && !/[\x00-\x1f/\\]/.test(value);
+}
+const LIFECYCLE_KINDS = new Set([
+    "hook_execution",
+    "turn_completed",
+    "session_recap",
+    "retry_state",
+    "task_backgrounded",
+    "task_completed",
+    "auto_compact_started",
+    "auto_compact_completed",
+    "compaction_checkpoint",
+    "plan",
+    "current_mode_update",
+]);
+function tally(values) {
+    let total = 0;
+    for (const count of values.values())
+        total += count;
+    return total;
+}
+function named(values, limit = 4) {
+    return [...values.keys()].sort().slice(0, limit).join(", ");
+}
+/**
+ * Replay the ACP stream.
+ *
+ * A run of same-role chunks becomes one record: chunk text is concatenated
+ * without a separator, because Grok splits tokens (including the spaces between
+ * them) across rows. A run flushes on a role change or when tool activity
+ * interrupts it, so one record's text never spans two speakers or straddles a
+ * tool call. A `tool_call_update` is a result only in its terminal state:
+ * in_progress and status-less progress rows are superseded by the terminal row
+ * that follows, and are counted rather than projected.
+ *
+ * Grok appends while it runs, so a torn last line or a line from a newer
+ * version is counted, never fatal: the transcript is what the prefix holds.
+ */
+function replayUpdates(text, sessionId, summary, limit) {
+    const rows = [];
+    const skips = {
+        lifecycle: new Map(), progress: 0, unknown: new Map(), content: 0, invalidLines: 0, malformedLines: 0,
+        repeatedTerminals: 0,
+    };
+    // One result per call id: a repeated terminal row (a retry after a failure, a
+    // re-emitted update) must not project a second result for the same call.
+    const terminals = new Set();
+    let run = null;
+    let model = summary.model;
+    let written = 0;
+    function emit(row) {
+        written += Buffer.byteLength(JSON.stringify(row)) + 1;
+        if (written > limit)
+            throw new NativeInputError("Grok transcript exceeds the native byte limit.");
+        rows.push(row);
+    }
+    function flush() {
+        const pending = run;
+        run = null;
+        if (!pending || !pending.text.length)
+            return;
+        if (pending.role === "user") {
+            emit({
+                type: "hook.start",
+                id: pending.id,
+                ...(pending.timestamp ? { timestamp: pending.timestamp } : {}),
+                data: {
+                    hookType: "userPromptSubmitted",
+                    input: { prompt: pending.text, sessionId, ...(summary.cwd ? { cwd: summary.cwd } : {}) },
+                },
+            });
+            return;
+        }
+        const eventModel = pending.model ?? model;
+        emit({
+            type: "assistant.message",
+            id: pending.id,
+            ...(pending.timestamp ? { timestamp: pending.timestamp } : {}),
+            data: {
+                ...(pending.role === "thought" ? { reasoningText: pending.text } : { content: pending.text }),
+                ...(eventModel ? { model: eventModel } : {}),
+            },
+        });
+    }
+    const lines = text.split("\n");
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        if (!line || !line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            skips.invalidLines += 1;
+            continue;
+        }
+        const row = object(parsed) ? parsed : null;
+        const params = row && object(row.params) ? row.params : null;
+        const update = params && object(params.update) ? params.update : null;
+        if (!row || !params || !update) {
+            skips.malformedLines += 1;
+            continue;
+        }
+        const meta = object(params._meta) ? params._meta : {};
+        const agentTimestampMs = typeof meta.agentTimestampMs === "number" && Number.isFinite(meta.agentTimestampMs)
+            ? meta.agentTimestampMs
+            : typeof update._meta === "object" && object(update._meta) && typeof update._meta.agentTimestampMs === "number"
+                && Number.isFinite(update._meta.agentTimestampMs)
+                ? update._meta.agentTimestampMs
+                : null;
+        const timestamp = agentTimestampMs !== null
+            ? new Date(agentTimestampMs).toISOString()
+            : typeof row.timestamp === "number" && Number.isFinite(row.timestamp) && row.timestamp > 0
+                ? new Date(row.timestamp * 1000).toISOString()
+                : null;
+        const chunkModel = object(update._meta) && typeof update._meta.modelId === "string" ? update._meta.modelId : undefined;
+        if (chunkModel)
+            model = chunkModel;
+        // A row without a usable update id keeps a stable identity from its own
+        // line: the file is append-only, so a line number never moves.
+        const id = typeof meta.eventId === "string" && safeNativeId(meta.eventId) ? meta.eventId : `grok-line-${index + 1}`;
+        const kind = update.sessionUpdate;
+        if (kind === "user_message_chunk" || kind === "agent_thought_chunk" || kind === "agent_message_chunk") {
+            const content = update.content;
+            const chunk = object(content) && content.type === "text" && typeof content.text === "string" ? content.text : null;
+            if (chunk === null) {
+                skips.content += 1;
+                continue;
+            }
+            const role = kind === "user_message_chunk" ? "user" : kind === "agent_thought_chunk" ? "thought" : "message";
+            if (run && run.role !== role)
+                flush();
+            run ??= { role, text: "", id, timestamp, model: chunkModel };
+            run.text += chunk;
+            continue;
+        }
+        if (kind === "tool_call") {
+            const callId = update.toolCallId;
+            if (!safeNativeId(callId)) {
+                skips.unknown.set("tool_call_without_id", (skips.unknown.get("tool_call_without_id") ?? 0) + 1);
+                continue;
+            }
+            flush();
+            const tool = object(update._meta) && object(update._meta["x.ai/tool"]) ? update._meta["x.ai/tool"] : null;
+            const name = typeof update.title === "string" && update.title.trim()
+                ? update.title
+                : tool && typeof tool.name === "string" && tool.name.trim() ? tool.name : undefined;
+            const eventModel = chunkModel ?? model;
+            emit({
+                type: "assistant.message",
+                id,
+                ...(timestamp ? { timestamp } : {}),
+                data: {
+                    toolRequests: [{ toolCallId: callId, ...(name ? { name } : {}), arguments: update.rawInput ?? {} }],
+                    ...(eventModel ? { model: eventModel } : {}),
+                },
+            });
+            continue;
+        }
+        if (kind === "tool_call_update") {
+            const callId = update.toolCallId;
+            if (!safeNativeId(callId)) {
+                skips.unknown.set("tool_call_update_without_id", (skips.unknown.get("tool_call_update_without_id") ?? 0) + 1);
+                continue;
+            }
+            const status = update.status;
+            if (status !== "completed" && status !== "failed") {
+                skips.progress += 1;
+                continue;
+            }
+            if (terminals.has(callId)) {
+                skips.repeatedTerminals += 1;
+                continue;
+            }
+            terminals.add(callId);
+            flush();
+            // ACP tool output is content blocks; a structured rawOutput is the only
+            // text a result can carry when no content block was written.
+            const blocks = update.content;
+            const parts = Array.isArray(blocks)
+                ? blocks
+                    .map((block) => (object(block) && object(block.content) && block.content.type === "text" && typeof block.content.text === "string"
+                    ? block.content.text
+                    : null))
+                    .filter((part) => part !== null && part.length > 0)
+                : [];
+            const raw = update.rawOutput;
+            const output = parts.length
+                ? parts.join("\n")
+                : raw === undefined || raw === null ? "" : typeof raw === "string" ? raw : JSON.stringify(raw);
+            emit({
+                type: "tool.execution_complete",
+                id,
+                ...(timestamp ? { timestamp } : {}),
+                data: {
+                    toolCallId: callId,
+                    success: status !== "failed",
+                    ...(status === "failed" ? { error: { message: output } } : { result: { content: output } }),
+                },
+            });
+            continue;
+        }
+        if (typeof kind === "string" && LIFECYCLE_KINDS.has(kind)) {
+            skips.lifecycle.set(kind, (skips.lifecycle.get(kind) ?? 0) + 1);
+            continue;
+        }
+        const label = typeof kind === "string" && kind ? kind : "missing_kind";
+        skips.unknown.set(label, (skips.unknown.get(label) ?? 0) + 1);
+    }
+    flush();
+    return { rows, skips, model };
+}
+/** Every skip is typed and counted, so a dropped update never vanishes silently. */
+function skipDiagnostics(skips) {
+    const diagnostics = [];
+    if (skips.lifecycle.size) {
+        diagnostics.push({
+            code: "noise_record_dropped",
+            message: `Skipped ${tally(skips.lifecycle)} Grok lifecycle update(s) (${named(skips.lifecycle)}).`,
+            count: tally(skips.lifecycle),
+        });
+    }
+    if (skips.progress) {
+        diagnostics.push({
+            code: "noise_record_dropped",
+            message: `Skipped ${skips.progress} non-terminal Grok tool progress update(s); the terminal update carries the result.`,
+            count: skips.progress,
+        });
+    }
+    if (skips.repeatedTerminals) {
+        diagnostics.push({
+            code: "noise_record_dropped",
+            message: `Skipped ${skips.repeatedTerminals} repeated Grok tool terminal update(s); the call's first terminal update is its result.`,
+            count: skips.repeatedTerminals,
+        });
+    }
+    if (skips.unknown.size) {
+        diagnostics.push({
+            code: "noise_record_dropped",
+            message: `Skipped ${tally(skips.unknown)} Grok update(s) with no supported transcript shape (${named(skips.unknown)}).`,
+            count: tally(skips.unknown),
+        });
+    }
+    if (skips.content) {
+        diagnostics.push({
+            code: "noise_record_dropped",
+            message: `Skipped ${skips.content} Grok message update(s) whose content is not a text block.`,
+            count: skips.content,
+        });
+    }
+    if (skips.invalidLines) {
+        diagnostics.push({
+            code: "invalid_json_line",
+            message: `Skipped ${skips.invalidLines} invalid JSON line(s) in the Grok update stream.`,
+            count: skips.invalidLines,
+        });
+    }
+    if (skips.malformedLines) {
+        diagnostics.push({
+            code: "invalid_json_line",
+            message: `Skipped ${skips.malformedLines} Grok line(s) with no session update object.`,
+            count: skips.malformedLines,
+        });
+    }
+    return diagnostics;
+}
+/** Normalize native ConversationItem history or ACP updates without reading a store.
+ * Native chat_history.jsonl has no header: callers may provide summary.json metadata.
+ */
+export function normalizeGrokBuild(transcript, metadata = {}) {
+    const input = [];
+    for (const [index, line] of transcript.split('\n').entries()) {
+        if (!line.trim())
+            continue;
+        let parsed;
+        try {
+            parsed = JSON.parse(line);
+        }
+        catch {
+            throw new NativeInputError(`Malformed Grok JSON on line ${index + 1}.`);
+        }
+        if (!object(parsed))
+            throw new NativeInputError(`Grok line ${index + 1} is not an object.`);
+        input.push(parsed);
+    }
+    if (!input.length)
+        throw new NativeInputError('Grok transcript is empty.');
+    const ids = new Set();
+    if (metadata.sessionId)
+        ids.add(metadata.sessionId);
+    for (const row of input) {
+        if (object(row.params) && typeof row.params.sessionId === 'string')
+            ids.add(row.params.sessionId);
+    }
+    if ([...ids].some(id => !safeNativeId(id)))
+        throw new NativeInputError('Invalid Grok native session id.');
+    if (ids.size > 1)
+        throw new NativeInputError('Grok transcript contains multiple native session ids.');
+    const id = [...ids][0] ?? `grok-${createHash('sha256').update(transcript).digest('hex')}`;
+    const acp = input.every(row => object(row.params) && object(row.params.update));
+    let rows;
+    let diagnostics = [];
+    if (acp) {
+        const replay = replayUpdates(transcript, id, metadata, Number.MAX_SAFE_INTEGER);
+        rows = replay.rows;
+        diagnostics = skipDiagnostics(replay.skips);
+    }
+    else {
+        if (input.some(row => object(row.params)))
+            throw new NativeInputError('Mixed Grok native and ACP formats.');
+        rows = [{ type: 'session_meta', payload: { id, cwd: metadata.cwd } }];
+        const model = metadata.model ?? input.find(row => typeof row.model_id === 'string')?.model_id;
+        if (model)
+            rows.push({ type: 'turn_context', payload: { model } });
+        const response = (payload) => rows.push({ type: 'response_item', payload });
+        for (const [index, row] of input.entries()) {
+            if (row.type === 'user' || row.type === 'assistant' || row.type === 'system') {
+                let content;
+                if (typeof row.content === 'string')
+                    content = row.content;
+                else if (Array.isArray(row.content) && row.content.every(part => object(part) && part.type === 'text' && typeof part.text === 'string')) {
+                    content = row.content.map(part => part.text).join('\n');
+                }
+                else
+                    throw new NativeInputError(`Unsupported Grok content on line ${index + 1}.`);
+                // Grok stores runtime instructions in user-shaped items before the first
+                // indexed human prompt. Retain their content as system context so a
+                // target writer does not promote old runtime rules into user intent.
+                const generatedContext = row.type === 'user' && row.prompt_index === undefined &&
+                    ((typeof row.synthetic_reason === 'string' && row.synthetic_reason.length > 0) || content.trimStart().startsWith('<user_info>'));
+                const role = generatedContext ? 'system' : row.type;
+                if (content.length)
+                    response({ type: 'message', role, content: [{ type: row.type === 'assistant' ? 'output_text' : 'input_text', text: content }] });
+                if (row.tool_calls !== undefined) {
+                    if (row.type !== 'assistant' || !Array.isArray(row.tool_calls))
+                        throw new NativeInputError('Invalid Grok tool calls.');
+                    for (const call of row.tool_calls) {
+                        if (!object(call) || !safeNativeId(call.id) || typeof call.name !== 'string' || typeof call.arguments !== 'string')
+                            throw new NativeInputError('Invalid Grok tool call.');
+                        try {
+                            JSON.parse(call.arguments);
+                        }
+                        catch {
+                            throw new NativeInputError('Malformed Grok tool arguments.');
+                        }
+                        response({ type: 'function_call', call_id: call.id, name: call.name, arguments: call.arguments });
+                    }
+                }
+            }
+            else if (row.type === 'reasoning') {
+                if (!Array.isArray(row.summary) || !row.summary.every(part => object(part) && part.type === 'summary_text' && typeof part.text === 'string')) {
+                    throw new NativeInputError(`Unsupported Grok reasoning summary on line ${index + 1}.`);
+                }
+                const text = row.summary.map(part => part.text).join('\n');
+                if (text)
+                    rows.push({ type: 'event_msg', payload: { type: 'agent_reasoning', text } });
+            }
+            else if (row.type === 'tool_result') {
+                if (!safeNativeId(row.tool_call_id) || typeof row.content !== 'string')
+                    throw new NativeInputError('Invalid Grok tool result.');
+                response({ type: 'function_call_output', call_id: row.tool_call_id, output: row.content });
+            }
+            else
+                throw new NativeInputError(`Unsupported Grok native item on line ${index + 1}.`);
+        }
+    }
+    const canonical = normalizeToCanonical({
+        source: acp ? 'copilot-cli' : 'codex',
+        transcript: rows.map(row => JSON.stringify(row)).join('\n'),
+        sourceContext: { groupId: id, partial: true },
+        bounds: { toolArguments: { maxCharacters: null }, toolResults: { maxCharacters: null } },
+        filters: { systemMessages: 'include', toolResults: 'include' },
+    });
+    return {
+        ...canonical,
+        records: canonical.records.map(record => ({ ...record, source_type: 'grok-build' })),
+        diagnostics: [...canonical.diagnostics, ...diagnostics],
+    };
+}

package/dist/readers/guards.d.ts

@@ -0,0 +1,4 @@
+import type { Harness } from '../types.js';
+import type { FxNativeCompanions } from './fx.js';
+/** The upstream normalizer is an archive reader, not a native active-branch resolver. */
+export declare function assertPortableHistory(harness: Harness, raw: string, fxCompanions?: FxNativeCompanions): void;