@volter/supercode-interchange 0.1.22 → 0.1.24

package/session-transfer.mjs

@@ -0,0 +1,141 @@
+// Artifacts retain native source recovery and portable source segments. Only
+// export-to-Hermes invokes a vendor writer, through its own import command.
+import { readFile, lstat } from 'node:fs/promises';
+import { basename, dirname, extname, resolve } from 'node:path';
+import { cloneNativeJson } from './native-json.mjs';
+import { decodeSessionUtf8 } from './session-file.mjs';
+import { loadSessionLocator } from './session-path.mjs';
+import { toSessionJsonl, toSessionJsonlSpliced, toNativeJsonl } from './session-write.mjs';
+import { createResidueStore } from './session-residue-store.mjs';
+import { restoreResidue } from './session-residue.mjs';
+import { importIntoHermes } from './session-hermes-import.mjs';
+
+const targetFormats = Object.freeze({ 'claude-code': 'claude_code', codex: 'codex', opencode: 'opencode', pi: 'pi',
+  grok: 'grok', gemini: 'gemini', goose: 'goose', hermes: 'codex' });
+const invalid = message => { throw Object.assign(new Error(message), { rpcCode: -32602 }); };
+const object = (value, name) => {
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) invalid(`${name} must be an object`);
+  return value;
+};
+const string = (value, name) => { if (typeof value !== 'string') invalid(`${name} must be a string`); return value; };
+function struct(value, fields, name) {
+  if (!Array.isArray(value)) return object(value, name);
+  if (value.length !== fields.length) invalid(`${name} positional params require ${fields.join(', ')}`);
+  return Object.fromEntries(fields.map((field, index) => [field, value[index]]));
+}
+export function transferTarget(value) {
+  // Externally tagged unit variants also admit {"target-name": null}.
+  if (value != null && typeof value === 'object' && !Array.isArray(value)) {
+    const keys = Object.keys(value);
+    if (keys.length !== 1 || value[keys[0]] !== null) invalid('target_harness must be a transfer format');
+    value = keys[0];
+  }
+  const requested = string(value, 'target_harness'), target = requested === 'open-code' ? 'opencode' : requested;
+  if (!Object.hasOwn(targetFormats, target)) invalid(`unknown transfer target: ${requested}`);
+  return target;
+}
+
+export function parseTransferLocator(value) {
+  const supplied = struct(value, ['harness', 'session_id', 'storage'], 'locator'), storage = object(supplied.storage, 'locator.storage');
+  const locator = { harness: string(supplied.harness, 'locator.harness'), session_id: string(supplied.session_id, 'locator.session_id'),
+    storage: { kind: storage.kind, path: string(storage.path, 'locator.storage.path') } };
+  if (!['file', 'sqlite'].includes(storage.kind)) invalid('locator.storage.kind must be file or sqlite');
+  if (storage.kind === 'sqlite') locator.storage.selector = string(storage.selector, 'locator.storage.selector');
+  // Native service admission decodes a JSON Value, so unknown fields are
+  // ignored and repeated JSON members have already settled to their last value.
+  return locator;
+}
+
+export function parseSessionTransferParams(params) {
+  params = struct(params, ['locator', 'target_harness'], 'session transfer params');
+  return { locator: parseTransferLocator(params.locator), target: transferTarget(params.target_harness) };
+}
+
+export function sanitizeArtifactFilename(value) {
+  return [...value].map(char => /^[A-Za-z0-9_-]$/u.test(char) ? char : '-').join('').replace(/^-+|-+$/gu, '').slice(0, 100) || 'session';
+}
+const appended = session => session.imported_message_count != null && session.imported_message_count < session.messages.length;
+const verbatim = session => session.raw.join('\n') + (session.raw_trailing_newline ? '\n' : '');
+
+async function appendGrokBundle(locator, prefix, role, files, { cwd = process.cwd() } = {}) {
+  const primary = locator.storage.path;
+  if (basename(primary) !== 'chat_history.jsonl') throw new Error(`Grok bundle locator must name chat_history.jsonl, got ${primary}`);
+  for (const name of ['summary.json', 'updates.jsonl']) {
+    const path = resolve(cwd, dirname(primary), name); let metadata;
+    try { metadata = await lstat(path); } catch (error) { if (error.code === 'ENOENT') continue; throw error; }
+    if (metadata.isSymbolicLink() || !metadata.isFile()) throw new Error(`refusing non-regular Grok bundle member ${path}`);
+    let content;
+    try { content = decodeSessionUtf8(await readFile(path)); }
+    catch (error) { throw new Error(`Grok bundle member ${path} is not representable as UTF-8: ${error.message}`, { cause: error }); }
+    files.push({ path: prefix + name, content, role });
+  }
+}
+
+/** Construct the complete artifact; targetSessionId is the native handoff/fork hook. */
+export async function sessionArtifact(locator, session, target, context = {}, targetSessionId = null) {
+  const format = targetFormats[target]; if (format == null) throw new TypeError(`unknown transfer target: ${target}`);
+  const diagonal = format === session.meta.source, hasAppended = appended(session), store = createResidueStore(context);
+  await store.store(session);
+  let content, restoration = null;
+  if (targetSessionId != null) {
+    if (diagonal && format !== 'opencode') content = toSessionJsonlSpliced(session, format, targetSessionId);
+    else { const rewritten = cloneNativeJson(session); rewritten.meta.session_id = targetSessionId; content = toSessionJsonl(rewritten, format); }
+  } else if (diagonal && session.raw_is_verbatim && !hasAppended) content = verbatim(session);
+  else if (diagonal) content = toSessionJsonlSpliced(session, format);
+  else {
+    const restored = await restoreResidue(session, format, store.lookup);
+    if (restored == null) content = toSessionJsonl(session, format);
+    else { content = restored.content; restoration = restored.report; }
+  }
+  const stem = sanitizeArtifactFilename(targetSessionId ?? session.meta.session_id ?? locator.session_id);
+  const filename = diagonal && target === 'grok' ? 'chat_history.jsonl' : target === 'goose' ? `${stem}.goose.json` : `${stem}.${target}.jsonl`;
+  const files = [{ path: filename, content, role: 'primary' }];
+  if (target === 'claude-code') {
+    const bundleStem = basename(filename, extname(filename)), paths = new Set();
+    for (const [index, child] of session.subagents.entries()) {
+      const agentId = child.meta.agent_id == null ? `subagent-${index + 1}` : sanitizeArtifactFilename(child.meta.agent_id.replace(/^agent-/u, ''));
+      let childContent;
+      if (targetSessionId == null && child.meta.source === 'claude_code' && child.raw_is_verbatim && !appended(child)) childContent = verbatim(child);
+      else if (child.meta.source === 'claude_code') childContent = toSessionJsonlSpliced(child, 'claude_code', targetSessionId);
+      else {
+        const rewritten = cloneNativeJson(child); if (targetSessionId != null) rewritten.meta.session_id = targetSessionId;
+        childContent = toSessionJsonl(rewritten, 'claude_code');
+      }
+      const path = `${bundleStem}/subagents/agent-${agentId}.jsonl`;
+      if (paths.has(path)) throw new Error(`Claude subagent ids collide at artifact path \`${path}\``);
+      paths.add(path); files.push({ path, content: childContent, role: 'subagent' });
+    }
+  }
+  if (diagonal && target === 'grok') await appendGrokBundle(locator, '', 'bundle', files, context);
+  if (!diagonal || !session.raw_is_verbatim) {
+    files.push({ path: 'recovery/source.supercode.jsonl', content: toNativeJsonl(session), role: 'source_recovery' });
+    for (const [index, child] of session.subagents.entries()) {
+      const id = child.meta.agent_id == null ? `subagent-${index + 1}` : sanitizeArtifactFilename(child.meta.agent_id);
+      files.push({ path: `recovery/subagents/${id}.supercode.jsonl`, content: toNativeJsonl(child), role: 'source_recovery' });
+    }
+  }
+  if (!diagonal && session.meta.source === 'grok') await appendGrokBundle(locator, 'recovery/grok/', 'source_recovery', files, context);
+  let fidelity, residue;
+  if (diagonal && targetSessionId == null && session.raw_is_verbatim && !hasAppended) { fidelity = 'byte_lossless'; residue = []; }
+  else if (diagonal && !(targetSessionId != null && target === 'opencode')) {
+    fidelity = 'value_lossless'; residue = [targetSessionId != null
+      ? 'target identity was rewritten, so the artifact intentionally differs from source bytes'
+      : 'source storage was reconstructed as a native-value-equivalent export; original container bytes were not captured'];
+  } else if (restoration?.rendered_messages === 0) {
+    fidelity = 'byte_lossless'; residue = [`restored verbatim from this conversation's ${target} source records in the residue store`];
+  } else if (restoration != null) {
+    fidelity = 'semantic'; residue = [`${restoration.restored_messages} of ${restoration.restored_messages + restoration.rendered_messages} messages restored verbatim from the residue store; the other ${restoration.rendered_messages} written by the ${target} writer`];
+  } else { fidelity = 'semantic'; residue = ['target schema has no portable slot for every source-native record and metadata field']; }
+  return { source_harness: locator.harness, target_harness: target, session_id: targetSessionId ?? session.meta.session_id,
+    content, suggested_filename: filename, files, fidelity, residue };
+}
+
+export async function transferSession(params, { exporting = false, ...context } = {}) {
+  context.signal?.throwIfAborted();
+  const { locator, target } = parseSessionTransferParams(params);
+  const loaded = { ...locator, storage: { ...locator.storage, path: resolve(context.cwd ?? process.cwd(), locator.storage.path) } };
+  const session = await loadSessionLocator(loaded, { ...context, fidelity: 'byte_lossless', includeSubagents: true });
+  context.signal?.throwIfAborted();
+  const artifact = await sessionArtifact(locator, session, target, context);
+  return exporting && target === 'hermes' ? { artifact, imported: await importIntoHermes(session, context) } : { artifact };
+}

