@volter/supercode-interchange 0.1.1 → 0.1.3

package/README.md

@@ -7,6 +7,94 @@ The port branch routes discovery and index windows through this library and the
 cover selected small homes; publication, all-format and large-home qualification remain open.
 Full session translation codecs remain at their later boundary.
 
+The `./session-model` subpath supplies the step-5 read service's typed message
+and retained-session representation, native raw-line framing, normalized views,
+projected message windows, inline-media elision and recorded profile history.
+Source metadata is separate from provider-facing message serialization. Bounding
+a display view keeps its raw records and imported count; a view is not an export
+or a continuation artifact. The port branch's public load/follow handlers now
+use these readers through caller-owned worker lanes; shared Rust models remain for
+the native consumers named in the architecture plan. No runtime qualification
+is claimed for these new helpers.
+
+The read-codec slice has named document and store readers in
+`./session-codecs`. They preserve raw text, native
+message extensions, tool pairing and source metadata; the Goose store read
+uses one read-only DB/WAL snapshot and refuses a changed source. They do not
+own a native parsing process. The `./session-read` service selects a structural
+reader and never falls back to Rust. These readers
+have source and syntax checks only, with no runtime
+qualification claimed.
+Hermes selects only native active rows for replay while retaining inactive rows
+in its reconstructed raw container. Its lineage, trigger, surface and profile
+interpretation is shared with the metadata reader; recorded lifecycle and
+message timestamps retain their separate native rounding rules. No Hermes
+write tier is introduced.
+Grok separates user/system envelopes, assistant tools and screenshot results
+from raw reasoning/backend records. Its portable residue is verified using the
+existing BLAKE3 digest contract before restoration; missing-record summaries
+name the lost residue. Path/summary overlays belong to the read service slice.
+Claude selects its active graph branch and compacted history before decoding
+messages, retaining exact reasoning blocks, tool outcomes, media and creating
+record provenance. Semantic views name disconnected or degraded graph segments;
+strict reads refuse a reconstruction they cannot establish. Its file reader
+attaches native subagent transcripts and verifies the main and child file
+identities. Its scoped index retains graph references and ordering/count
+skeletons while materializing only requested assistant groups and summary
+messages. The file handle closes before the result leaves the scope. The
+public read/follow handoff has source and syntax checks only, with no runtime
+qualification claimed yet.
+Codex has separate model-context and bounded display-history readers. The
+model reader retains compaction replacement, turn grouping, reasoning and
+native typed-input pairing; the display reader projects durable TurnItems or
+legacy typed events with human-boundary anchors. Context and hook classification
+is shared between both. Hook XML is parsed by the pinned `saxes` dependency;
+source checks do not establish XML or display runtime parity. These additions
+are used by the public load/follow path on this port branch.
+Pi's active parent chain retains compaction flags, native signatures and
+message clocks, custom messages and source-native entry ids. Its OpenClaw
+dialect follows recorded leaf redirects, excludes side appends from default
+leaf selection and keeps vendor references inert. Unknown Pi image shapes
+remain raw-only, following the existing reader's refusal to synthesize image
+data it cannot establish. These are read-library additions, with no new
+OpenClaw write tier or runtime qualification.
+OpenCode's envelope and export-document readers share creation/id ordering,
+compaction boundaries, portable message extensions and task-child provenance.
+Completed tool parts split into calls/results, retaining masked original output
+and attachment content. Its SQLite reader reconstructs native columns, reads
+the external revert sidecar and verifies both identities; malformed JSON columns
+remain diagnostic. Legacy JSON-tree directories retain their native
+unsupported-source refusal. No runtime qualification is claimed for this
+checkpoint.
+The path layer selects formats structurally, pins native store selectors and
+reads compressed transcripts through Node's zstd support. Native sidecars
+validate framing and retain malformed appended turns as raw parse loss.
+Grok summaries and OpenClaw path profiles keep their source meanings. Display
+reads retain the native byte-window, human-anchor and fixed-byte-anchor rules;
+those bounded views remain unsuitable as continuation artifacts. Public
+load/follow uses `./session-read` on this branch. Its TypeScript follower pins
+the store selector, compares filesystem identities and reports snapshot,
+append, rewrite and recoverable-error events. Cold follower opening performs
+one selection read followed by a fingerprint-bracketed pinned read. Changed
+full-history Claude files can reuse a conservative append projection after
+comparing every old prefix byte. Partial, tool, branch, assistant-chunk and
+companion changes retain the canonical full loader. This optimization has
+source/syntax checks only, with no runtime qualification yet.
+
+The npm stdio router and the machine's harness streams use caller-owned load
+and follow worker lanes from `@volter/supercode-teams/session-read-client`.
+Large parsing jobs do not run on their routing thread. Each stream owns its
+subscriptions; response admission precedes activation, and close terminates
+its workers. The machine rechecks operator authority before content leaves
+an asynchronous read. Runtime-state events use authenticated loopback
+`frontend.v2.describe` with an `observe` narrowing header, not transcript
+activity. This read-only probe does not retire runtime receipts; the retained
+registry owns that behavior until its later replacement. No Windows caller
+authority implementation or runtime qualification is implied by this slice.
+The SDK checks the read capability before moved requests; an older service
+refuses explicitly instead of supplying a native read. Its catalog and other
+retained operations remain independently available on the same client.
+
 `resolveHarnessHomes` follows native HOME-first defaults and preserves explicitly empty harness-specific
 home values. `projectMetadata` applies workspace scope, native lineage, repository-family, profile, time and
 metadata-search filters with stable newest-first ordering. It clones raw rows before descendant roll-up.