package/session-views.mjs

@@ -160,6 +160,7 @@ export function projectedSessionJson(session, options) {
   const childOptions = { ...options, message_limit: null, message_offset: null, message_tail: null };
   return {
     source: meta.source, session_id: meta.session_id, ended_at: meta.ended_at, end_reason: meta.end_reason, model: meta.model,
+    ...(meta.first_response ? { first_response: cloneNativeJson(meta.first_response) } : {}),
     resolved_profile: recordedSessionProfile(session), resolved_profile_history: recordedSessionProfileHistory(session),
     cwd: meta.cwd, system_prompt: meta.system_prompt, agent_id: meta.agent_id, parent_tool_use_id: meta.parent_tool_use_id,
     lineage: cloneNativeJson(meta.lineage), messages: session.messages.slice(offset, end).map((message) => projectInlineMedia(messageJson(message), options)),

package/session-write-claude.mjs

@@ -0,0 +1,135 @@
+import { nativeInteger } from './native-json.mjs';
+import { toolOutcome } from './message.mjs';
+import { nativeTrim } from './text.mjs';
+import { NATIVE_RESIDUE_KEY, NATIVE_RESIDUE_SUMMARY_KEY } from './session-native-residue.mjs';
+import { nativeResidueEnvelope, nativeResidueSummary } from './session-write-residue.mjs';
+import { SYNTH_TS, replayExcluded, sessionCwd, tryNativeJson, sourceMessageExtension, splicedPrefixLengths,
+  jsonLine, injectFirstJsonLine, synthUuid, messageTimestamp, parseDataUri, parsedJsonField } from './session-write-utils.mjs';
+
+function imageBlock(url) {
+  const data = parseDataUri(url);
+  return { type: 'image', source: data == null ? { type: 'url', url }
+    : { type: 'base64', media_type: data.mimeType, data: data.data } };
+}
+function imageBlocks(parts) {
+  return (parts ?? []).filter(part => part?.type === 'image_url' && typeof part?.image_url?.url === 'string')
+    .map(part => imageBlock(part.image_url.url));
+}
+
+function userContent(message) {
+  if (message.content_parts == null) return message.content ?? '';
+  const blocks = [];
+  for (const part of message.content_parts) {
+    if (part?.type === 'text' && typeof part.text === 'string' && part.text !== '') blocks.push({ type: 'text', text: part.text });
+    else if (part?.type === 'image_url' && typeof part?.image_url?.url === 'string') blocks.push(imageBlock(part.image_url.url));
+  }
+  return blocks;
+}
+function toolResultContent(message) {
+  if (!message.content_parts?.length) return message.content ?? '';
+  return [...(message.content ? [{ type: 'text', text: message.content }] : []), ...imageBlocks(message.content_parts)];
+}
+function assistantContent(message) {
+  const blocks = [], metadata = message.metadata, thinking = tryNativeJson(metadata.thinking_blocks);
+  if (Array.isArray(thinking)) blocks.push(...thinking);
+  else {
+    if (metadata.thinking != null) {
+      const block = { type: 'thinking', thinking: metadata.thinking };
+      if (metadata.thinking_signature != null) block.signature = metadata.thinking_signature;
+      blocks.push(block);
+    }
+    if (metadata.redacted_thinking != null) blocks.push({ type: 'redacted_thinking', data: metadata.redacted_thinking });
+  }
+  if (message.content) blocks.push({ type: 'text', text: message.content });
+  blocks.push(...imageBlocks(message.content_parts));
+  for (const call of message.tool_calls ?? []) {
+    const block = { type: 'tool_use', id: call.id, name: call.function.name }, args = nativeTrim(call.function.arguments);
+    if (args === '') block.input = {}; else parsedJsonField(block, 'input', args, {});
+    blocks.push(block);
+  }
+  return blocks;
+}
+
+function claudeRecords(session, messages, sessionId, cwd, parent = null, seedIds = new Set()) {
+  const used = new Set(seedIds); let counter = 1n, text = '';
+  const messageUuid = message => {
+    for (const key of ['claude_uuid', 'supercode_native_uuid']) {
+      const candidate = message.metadata[key];
+      if (candidate && !used.has(candidate)) { used.add(candidate); return candidate; }
+    }
+    for (;;) {
+      const candidate = synthUuid(counter++);
+      if (!used.has(candidate)) { used.add(candidate); return candidate; }
+    }
+  };
+  for (const message of messages) {
+    if (replayExcluded(message)) continue;
+    let value, uuid;
+    if (message.role === 'system') {
+      const content = message.content ?? ''; if (!nativeTrim(content)) continue;
+      uuid = messageUuid(message);
+      value = { parentUuid: parent, type: 'system', subtype: message.metadata.systemSubtype ?? 'local_command', content,
+        uuid, sessionId, cwd, timestamp: messageTimestamp(message) };
+    } else {
+      uuid = messageUuid(message);
+      let native;
+      switch (message.role) {
+        case 'user': native = { role: 'user', content: userContent(message) }; break;
+        case 'tool': native = { role: 'user', content: [{ type: 'tool_result', tool_use_id: message.tool_call_id ?? '',
+          content: toolResultContent(message) }] }; break;
+        case 'assistant':
+          native = { role: 'assistant', content: assistantContent(message) };
+          if (message.metadata.model != null || session.meta.model != null) native.model = message.metadata.model ?? session.meta.model;
+          break;
+        default: throw new TypeError(`unknown message role: ${message.role}`);
+      }
+      value = { parentUuid: parent, type: message.role === 'assistant' ? 'assistant' : 'user', message: native,
+        uuid, sessionId, cwd, timestamp: messageTimestamp(message) };
+      if (message.role === 'tool' && toolOutcome(message) === 'unknown') value._supercode_tool_outcome = 'unknown';
+    }
+    sourceMessageExtension(value, session.meta.source, message); text += jsonLine(value); parent = uuid;
+  }
+  return text;
+}
+
+function residueLine(raw, sessionId, cwd) {
+  const value = tryNativeJson(raw);
+  if (value == null || typeof value !== 'object' || Array.isArray(value)) return raw;
+  let changed = false;
+  for (const [key, current] of [['sessionId', sessionId], ['cwd', cwd]]) {
+    if (typeof value[key] === 'string' && value[key] !== current) { value[key] = current; changed = true; }
+  }
+  return changed ? jsonLine(value).slice(0, -1) : raw;
+}
+
+export function toClaudeCodeJsonl(session) {
+  const sessionId = session.meta.session_id ?? synthUuid(0), cwd = sessionCwd(session);
+  let text = session.meta.lineage.claude_fork_context_ref_raw == null ? '' : session.meta.lineage.claude_fork_context_ref_raw + '\n';
+  text += claudeRecords(session, session.messages, sessionId, cwd);
+  if (session.meta.native_residue_source === 'claude_code') {
+    const at = entry => nativeInteger(entry, 'record_index') ?? ((1n << 64n) - 1n);
+    const records = [...session.meta.native_residue].sort((left, right) => at(left) < at(right) ? -1 : at(left) > at(right) ? 1 : 0);
+    for (const entry of records) if (typeof entry?.raw === 'string') text += residueLine(entry.raw, sessionId, cwd) + '\n';
+  } else {
+    const envelope = nativeResidueEnvelope(session.meta);
+    if (envelope != null) {
+      if (!text) text = jsonLine({ type: 'file-history-snapshot', messageId: synthUuid(1), snapshot: {}, sessionId, cwd, timestamp: SYNTH_TS });
+      text = injectFirstJsonLine(text, NATIVE_RESIDUE_SUMMARY_KEY, nativeResidueSummary(envelope));
+      text = injectFirstJsonLine(text, NATIVE_RESIDUE_KEY, envelope);
+    }
+  }
+  return text;
+}
+
+export function toClaudeCodeJsonlSpliced(session, sessionId = null) {
+  const prefix = splicedPrefixLengths(session), used = new Set(); let text = '', parent = null;
+  for (const line of session.raw.slice(0, prefix.raw)) {
+    const value = tryNativeJson(line);
+    if (sessionId != null && value != null && typeof value === 'object' && !Array.isArray(value) && Object.hasOwn(value, 'sessionId')) {
+      value.sessionId = sessionId; text += jsonLine(value);
+    } else text += line + '\n';
+    if (typeof value?.uuid === 'string') { parent = value.uuid; used.add(value.uuid); }
+  }
+  return text + claudeRecords(session, session.messages.slice(prefix.messages), sessionId ?? session.meta.session_id ?? synthUuid(0),
+    sessionCwd(session), parent, used);
+}

package/session-write-codex.mjs

@@ -0,0 +1,146 @@
+import { cloneNativeJson, nativeInteger, setNativeInteger } from './native-json.mjs';
+import emitterVersion from './session-emission-version.json' with { type: 'json' };
+import { nativeTrim } from './text.mjs';
+import { NATIVE_RESIDUE_KEY, NATIVE_RESIDUE_SUMMARY_KEY } from './session-native-residue.mjs';
+import { nativeResidueEnvelope, nativeResidueSummary } from './session-write-residue.mjs';
+import { SYNTH_TS, replayExcluded, sessionCwd, tryNativeJson, sourceMessageExtension, splicedPrefixLengths,
+  jsonLine, synthUuid, messageTimestamp, parsedJsonField } from './session-write-utils.mjs';
+
+function synthesizedHeader(session) {
+  const payload = { id: session.meta.session_id ?? synthUuid(0), timestamp: SYNTH_TS, cwd: sessionCwd(session),
+    originator: 'supercode', cli_version: emitterVersion, source: 'exec', thread_source: 'user', model_provider: 'openai' };
+  if (session.meta.system_prompt != null) payload.base_instructions = { text: session.meta.system_prompt };
+  if (session.meta.lineage.claude_fork_context_ref_raw != null) parsedJsonField(payload, 'claude_fork_context_ref', session.meta.lineage.claude_fork_context_ref_raw);
+  let text = jsonLine({ timestamp: SYNTH_TS, type: 'session_meta', payload });
+  if (session.meta.model != null) text += jsonLine({ timestamp: SYNTH_TS, type: 'turn_context',
+    payload: { model: session.meta.model, cwd: sessionCwd(session) } });
+  return text;
+}
+
+function messageContent(textType, message) {
+  if (message.content_parts == null) return [{ type: textType, text: message.content ?? '' }];
+  const content = [];
+  for (const part of message.content_parts) {
+    if (part?.type === 'text' && typeof part.text === 'string' && part.text !== '') content.push({ type: textType, text: part.text });
+    else if (part?.type === 'image_url' && typeof part?.image_url?.url === 'string') content.push({ type: 'input_image', image_url: part.image_url.url });
+  }
+  return content;
+}
+function toolOutput(message) {
+  const content = message.content ?? '';
+  const images = (message.content_parts ?? []).filter(part => part?.type === 'image_url')
+    .map(part => part?.image_url?.url).filter(url => typeof url === 'string');
+  return !images.length ? content : [...(content ? [{ type: 'input_text', text: content }] : []),
+    ...images.map(image_url => ({ type: 'input_image', image_url }))];
+}
+
+function codexRecords(session, messages, seedIds = new Set()) {
+  const used = new Set(seedIds), searchCalls = new Set(); let nextGroup = 0n, text = '';
+  const emit = (payload, message) => {
+    sourceMessageExtension(payload, session.meta.source, message);
+    text += jsonLine({ timestamp: messageTimestamp(message), type: 'response_item', payload });
+  };
+  const withTurn = (payload, turnId) => { if (turnId != null) payload.metadata = { turn_id: turnId }; return payload; };
+  const emitMessage = (message, role, textType, turnId, subtype = null) => {
+    const payload = withTurn({ type: 'message', role, content: messageContent(textType, message) }, turnId);
+    if (subtype != null) { payload.metadata ??= {}; payload.metadata.claude_system_subtype = subtype; }
+    emit(payload, message);
+  };
+  for (const message of messages) {
+    if (replayExcluded(message)) continue;
+    const realTurn = message.metadata.turn_id;
+    switch (message.role) {
+      case 'system': emitMessage(message, 'developer', 'input_text', realTurn, message.metadata.systemSubtype); break;
+      case 'user': emitMessage(message, 'user', 'input_text', realTurn); break;
+      case 'assistant': {
+        const calls = message.tool_calls ?? [];
+        let group = realTurn ?? null;
+        if (group != null && used.has(group)) {
+          let duplicate = 1n; while (used.has(`${realTurn}~dup${duplicate}`)) duplicate++;
+          group = `${realTurn}~dup${duplicate}`;
+        } else if (group == null && calls.length) {
+          do { group = `sc-grp-${nextGroup++}`; } while (used.has(group));
+        }
+        if (group != null) used.add(group);
+        if (message.content || message.content_parts != null || Object.hasOwn(message.metadata, 'empty_assistant_record')) {
+          emitMessage(message, 'assistant', 'output_text', group);
+        }
+        const custom = tryNativeJson(message.metadata.codex_custom_tool_call_ids);
+        const customIds = Array.isArray(custom) && custom.every(id => typeof id === 'string') ? custom : [];
+        for (const call of calls) {
+          let payload;
+          if (customIds.includes(call.id)) {
+            payload = { type: 'custom_tool_call', name: call.function.name };
+            const args = nativeTrim(call.function.arguments);
+            if (args === '') payload.input = {}; else parsedJsonField(payload, 'input', args, call.function.arguments);
+            payload.call_id = call.id;
+          } else if (call.function.name === 'tool_search') {
+            searchCalls.add(call.id);
+            payload = { type: 'tool_search_call', arguments: call.function.arguments, call_id: call.id };
+          } else payload = { type: 'function_call', name: call.function.name, arguments: call.function.arguments, call_id: call.id };
+          emit(withTurn(payload, group), message);
+        }
+        break;
+      }
+      case 'tool': {
+        let payload;
+        if (message.tool_call_id != null && searchCalls.has(message.tool_call_id)) {
+          payload = { type: 'tool_search_output', call_id: message.tool_call_id };
+          parsedJsonField(payload, 'tools', message.content ?? '');
+        } else payload = { type: 'function_call_output', call_id: message.tool_call_id ?? '', output: toolOutput(message) };
+        emit(payload, message); break;
+      }
+      default: throw new TypeError(`unknown message role: ${message.role}`);
+    }
+  }
+  return text;
+}
+
+function patchSessionMeta(value, id) {
+  if (value?.type !== 'session_meta' || !Object.hasOwn(value, 'payload')) return;
+  if (value.payload === null) value.payload = {};
+  if (typeof value.payload !== 'object' || Array.isArray(value.payload)) throw new Error('Codex session_meta payload is not an object');
+  value.payload.id = id;
+}
+
+export function toCodexJsonl(session) {
+  let text;
+  if (!session.meta.codex_headers.length) text = synthesizedHeader(session);
+  else text = session.meta.codex_headers.map(original => {
+    const header = cloneNativeJson(original);
+    if (session.meta.session_id != null) patchSessionMeta(header, session.meta.session_id);
+    return jsonLine(header);
+  }).join('');
+  text += codexRecords(session, session.messages);
+  const envelope = nativeResidueEnvelope(session.meta), end = text.indexOf('\n');
+  if (envelope != null && end >= 0) {
+    const record = tryNativeJson(text.slice(0, end));
+    if (record?.type === 'session_meta' && record.payload != null && typeof record.payload === 'object' && !Array.isArray(record.payload)) {
+      record.payload[NATIVE_RESIDUE_SUMMARY_KEY] = nativeResidueSummary(envelope); record.payload[NATIVE_RESIDUE_KEY] = envelope;
+      text = jsonLine(record) + text.slice(end + 1);
+    }
+  }
+  return text;
+}
+
+export function toCodexJsonlSpliced(session, sessionId = null) {
+  const prefix = splicedPrefixLengths(session), used = new Set(); let text = '', ordinal = null;
+  for (const line of session.raw.slice(0, prefix.raw)) {
+    const value = tryNativeJson(line);
+    if (sessionId != null && value?.type === 'session_meta') { patchSessionMeta(value, sessionId); text += jsonLine(value); }
+    else text += line + '\n';
+    const turnId = value?.payload?.metadata?.turn_id;
+    if (typeof turnId === 'string') used.add(turnId);
+    const recordedOrdinal = nativeInteger(value, 'ordinal'); if (recordedOrdinal != null) ordinal = recordedOrdinal;
+  }
+  for (const message of session.messages.slice(0, prefix.messages)) if (message.metadata.turn_id != null) used.add(message.metadata.turn_id);
+  const tail = codexRecords(session, session.messages.slice(prefix.messages), used);
+  if (ordinal == null) return text + tail;
+  for (const line of tail.split('\n').slice(0, -1)) {
+    const record = tryNativeJson(line);
+    if (record != null && typeof record === 'object' && !Array.isArray(record)) {
+      ordinal = BigInt.asUintN(64, ordinal + 1n); setNativeInteger(record, 'ordinal', ordinal); text += jsonLine(record);
+    } else text += line + '\n';
+  }
+  return text;
+}

package/session-write-gemini.mjs

@@ -0,0 +1,77 @@
+import { stringifyNativeJson } from './native-json.mjs';
+import { SYNTH_TS, replayExcluded, tryNativeJson, parsedJsonField, messageEnvelope, splicedPrefixLengths, jsonLine, inlineDataUrl } from './session-write-utils.mjs';
+
+function header(session, sessionId) {
+  return jsonLine({ sessionId: sessionId ?? 'supercode-gemini-session',
+    projectHash: session.meta.lineage.gemini_project_hash ?? 'supercode',
+    startTime: session.meta.lineage.created_at ?? SYNTH_TS, lastUpdated: session.meta.lineage.updated_at ?? SYNTH_TS,
+    kind: session.meta.lineage.gemini_session_kind ?? 'main' });
+}
+
+function geminiRecords(session, messages) {
+  let text = ''; const names = new Map();
+  for (const [index, message] of messages.entries()) {
+    if (replayExcluded(message)) continue;
+    const timestamp = message.metadata.timestamp ?? SYNTH_TS;
+    let value;
+    switch (message.role) {
+      case 'system': case 'user': {
+        const parts = [];
+        const collected = (message.content_parts ?? []).map(part => part?.text).filter(part => typeof part === 'string').join(' ');
+        const content = message.content ?? (collected ? collected : null);
+        if (content != null) parts.push({ text: message.role === 'system' ? `[System] ${content}` : content });
+        for (const part of message.content_parts ?? []) {
+          const data = inlineDataUrl(part); if (data != null) parts.push({ inlineData: data });
+        }
+        if (!parts.length) continue;
+        value = { id: `supercode-user-${index}`, timestamp, type: 'user', content: parts };
+        break;
+      }
+      case 'assistant': {
+        const calls = (message.tool_calls ?? []).map(call => {
+          names.set(call.id, call.function.name);
+          const value = { id: call.id, name: call.function.name };
+          parsedJsonField(value, 'args', call.function.arguments); return value;
+        });
+        value = { id: `supercode-gemini-${index}`, timestamp, type: 'gemini', content: message.content ?? '',
+          model: message.metadata.gemini_model ?? session.meta.model ?? 'unknown' };
+        if (calls.length) value.toolCalls = calls;
+        const thoughts = message.metadata.gemini_thoughts;
+        if (thoughts != null) parsedJsonField(value, 'thoughts', thoughts);
+        break;
+      }
+      case 'tool': {
+        const id = message.tool_call_id ?? '', name = message.name ?? names.get(id) ?? 'tool';
+        const output = message.content ?? (message.content_parts == null ? '' : stringifyNativeJson(message.content_parts));
+        value = { id: `supercode-tool-${index}`, timestamp, type: 'user', content: [{
+          functionResponse: { id, name, response: { output } },
+        }] };
+        break;
+      }
+      default: throw new TypeError(`unknown message role: ${message.role}`);
+    }
+    value._supercode_gemini_message = messageEnvelope(message, 1); text += jsonLine(value);
+  }
+  return text;
+}
+
+export function toGeminiJsonl(session) {
+  return header(session, session.meta.session_id) + geminiRecords(session, session.messages)
+    + jsonLine({ $set: { lastUpdated: SYNTH_TS } });
+}
+
+export function toGeminiJsonlSpliced(session, sessionId = null) {
+  const prefix = splicedPrefixLengths(session);
+  if (!prefix.raw) return header(session, sessionId ?? session.meta.session_id) + geminiRecords(session, session.messages);
+  let text = '';
+  for (const [index, line] of session.raw.slice(0, prefix.raw).entries()) {
+    if (!index && sessionId != null) {
+      const value = tryNativeJson(line);
+      if (value != null && typeof value === 'object' && !Array.isArray(value) && !Object.hasOwn(value, 'type') && Object.hasOwn(value, 'sessionId')) {
+        value.sessionId = sessionId; text += jsonLine(value); continue;
+      }
+    }
+    text += line + '\n';
+  }
+  return text + geminiRecords(session, session.messages.slice(prefix.messages));
+}

package/session-write-goose.mjs

@@ -0,0 +1,99 @@
+import { cloneNativeJson, setNativeInteger, stringifyNativeJson, stringifyNativeJsonPretty } from './native-json.mjs';
+import { rawVerbatim } from './session-model.mjs';
+import { isToolError } from './message.mjs';
+import { SYNTH_TS, SYNTH_TS_MS, replayExcluded, sessionCwd, tryNativeJson, metadataI64, targetMessageExtension, parsedJsonField } from './session-write-utils.mjs';
+
+function gooseConversation(messages) {
+  const result = [], names = new Map(); let lastNativeIndex = null;
+  for (const [index, message] of messages.entries()) {
+    if (replayExcluded(message)) continue;
+    const nativeIndex = message.metadata.goose_native_index;
+    if (nativeIndex != null) {
+      if (lastNativeIndex === nativeIndex) continue;
+      lastNativeIndex = nativeIndex;
+      const native = tryNativeJson(message.metadata.goose_native_message);
+      if (native !== undefined) { result.push(native); continue; }
+    } else lastNativeIndex = null;
+    for (const call of message.tool_calls ?? []) names.set(call.id, call.function.name);
+    const created = metadataI64(message.metadata.goose_created) ?? SYNTH_TS_MS / 1000n + BigInt(index);
+    const role = message.role === 'assistant' ? 'assistant' : 'user', content = [];
+    if (message.role !== 'tool') {
+      if (message.content != null) content.push({ type: 'text', text: message.role === 'system' ? `[System] ${message.content}` : message.content });
+      for (const part of message.content_parts ?? []) {
+        if (typeof part?.text === 'string' && message.content == null) content.push({ type: 'text', text: part.text });
+        const url = part?.image_url?.url;
+        if (typeof url !== 'string' || !url.startsWith('data:')) continue;
+        const separator = url.indexOf(';base64,', 5);
+        if (separator < 0) continue;
+        content.push({ type: 'image', data: url.slice(separator + 8), mimeType: url.slice(5, separator) });
+      }
+    }
+    for (const call of message.tool_calls ?? []) {
+      const value = { name: call.function.name };
+      parsedJsonField(value, 'arguments', call.function.arguments);
+      content.push({ type: 'toolRequest', id: call.id, toolCall: { status: 'success',
+        value } });
+    }
+    if (message.role === 'tool') {
+      const id = message.tool_call_id ?? '';
+      const output = message.content ?? (message.content_parts == null ? '' : stringifyNativeJson(message.content_parts));
+      const toolResult = isToolError(message) ? { status: 'error', error: output }
+        : { status: 'success', value: { content: [{ type: 'text', text: output }], isError: false } };
+      content.push({ type: 'toolResponse', id, toolResult, metadata: { toolName: message.name ?? names.get(id) ?? null } });
+    }
+    if (!content.length) continue;
+    const native = { id: message.metadata.goose_message_id ?? `supercode-goose-${index}`, role, created: 0,
+      content };
+    parsedJsonField(native, 'metadata', message.metadata.goose_metadata, { userVisible: true, agentVisible: true });
+    setNativeInteger(native, 'created', created); targetMessageExtension(native, message); result.push(native);
+  }
+  return result;
+}
+
+function synthesizedGooseDocument(session, sessionId, messages) {
+  let document = session.meta.goose_header == null ? undefined : cloneNativeJson(session.meta.goose_header);
+  if (document === undefined) for (const message of session.messages) {
+    const header = tryNativeJson(message.metadata.goose_session_header);
+    if (header !== undefined) { document = header; break; }
+  }
+  if (document === undefined) document = {
+    id: 'supercode-goose-session', working_dir: sessionCwd(session), name: 'supercode export', user_set_name: false,
+    session_type: 'user', created_at: SYNTH_TS, updated_at: SYNTH_TS, extension_data: {}, usage: {}, accumulated_usage: {},
+    accumulated_cost: null, schedule_id: null, recipe: null, user_recipe_values: null, message_count: 0,
+    last_message_at: null, provider_name: null, model_config: null, goose_mode: 'auto', archived_at: null,
+    project_id: null, parent_session_id: null, last_message_snippet: null,
+  };
+  if (document === null) document = {};
+  if (typeof document !== 'object' || Array.isArray(document)) throw new Error('Goose session header is not an object');
+  document.id = sessionId ?? session.meta.session_id ?? 'supercode-goose-session'; document.working_dir = sessionCwd(session);
+  const conversation = gooseConversation(messages);
+  setNativeInteger(document, 'message_count', BigInt(conversation.length)); document.conversation = conversation;
+  return stringifyNativeJsonPretty(document);
+}
+
+/** Unchanged native Goose documents retain every original byte. */
+export function toGooseJson(session) {
+  if (session.meta.source === 'goose' && session.raw.length && session.imported_message_count === session.messages.length) return rawVerbatim(session);
+  return synthesizedGooseDocument(session, null, session.messages);
+}
+
+export function toGooseJsonSpliced(session, sessionId = null) {
+  const prefix = Math.min(session.imported_message_count ?? session.messages.length, session.messages.length);
+  if (session.meta.source === 'goose' && session.raw.length) {
+    if (sessionId == null && prefix === session.messages.length) return rawVerbatim(session);
+    let document = tryNativeJson(rawVerbatim(session));
+    if (document !== undefined) {
+      if (sessionId != null) {
+        if (document === null) document = {};
+        if (typeof document !== 'object' || Array.isArray(document)) throw new Error('Goose session document is not an object');
+        document.id = sessionId;
+      }
+      const appended = gooseConversation(session.messages.slice(prefix));
+      if (Array.isArray(document?.conversation)) {
+        document.conversation.push(...appended); setNativeInteger(document, 'message_count', BigInt(document.conversation.length));
+      }
+      return stringifyNativeJsonPretty(document);
+    }
+  }
+  return synthesizedGooseDocument(session, sessionId, session.messages);
+}