package/hermes-store.mjs

@@ -37,8 +37,8 @@ function nouns(row, relationship, config, extended) {
   const source = nonempty(row.source) ?? '';
   let trigger = relationship === 'delegate' ? 'parent' : sourceTrigger(source);
   let recurrence = null;
-  const cron = /^cron_(.+)_([0-9]{8})_([0-9]{6})$/.exec(row.id);
-  if (cron) { trigger = 'cron'; recurrence = { job_id: cron[1], kind: 'cron' }; }
+  const cron = /^cron_(.+)_([0-9]{8})_([0-9]{6})$/s.exec(row.id);
+  if (cron?.[0].length === row.id.length) { trigger = 'cron'; recurrence = { job_id: cron[1], kind: 'cron' }; }
   recurrence ??= mirrorRecurrence(config);
   let surface = {}, profile = null;
   if (extended) {
@@ -66,6 +66,9 @@ function nouns(row, relationship, config, extended) {
     ...(state != null ? { cross_surface: { state, ...(platform != null ? { platform } : {}), ...(error != null ? { error } : {}) } } : {}) };
 }
 
+// Transcript and metadata readers share these native row interpretations.
+export { lineage as hermesLineageKind, nouns as hermesSessionNouns };
+
 export async function readHermesStore(path, { metrics = {} } = {}) {
   return readStore(path, (db) => {
     statement(db, 'SELECT count(*) FROM sessions').get();

package/message.mjs

@@ -0,0 +1,85 @@
+// Provider-neutral messages. Source provenance lives beside the provider wire
+// fields; serialization to a model never sends it as another instruction.
+import { cloneNativeJson, parseNativeJson, stringifyNativeJsonMember } from './native-json.mjs';
+import { nativeTrim } from './text.mjs';
+
+export const ROLES = Object.freeze(['system', 'user', 'assistant', 'tool']);
+export const TOOL_ERROR_METADATA_KEY = 'sc.tool_error';
+export const TOOL_OUTCOME_UNKNOWN_METADATA_KEY = 'sc.tool_outcome_unknown';
+
+const object = (value) => value != null && typeof value === 'object' && !Array.isArray(value);
+const invalid = (field) => { throw new TypeError(`invalid canonical message: ${field}`); };
+const optionalString = (value, key) => {
+  if (value[key] == null) return null;
+  if (typeof value[key] !== 'string') invalid(`${key} must be a string`);
+  return value[key];
+};
+
+/** Internal representation: null and an explicitly empty array are distinct. */
+export function createMessage(role, content = null) {
+  if (!ROLES.includes(role)) invalid('role must be system, user, assistant or tool');
+  if (content !== null && typeof content !== 'string') invalid('text content must be a string');
+  return { role, content, content_parts: null, tool_calls: null, tool_call_id: null, name: null, metadata: Object.create(null) };
+}
+
+/** The provider-shaped decoder deliberately ignores metadata, as ChatMessage's
+ * Deserialize implementation does. Native-turn readers restore it separately. */
+export function deserializeMessage(value) {
+  if (!object(value)) invalid('expected an object');
+  const message = createMessage(value.role);
+  if (typeof value.content === 'string') message.content = value.content;
+  else if (Array.isArray(value.content)) message.content_parts = cloneNativeJson(value.content);
+  else if (value.content != null) message.content = stringifyNativeJsonMember(value, 'content');
+  message.tool_call_id = optionalString(value, 'tool_call_id');
+  message.name = optionalString(value, 'name');
+  if (value.tool_calls != null) {
+    if (!Array.isArray(value.tool_calls)) invalid('tool_calls must be an array');
+    message.tool_calls = value.tool_calls.map((call) => {
+      if (!object(call) || typeof call.id !== 'string') invalid('tool call id must be a string');
+      const kind = Object.hasOwn(call, 'type') ? call.type : 'function';
+      if (typeof kind !== 'string') invalid('tool call type must be a string');
+      if (!object(call.function) || typeof call.function.name !== 'string' || typeof call.function.arguments !== 'string') {
+        invalid('tool call function needs string name and arguments');
+      }
+      return { id: call.id, type: kind, function: { name: call.function.name, arguments: call.function.arguments } };
+    });
+  }
+  return message;
+}
+
+/** Model-facing serialization, omitting absent fields and source metadata. */
+export function messageWire(message) {
+  const value = { role: message.role };
+  if (message.content_parts != null) value.content = cloneNativeJson(message.content_parts);
+  else if (message.content != null) value.content = message.content;
+  if (message.tool_calls != null) value.tool_calls = cloneNativeJson(message.tool_calls);
+  if (message.tool_call_id != null) value.tool_call_id = message.tool_call_id;
+  if (message.name != null) value.name = message.name;
+  return value;
+}
+
+/** Session-read serialization adds the complete source provenance map. */
+export function messageJson(message) {
+  return { ...messageWire(message), metadata: cloneNativeJson(message.metadata) };
+}
+
+export function parsedArguments(call) {
+  const text = nativeTrim(call.function.arguments);
+  return text === '' ? {} : parseNativeJson(text);
+}
+
+export function markToolError(message) {
+  delete message.metadata[TOOL_OUTCOME_UNKNOWN_METADATA_KEY];
+  message.metadata[TOOL_ERROR_METADATA_KEY] = 'true';
+}
+
+export function markToolOutcomeUnknown(message) {
+  delete message.metadata[TOOL_ERROR_METADATA_KEY];
+  message.metadata[TOOL_OUTCOME_UNKNOWN_METADATA_KEY] = 'true';
+}
+
+export function isToolError(message) { return message.metadata[TOOL_ERROR_METADATA_KEY] === 'true'; }
+export function toolOutcome(message) {
+  if (isToolError(message)) return 'known_error';
+  return message.metadata[TOOL_OUTCOME_UNKNOWN_METADATA_KEY] === 'true' ? 'unknown' : 'known_success';
+}

package/native-json.mjs

@@ -123,7 +123,25 @@ export function parseNativeJson(text) {
   return result.value;
 }
 
-export function nativeObjectKeys(value) { return facts.get(value)?.keys ?? Object.keys(value); }
+export function nativeObjectKeys(value) {
+  const keys = facts.get(value)?.keys;
+  if (!keys) return Object.keys(value);
+  const known = new Set(keys);
+  return [...keys.filter((key) => Object.hasOwn(value, key)), ...Object.keys(value).filter((key) => !known.has(key))];
+}
+
+// Transcript projections clone JSON before bounding strings or eliding media.
+// Keep the source's numeric tokens and insertion order with those values.
+export function cloneNativeJson(value) {
+  if (value == null || typeof value !== 'object') return value;
+  const result = Array.isArray(value) ? [] : Object.create(Object.getPrototypeOf(value) === null ? null : Object.prototype);
+  for (const key of nativeObjectKeys(value)) {
+    Object.defineProperty(result, key, { value: cloneNativeJson(value[key]), enumerable: true, writable: true, configurable: true });
+  }
+  const meta = facts.get(value);
+  if (meta) facts.set(result, { keys: [...meta.keys], numbers: new Map(meta.numbers) });
+  return result;
+}
 
 export function nativeInteger(value, key, { signed = false } = {}) {
   if (value == null || typeof value !== 'object') return null;
@@ -132,6 +150,30 @@ export function nativeInteger(value, key, { signed = false } = {}) {
   const whole = fact.integer;
   return whole >= (signed ? intMin : 0n) && whole <= (signed ? intMax : uintMax) ? whole : null;
 }
+export function nativeNumberKind(value, key) {
+  const fact = facts.get(value)?.numbers.get(String(key));
+  return fact && Object.is(value[key], fact.value) ? fact.kind : null;
+}
+
+/** Native SQLite INTEGER columns enter JSON without a lossy Number round
+ * trip. This helper records their exact i64/u64 value for the serializer. */
+export function setNativeInteger(value, key, integer) {
+  if (typeof integer !== 'bigint' || integer < intMin || integer > uintMax) throw new RangeError('not a native JSON integer');
+  let meta = facts.get(value);
+  if (!meta) { meta = { keys: Object.keys(value), numbers: new Map() }; facts.set(value, meta); }
+  if (!Object.hasOwn(value, key)) meta.keys.push(String(key));
+  Object.defineProperty(value, key, { value: Number(integer), enumerable: true, writable: true, configurable: true });
+  meta.numbers.set(String(key), { value: Number(integer), kind: 'integer', integer });
+}
+
+export function setNativeFloat(value, key, number) {
+  let meta = facts.get(value);
+  if (!meta) { meta = { keys: Object.keys(value), numbers: new Map() }; facts.set(value, meta); }
+  if (!Object.hasOwn(value, key)) meta.keys.push(String(key));
+  value[key] = Number.isFinite(number) ? number : null;
+  if (value[key] == null) meta.numbers.delete(String(key));
+  else meta.numbers.set(String(key), { value: number, kind: 'float' });
+}
 
 function formatFloat(number) {
   if (number === 0) return Object.is(number, -0) ? '-0.0' : '0.0';
@@ -149,12 +191,57 @@ function formatFloat(number) {
 }
 
 export function stringifyNativeJson(value) {
+  if (typeof value === 'bigint') return String(value);
   if (value == null || typeof value !== 'object') return JSON.stringify(value);
-  const meta = facts.get(value);
-  const child = (key) => {
-    const fact = meta?.numbers.get(key);
-    return fact ? fact.kind === 'integer' ? String(fact.integer) : formatFloat(fact.value) : stringifyNativeJson(value[key]);
+  const child = (key) => stringifyNativeJsonMember(value, key);
+  if (Array.isArray(value)) return `[${Array.from({ length: value.length }, (_, at) => child(String(at)) ?? 'null').join(',')}]`;
+  return `{${nativeObjectKeys(value).flatMap((key) => {
+    const encoded = child(key); return encoded === undefined ? [] : [`${JSON.stringify(key)}:${encoded}`];
+  }).join(',')}}`;
+}
+
+/** serde_json Value equality ignores object order but distinguishes integers
+ * from floats. Keep those facts when comparing transcript content; ordinary
+ * deep JS equality cannot distinguish an exact u64 from its rounded Number. */
+export function nativeJsonEqual(left, right) {
+  const number = (parent, key) => {
+    const value = parent[key], fact = facts.get(parent)?.numbers.get(String(key));
+    if (fact && Object.is(value, fact.value)) return fact;
+    return typeof value === 'number' ? { kind: Number.isInteger(value) && !Object.is(value, -0) ? 'integer' : 'float',
+      value, integer: Number.isInteger(value) ? BigInt(value) : null } : null;
+  };
+  const equal = (a, b) => {
+    if (a == null || b == null || typeof a !== 'object' || typeof b !== 'object') return a === b;
+    if (Array.isArray(a) !== Array.isArray(b)) return false;
+    const keys = Object.keys(a);
+    if (keys.length !== Object.keys(b).length) return false;
+    for (const key of keys) {
+      if (!Object.hasOwn(b, key)) return false;
+      const first = number(a, key), second = number(b, key);
+      if (first || second) {
+        if (!first || !second || first.kind !== second.kind
+          || (first.kind === 'integer' ? first.integer !== second.integer : first.value !== second.value)) return false;
+      } else if (!equal(a[key], b[key])) return false;
+    }
+    return true;
   };
-  if (Array.isArray(value)) return `[${value.map((_, at) => child(String(at))).join(',')}]`;
-  return `{${nativeObjectKeys(value).map((key) => `${JSON.stringify(key)}:${child(key)}`).join(',')}}`;
+  return equal(left, right);
+}
+
+export function stringifyNativeJsonMember(value, key) {
+  const fact = facts.get(value)?.numbers.get(String(key));
+  return fact && Object.is(value[key], fact.value) ? fact.kind === 'integer' ? String(fact.integer) : formatFloat(fact.value) : stringifyNativeJson(value[key]);
+}
+
+export function stringifyNativeJsonPretty(value, depth = 0) {
+  if (value == null || typeof value !== 'object') return stringifyNativeJson(value);
+  const keys = nativeObjectKeys(value), array = Array.isArray(value);
+  if (!keys.length) return array ? '[]' : '{}';
+  const padding = '  '.repeat(depth + 1);
+  const lines = keys.map((key) => {
+    const child = value[key] != null && typeof value[key] === 'object'
+      ? stringifyNativeJsonPretty(value[key], depth + 1) : stringifyNativeJsonMember(value, key);
+    return padding + (array ? child : `${JSON.stringify(key)}: ${child}`);
+  });
+  return `${array ? '[' : '{'}\n${lines.join(',\n')}\n${'  '.repeat(depth)}${array ? ']' : '}'}`;
 }

package/package.json

@@ -1,13 +1,25 @@
 {
   "name": "@volter/supercode-interchange",
-  "version": "0.1.1",
+  "version": "0.1.3",
   "type": "module",
-  "description": "Read-only harness metadata and discovery projection for Supercode's daemon-owned session index",
+  "description": "Read-only harness metadata, transcript codecs and session projections for Supercode",
   "license": "MIT OR Apache-2.0",
   "exports": {
     ".": {
       "types": "./index.d.ts",
       "import": "./index.mjs"
+    },
+    "./session-model": {
+      "types": "./session-model.d.ts",
+      "import": "./session-model.mjs"
+    },
+    "./session-codecs": {
+      "types": "./session-codecs.d.ts",
+      "import": "./session-codecs.mjs"
+    },
+    "./session-read": {
+      "types": "./session-read.d.ts",
+      "import": "./session-read.mjs"
     }
   },
   "files": [
@@ -21,6 +33,7 @@
     "node": ">=22.15.0"
   },
   "dependencies": {
-    "@noble/hashes": "2.4.0"
+    "@noble/hashes": "2.4.0",
+    "saxes": "6.0.0"
   }
 }

package/session-claude-append.mjs

@@ -0,0 +1,107 @@
+// Conservative native append optimization. Every retained prefix byte is
+// compared before reuse. Complex graph/tool/chunk changes use the full codec.
+import { withSessionFile } from './file-io.mjs';
+import { decodeSessionUtf8 } from './session-file.mjs';
+import { parseNativeJson, cloneNativeJson, nativeJsonEqual } from './native-json.mjs';
+import { nativeTrim } from './text.mjs';
+import { field, stringField } from './session-codec-utils.mjs';
+import { ClaudeReplayIndex } from './session-claude-graph.mjs';
+import { captureClaudeMeta } from './session-claude.mjs';
+import { pushClaudeUser, captureClaudeProvenance, mergeClaudeAssistantChunk, flushClaudeAssistant } from './session-claude-content.mjs';
+
+const messageId = (value) => stringField(field(value, 'message'), 'id');
+function simpleMessage(value) {
+  if (value != null && typeof value === 'object' && Object.keys(value).some((key) => key.startsWith('_supercode_'))) return false;
+  if (!['user', 'assistant'].includes(stringField(value, 'type'))) return false;
+  const content = field(field(value, 'message'), 'content');
+  return typeof content === 'string' || Array.isArray(content)
+    && content.every((block) => ['text', 'image', 'thinking', 'redacted_thinking', 'fallback'].includes(stringField(block, 'type')));
+}
+function* rawChunks(raw) {
+  for (const line of raw) {
+    for (let at = 0; at < line.length;) {
+      let end = Math.min(line.length, at + 32 * 1024);
+      const last = line.charCodeAt(end - 1);
+      if (end < line.length && last >= 0xd800 && last <= 0xdbff) end--;
+      yield Buffer.from(line.slice(at, end)); at = end;
+    }
+    yield Buffer.from('\n');
+  }
+}
+async function prefixMatches(reader, raw) {
+  let position = 0, available = Buffer.alloc(0), used = 0;
+  for (const expected of rawChunks(raw)) {
+    for (let at = 0; at < expected.length;) {
+      if (used === available.length) { available = await reader.read(position, 64 * 1024); used = 0; }
+      const length = Math.min(available.length - used, expected.length - at);
+      if (!length || !expected.subarray(at, at + length).equals(available.subarray(used, used + length))) return false;
+      used += length; at += length; position += length;
+    }
+  }
+  return true;
+}
+
+export class ClaudeAppendState {
+  static fromSession(session, fidelity) {
+    if (session.meta.source !== 'claude_code' || !session.raw_is_verbatim || !session.raw_trailing_newline
+      || session.parse_error_lines !== 0 || session.subagents.length) return null;
+    const graph = new ClaudeReplayIndex(); let bytes = 0;
+    session.raw.forEach((line, index) => {
+      bytes += Buffer.byteLength(line) + 1;
+      if (nativeTrim(line) !== '') graph.observe(index, parseNativeJson(line));
+    });
+    const selection = graph.clone().selectLines(fidelity);
+    if (!nativeJsonEqual(selection.residue, session.load_residue)) return null;
+    let lastAssistant = null;
+    if (selection.lines.length) {
+      const last = parseNativeJson(session.raw[selection.lines.at(-1)]);
+      if (stringField(last, 'type') === 'assistant') lastAssistant = messageId(last);
+    }
+    return new ClaudeAppendState(graph, selection.lines, bytes, lastAssistant);
+  }
+  constructor(graph, replay, bytes, lastAssistant) { this.graph = graph; this.replay = replay; this.bytes = bytes; this.lastAssistant = lastAssistant; }
+  async append(path, current, fidelity, { metrics } = {}) {
+    return (await withSessionFile(path, async (reader) => {
+      if (reader.size <= this.bytes || reader.size - this.bytes > 8 * 1024 * 1024) return null;
+      if (!await prefixMatches(reader, current.raw)) return null;
+      const appended = decodeSessionUtf8(await reader.read(this.bytes, reader.size - this.bytes));
+      if (!appended.endsWith('\n')) return null;
+      const lines = appended.slice(0, -1).split('\n'), values = [], graph = this.graph.clone(), meta = cloneNativeJson(current.meta);
+      for (let at = 0; at < lines.length; at++) {
+        const line = lines[at]; if (nativeTrim(line) === '') { values.push(null); continue; }
+        let value; try { value = parseNativeJson(line); } catch { return null; }
+        if (!simpleMessage(value)) return null;
+        graph.observe(current.raw.length + at, value); captureClaudeMeta(value, meta, line); values.push(value);
+      }
+      const selection = graph.clone().selectLines(fidelity);
+      if (selection.lines.length < this.replay.length || this.replay.some((index, at) => selection.lines[at] !== index)) return null;
+      const added = selection.lines.slice(this.replay.length);
+      if (added.some((index) => index < current.raw.length)) return null;
+      if (added.length && this.lastAssistant != null && messageId(values[added[0] - current.raw.length]) === this.lastAssistant) return null;
+      const messages = []; let pending = null;
+      for (const index of added) {
+        const value = values[index - current.raw.length];
+        if (stringField(value, 'type') === 'assistant') {
+          if (field(value, 'isApiErrorMessage') === true) { flushClaudeAssistant(pending, messages); pending = null; continue; }
+          if (pending != null) {
+            if (messageId(pending) != null && messageId(pending) === messageId(value)) { mergeClaudeAssistantChunk(pending, value); continue; }
+            flushClaudeAssistant(pending, messages);
+          }
+          pending = cloneNativeJson(value);
+        } else {
+          flushClaudeAssistant(pending, messages); pending = null;
+          const before = messages.length; pushClaudeUser(value, messages); captureClaudeProvenance(value, messages, before);
+        }
+      }
+      flushClaudeAssistant(pending, messages);
+      const last = added.length ? values[added.at(-1) - current.raw.length] : null;
+      const lastAssistant = added.length ? stringField(last, 'type') === 'assistant' ? messageId(last) : null : this.lastAssistant;
+      const session = cloneNativeJson(current), count = (current.imported_message_count ?? current.messages.length) + messages.length;
+      session.meta = meta;
+      for (const message of messages) session.messages.push(message);
+      for (const line of lines) session.raw.push(line);
+      session.imported_message_count = count; session.load_residue = selection.residue;
+      return { session, state: new ClaudeAppendState(graph, selection.lines, reader.size, lastAssistant) };
+    }, metrics)).result;
+  }
+}