@volter/supercode-interchange 0.1.22 → 0.1.24

package/session-inspect.mjs

@@ -0,0 +1,122 @@
+// Full literal input or a verified saved family, with the persisted working
+// transcript taking precedence over a mechanical reduction projection.
+import { join } from 'node:path';
+import { loadSessionPath, looksLikeSessionSqlite } from './session-path.mjs';
+import { readStore, statement } from './sqlite-reader.mjs';
+import { cloneNativeJson, copyNativeJsonMember, nativeInteger, setNativeInteger, stringifyNativeJsonPretty } from './native-json.mjs';
+import { fromSidecarStr } from './session-native.mjs';
+import { sessionTrigger, sessionWorkspace } from './session-model.mjs';
+import { SavedSessionReader, parseSavedMessages, savedPathExists, savedSessionRoot } from './session-saved-read.mjs';
+import { estimateViewTokens, verifyReductionLog } from './reduction-log.mjs';
+import { reapplyReductionLog } from './reduction-view.mjs';
+import { savedReductionAttribution } from './reduction-attribution.mjs';
+import { conversionParseLoss } from './session-convert.mjs';
+
+export const inspectionFirstLine = (text, maximum) => {
+  const end = text.indexOf('\n'), line = end < 0 ? text : text.slice(0, end).replace(/\r$/u, ''), chars = [...line];
+  return chars.length > maximum ? chars.slice(0, maximum).join('') + '…' : line;
+};
+export function inspectionPercentage(view, full) {
+  if (full === 0n) return 0n;
+  const value = Math.round(Number(view) / Number(full) * 100);
+  return value >= Number((1n << 63n) - 1n) ? (1n << 63n) - 1n : BigInt(value);
+}
+export function inspectionStoredRecords(session) {
+  if (!['pi', 'openclaw'].includes(session.meta.source)) return null;
+  const stored = session.raw.filter(line => line.includes('"type":"message"')).length;
+  return stored === session.messages.length ? null : stored;
+}
+const aggregateFields = ['full_bytes', 'view_bytes', 'full_tokens', 'view_tokens', 'aggregate_saved_bytes', 'aggregate_saved_tokens',
+  'standalone_saved_bytes', 'standalone_saved_tokens', 'overlap_suppressed_bytes', 'overlap_suppressed_tokens'];
+const passFields = ['candidate_count', 'candidate_original_bytes', 'applied_count', 'applied_original_bytes', 'suppressed_by_later_pass_count',
+  'suppressed_by_later_pass_bytes', 'standalone_saved_bytes', 'standalone_saved_tokens', 'marginal_saved_bytes', 'marginal_saved_tokens',
+  'suppressed_bytes', 'suppressed_tokens', 'retained_bytes', 'retained_tokens'];
+function attributionJson(value) {
+  const out = {};
+  for (const key of aggregateFields) copyNativeJsonMember(out, key, value);
+  const sum = key => value.passes.reduce((total, row) => (total + nativeInteger(row, key)) & ((1n << 64n) - 1n), 0n);
+  out.aggregate_bytes_is_marginal_sum = sum('marginal_saved_bytes') === nativeInteger(value, 'aggregate_saved_bytes');
+  out.aggregate_is_marginal_sum = sum('marginal_saved_tokens') === nativeInteger(value, 'aggregate_saved_tokens');
+  out.passes = value.passes.map(row => {
+    const out = { kind: row.kind, enabled: row.enabled };
+    for (const key of passFields) copyNativeJsonMember(out, key, row);
+    return out;
+  });
+  return out;
+}
+export function inspectionSessionSummary(session, reduced = null) {
+  const meta = session.meta, workspace = sessionWorkspace(meta);
+  const out = { source: meta.source.replace('claude_code', 'claude-code'), session_id: meta.session_id, model: meta.model, cwd: meta.cwd,
+    trigger: sessionTrigger(meta), surface: cloneNativeJson(meta.surface), profile: meta.profile, recurrence: cloneNativeJson(meta.recurrence),
+    cross_surface: cloneNativeJson(meta.cross_surface), workspace: { kind: workspace.kind, value: workspace.value ?? null },
+    message_count: session.messages.length, messages: session.messages.map(message => ({ role: message.role,
+      content_preview: message.content == null ? null : inspectionFirstLine(message.content, 120), tool_calls: (message.tool_calls ?? []).map(call => call.function.name) })) };
+  const stored = inspectionStoredRecords(session); if (stored != null) out.stored_message_records = stored;
+  if (reduced) {
+    out.reduced = { stub_count: reduced.stubCount };
+    for (const [key, value] of [['view_tokens', reduced.viewTokens], ['full_tokens', reduced.fullTokens], ['pct', reduced.pct]]) setNativeInteger(out.reduced, key, value);
+    out.reduced.sidecar_path = reduced.sidecarPath; out.reduced.attribution = attributionJson(reduced.attribution);
+  }
+  return out;
+}
+async function storeSummary(path) {
+  try {
+    if (!await looksLikeSessionSqlite(path)) return null;
+    return (await readStore(path, db => {
+      const out = { path };
+      for (const [key, table] of [['sessions', 'session'], ['messages', 'message'], ['parts', 'part'], ['todos', 'todo']]) {
+        const count = statement(db, `SELECT COUNT(*) AS count FROM ${table}`).get().count;
+        const value = typeof count === 'bigint' ? count : BigInt(count);
+        setNativeInteger(out, key, value < 0n ? 0n : value);
+      }
+      return out;
+    })).result;
+  } catch { return null; }
+}
+
+/** No tier/configuration read occurs in JSON mode or after parse loss. Render
+ * callbacks keep presentation separate while preserving partial reports. */
+export async function inspectSession({ file, json = false }, context = {}) {
+  const output = context.output ?? (() => {}); let session, reduced = null, opencodeStore = null, literal = false;
+  if (await savedPathExists(file)) {
+    literal = true; opencodeStore = await storeSummary(file);
+    try { session = await loadSessionPath(file, { env: context.env ?? process.env }); }
+    catch (error) { throw new Error(`loading session ${file}: ${error.message}`, { cause: error }); }
+  } else {
+    const store = new SavedSessionReader(context.storeRoot ?? savedSessionRoot(context.env)), name = await store.resolve(file);
+    const source = await store.read(name, '.sidecar.jsonl', true);
+    if (source != null) {
+      let sidecar;
+      try { sidecar = fromSidecarStr(source); } catch (error) { throw new Error(`parsing sidecar for \`${name}\`: ${error.message}`, { cause: error }); }
+      const log = await store.reductionLog(name);
+      try { verifyReductionLog(log, sidecar.messages); }
+      catch (error) { throw new Error(`${error.message} — repair pointer: \`sessions show-reductions ${name}\``, { cause: error }); }
+      let saved;
+      try { saved = await store.read(name, '.jsonl', true); }
+      catch (error) { throw new Error(`reading stored working view for \`${name}\`: ${error.message}`, { cause: error }); }
+      let messages;
+      if (saved != null) {
+        try { messages = parseSavedMessages(name, saved).messages; }
+        catch (error) { throw new Error(`parsing stored working view for \`${name}\`: ${error.message}`, { cause: error }); }
+      } else messages = reapplyReductionLog(sidecar.messages, log);
+      const fullTokens = estimateViewTokens(sidecar.messages), viewTokens = estimateViewTokens(messages);
+      reduced = { stubCount: log.reductions.length, fullTokens, viewTokens, pct: inspectionPercentage(viewTokens, fullTokens),
+        sidecarPath: join(store.root, name + '.sidecar.jsonl'), attribution: savedReductionAttribution(log, sidecar.messages) };
+      session = cloneNativeJson(sidecar); session.messages = messages;
+    } else session = parseSavedMessages(name, await store.read(name, '.jsonl'));
+  }
+  const report = { session: inspectionSessionSummary(session, reduced) };
+  if (opencodeStore) report.opencode_store = opencodeStore;
+  if (json) await output(stringifyNativeJsonPretty(report) + '\n');
+  else await context.render?.({ session, reduced, opencodeStore });
+  if (literal) {
+    const { errors, lines, children, childErrors } = conversionParseLoss(session);
+    if (errors) {
+      const note = childErrors ? ` (${childErrors} of which came from ${children} subagent transcript(s))` : '';
+      context.diagnostic?.(`error: ${file} — ${errors} of ${lines} line(s) failed to parse and were DROPPED${note} (the file may be truncated or corrupted); everything above reflects only the ${Math.max(0, lines - errors)} line(s) that DID parse, not the complete session`, 'ERR');
+      throw new Error(`${file}: ${errors} of ${lines} line(s) failed to parse — refusing to report success on a partially-loaded session (PARITY-15)${note}`);
+    }
+  }
+  if (!json) await context.schemas?.();
+  return report;
+}

package/session-machine-tree.d.ts

@@ -0,0 +1,33 @@
+import type { HarnessHomes } from './index.js';
+type JsonRecord = Record<string, unknown>;
+type Context = { env?: Record<string, string | undefined>; cwd?: string };
+interface Launch { key: string; by: string | null; at: bigint; resumes: string | null; kind: string | null }
+export const TREE_HEARTBEAT_MS: bigint;
+export const TREE_JOURNAL_MAX_BYTES: number;
+export function treePath(...parts: string[]): string;
+export function treeSelectedPath(path: string, cwd: string): string;
+export function machineTreeHome(env: Record<string, string | undefined>, cwd: string): string;
+export function sessionTreeQuery(params: unknown, context?: Context): { at: string | null; homes: HarnessHomes; home: string };
+export function treeMoment(at: bigint): string;
+export function treeTimestamp(at: unknown): bigint | null;
+export function treeParseSince(at: string, now?: bigint): bigint;
+export function treeRecordTime(record: unknown): bigint | null;
+export function treeUnsigned(record: unknown, key: string): bigint | null;
+export function treeMachineName(env: Record<string, string | undefined>, cwd: string): string;
+export function treeAddress(machine: string, harness: string, id: string): string | null;
+export function treeParseAddress(value: unknown): { machine: string; harness: string; session: string; address: string } | null;
+export function treeReadText(path: string | Buffer): string | null;
+export function treeRecords(text: string | null): unknown[];
+export function readTreeLaunches(home: string): { origins: Map<string, Launch>; panes: Map<string, Launch> };
+export function readTreeTail(home: string): { last: JsonRecord | null; lastAt: bigint | null };
+export function recordedMachineTree(home: string, at: bigint): JsonRecord | null;
+export function treeShape(tree: unknown): string[][];
+export function nextTreeRecord(tree: unknown, tail: { last: JsonRecord | null; lastAt: bigint | null }, now?: bigint): { written: 'tree' | 'heartbeat'; record: JsonRecord } | null;
+export function firstTreeStarts(home: string, addresses: Set<string>): Map<string, { parent: string | null; evidence: 'launch'; recorded: true; detail: string; launch_key: string | null; at: bigint | null }>;
+export function machineTreeEdges(rows: JsonRecord[]): { rows: JsonRecord[]; elsewhere: string[]; children: Map<string, string[]> };
+export function treeRegistryDirectory(homes: HarnessHomes): string;
+export function treeClaudeRegistry(homes: HarnessHomes, env: Record<string, string | undefined>): Promise<JsonRecord[]>;
+export function treeFindRollout(root: string, id: string): Buffer | null;
+export function treeRolloutHeader(path: string | Buffer): { thread: string; parent: string | null; cwd: string | null } | null;
+export function treeFile(path: string | Buffer): boolean;
+export function treeRolloutStatus(path: string | Buffer): 'busy' | 'idle' | 'running';

package/session-machine-tree.mjs

@@ -0,0 +1,274 @@
+// The machine's launch/tree records and graph fold. These records describe
+// starter lineage; they never prove caller identity or confer a grant.
+import { readFileSync, openSync, fstatSync, readSync, closeSync, statSync } from 'node:fs';
+import { dirname, isAbsolute, parse, sep } from 'node:path';
+import { userInfo } from 'node:os';
+import { execFile } from 'node:child_process';
+import { parseNativeJson, cloneNativeJson, nativeInteger, nativeNumberKind, setNativeInteger, stringifyNativeJsonMember } from './native-json.mjs';
+import { field, stringField } from './session-codec-utils.mjs';
+import { childPath, directoryEntries, rolloutSession, isDirectory, textName } from './session-spend-files.mjs';
+import { spendMachineName, spendAddress } from './session-spend-metadata.mjs';
+import { nativeTrim } from './text.mjs';
+import { resolveHarnessHomes } from './homes.mjs';
+import { usageMoment, usageTimestamp, parseUsageSince } from './session-usage-time.mjs';
+import { CodexLifecycleCursor } from './session-codex-activity.mjs';
+
+export const TREE_HEARTBEAT_MS = 9n * 60n * 1000n;
+export const TREE_JOURNAL_MAX_BYTES = 16 * 1024 * 1024;
+const decoder = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const invalid = message => { throw Object.assign(new Error(message), { rpcCode: -32602 }); };
+const object = value => value != null && typeof value === 'object' && !Array.isArray(value);
+const hasSessions = record => object(record) && Object.hasOwn(record, 'sessions');
+const moment = value => usageMoment(value);
+export const treeMoment = moment;
+export const treeTimestamp = usageTimestamp;
+export const treeRecordTime = record => nativeInteger(record, 't', { signed: true });
+export const treeParseSince = parseUsageSince;
+export const treeMachineName = spendMachineName;
+export const treeAddress = (machine, harness, id) => /^[A-Za-z0-9._-]+$/.test(machine) && /^[A-Za-z0-9._-]+$/.test(harness) ? spendAddress(machine, harness, id) : null;
+export function treeParseAddress(value) {
+  if (typeof value !== 'string') return null;
+  const match = /^sc:([A-Za-z0-9._-]+):([A-Za-z0-9._-]+):(.+)$/su.exec(value);
+  if (!match || /[\u0009-\u000d\u0020\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]/u.test(match[3])) return null;
+  return { machine: match[1], harness: match[2], session: match[3], address: value };
+}
+export const treeUnsigned = (record, key) => nativeInteger(record, key)
+  ?? (nativeNumberKind(record, key) == null && Number.isSafeInteger(record?.[key]) && record[key] >= 0 ? BigInt(record[key]) : null);
+// A rollout's first record never changes once written: its header is kept per file identity (device, inode, birth),
+// so a session's every reading costs one stat, not a header read. A file not yet holding its header is read again.
+const ROLLOUT_HEADERS_KEPT = 4096, rolloutHeaders = new Map();
+const pathKey = path => Buffer.isBuffer(path) ? `b:${path.toString('hex')}` : `s:${path}`;
+export function treeRolloutHeader(path) {
+  let stat; try { stat = statSync(path, { bigint: true }); } catch { return null; }
+  const key = pathKey(path), identity = `${stat.dev}:${stat.ino}:${stat.birthtimeNs}`, kept = rolloutHeaders.get(key);
+  if (kept?.identity === identity) return kept.header;
+  const header = rolloutSession(path);
+  rolloutHeaders.delete(key);
+  if (header != null) {
+    if (rolloutHeaders.size >= ROLLOUT_HEADERS_KEPT) rolloutHeaders.delete(rolloutHeaders.keys().next().value);
+    rolloutHeaders.set(key, { identity, header: Object.freeze(header) });
+  }
+  return header;
+}
+export const treeFile = path => { try { return statSync(path).isFile(); } catch { return false; } };
+
+export function treePath(...parts) {
+  let result = '';
+  for (const part of parts) result = isAbsolute(part) || process.platform === 'win32' && /^[A-Za-z]:/.test(part)
+    ? part : childPath(result, part).toString('utf8');
+  return result;
+}
+export const treeSelectedPath = (path, cwd) => !path || isAbsolute(path) || process.platform === 'win32' && /^[A-Za-z]:/.test(path)
+  ? path : `${cwd}${sep}${path}`;
+export function machineTreeHome(env, cwd) {
+  let home; try { home = env.HOME || (process.platform === 'win32' && env.USERPROFILE) || userInfo().homedir || '.'; } catch { home = '.'; }
+  const supercode = env.SUPERCODE_HOME || (env.XDG_CONFIG_HOME ? treePath(env.XDG_CONFIG_HOME, 'supercode') : treePath(home, '.config', 'supercode'));
+  return treeSelectedPath(env.SUPERCODE_TEAMS_HOME || treePath(supercode, 'teams'), cwd);
+}
+export function sessionTreeQuery(params, { env = process.env, cwd = process.cwd() } = {}) {
+  params ??= {};
+  if (!object(params)) invalid('tree params must be an object');
+  for (const key of Object.keys(params)) if (!['at', 'homes'].includes(key)) invalid(`unknown field ${key}`);
+  if (params.at != null && typeof params.at !== 'string') invalid('at must be a string');
+  const homes = resolveHarnessHomes(env);
+  if (Object.hasOwn(params, 'homes')) {
+    if (!object(params.homes)) invalid('homes must be an object');
+    for (const key of Object.keys(homes)) if (Object.hasOwn(params.homes, key)) {
+      if (typeof params.homes[key] !== 'string') invalid(`homes.${key} must be a string`);
+      homes[key] = params.homes[key];
+    }
+  }
+  for (const key of Object.keys(homes)) homes[key] = treeSelectedPath(homes[key], cwd);
+  return { at: params.at ?? null, homes, home: machineTreeHome(env, cwd) };
+}
+
+export function treeReadText(path) {
+  try { return decoder.decode(readFileSync(path)); } catch { return null; }
+}
+const lines = text => text.split('\n').map(line => line.endsWith('\r') ? line.slice(0, -1) : line);
+export function treeRecords(text) {
+  const records = [];
+  for (const line of lines(text ?? '')) { try { records.push(parseNativeJson(line)); } catch { /* an unread record establishes nothing */ } }
+  return records;
+}
+
+/** A key/pane's first issue, each session's first non-resume launch, and
+ * each pane's last launch, in journal order. */
+export function readTreeLaunches(home) {
+  const origins = new Map(), panes = new Map(), issued = new Map();
+  for (const record of treeRecords(treeReadText(treePath(home, 'launches.jsonl')))) {
+    const key = stringField(record, 'key'), t = treeRecordTime(record); if (key == null || t == null) continue;
+    const pane = stringField(record, 'pane'), issueKey = JSON.stringify([key, pane ?? '']);
+    if (!issued.has(issueKey)) issued.set(issueKey, t);
+    let resumes = stringField(record, 'resumes');
+    if (resumes == null && key.startsWith('open:')) {
+      let rest = key.slice(5); if (rest.startsWith('native:')) rest = rest.slice(7);
+      const colon = rest.indexOf(':'); if (colon >= 0 && rest.slice(colon + 1)) resumes = rest.slice(colon + 1);
+    }
+    const launch = { key, by: stringField(record, 'by'), at: issued.get(issueKey), resumes, kind: stringField(record, 'kind') };
+    const id = stringField(record, 'native_session');
+    if (id != null && resumes == null && !origins.has(id)) origins.set(id, launch);
+    if (pane != null) panes.set(pane, launch);
+  }
+  return { origins, panes };
+}
+
+/** The last full record and the newest valid i64 clock in the same 4 MiB
+ * tail. A split UTF-8 sequence makes this native read unavailable. */
+export function readTreeTail(home) {
+  let file;
+  try {
+    file = openSync(treePath(home, 'sessions-tree.jsonl'), 'r');
+    const length = fstatSync(file).size, start = Math.max(0, length - 4 * 1024 * 1024), buffer = Buffer.alloc(length - start);
+    let read = 0; while (read < buffer.length) { const n = readSync(file, buffer, read, buffer.length - read, start + read); if (!n) break; read += n; }
+    const text = decoder.decode(buffer.subarray(0, read)); let lastAt = null;
+    for (const record of treeRecords(text).reverse()) {
+      lastAt ??= treeRecordTime(record);
+      if (hasSessions(record)) return { last: record, lastAt };
+    }
+    return { last: null, lastAt };
+  } catch { return { last: null, lastAt: null }; }
+  finally { if (file != null) closeSync(file); }
+}
+
+export function recordedMachineTree(home, at) {
+  const text = (treeReadText(treePath(home, 'sessions-tree.jsonl.1')) ?? '') + (treeReadText(treePath(home, 'sessions-tree.jsonl')) ?? '');
+  let found = null, confirmed = null, nextChange = null;
+  for (const record of treeRecords(text)) {
+    const t = treeRecordTime(record); if (t == null) continue;
+    if (t <= at) { if (hasSessions(record)) found = record; confirmed = t; }
+    else if (hasSessions(record)) { nextChange = t; break; }
+    else if (found != null && nextChange == null) confirmed = t;
+  }
+  if (found == null) return null;
+  const tree = cloneNativeJson(found), recorded = treeRecordTime(tree) ?? 0n;
+  tree.at = moment(at); tree.recorded_at = moment(recorded);
+  tree.confirmed_through = confirmed == null ? null : moment(confirmed);
+  tree.next_change_at = nextChange == null ? null : moment(nextChange);
+  delete tree.t;
+  return tree;
+}
+
+export function treeShape(tree) {
+  const rows = Array.isArray(field(tree, 'sessions')) ? tree.sessions : [];
+  return rows.map(row => ['address', 'parent', 'pane'].map(key => stringField(row, key) ?? ''))
+    .sort((a, b) => { for (let i = 0; i < 3; i++) { const n = Buffer.compare(Buffer.from(a[i]), Buffer.from(b[i])); if (n) return n; } return 0; });
+}
+/** Decide the next append without changing the journal. The daemon/CLI
+ * owns rollover and the single append. */
+export function nextTreeRecord(tree, { last, lastAt }, now = BigInt(Date.now())) {
+  const same = last != null && JSON.stringify(treeShape(last)) === JSON.stringify(treeShape(tree));
+  if (same && lastAt != null && BigInt.asIntN(64, now - lastAt) < TREE_HEARTBEAT_MS) return null;
+  const record = same ? parseNativeJson(`{"t":0,"unchanged_since":${stringifyNativeJsonMember(last, 't')}}`) : {
+    t: 0, machine: cloneNativeJson(field(tree, 'machine') ?? null), sessions: cloneNativeJson(field(tree, 'sessions') ?? null),
+    parents_elsewhere: cloneNativeJson(field(tree, 'parents_elsewhere') ?? null),
+  };
+  setNativeInteger(record, 't', BigInt.asIntN(64, now));
+  return { written: same ? 'heartbeat' : 'tree', record };
+}
+
+export function firstTreeStarts(home, addresses) {
+  if (!addresses.size) return new Map();
+  const { last } = readTreeTail(home); if (last == null) return new Map();
+  const at = treeRecordTime(last), recordedAt = at == null ? '' : moment(at), starts = new Map();
+  for (const row of Array.isArray(field(last, 'sessions')) ? last.sessions : []) {
+    const address = stringField(row, 'address'), started = field(row, 'started_by');
+    if (!addresses.has(address) || field(started, 'recorded') !== true || stringField(started, 'evidence') !== 'launch') continue;
+    starts.set(address, { parent: stringField(row, 'parent'), evidence: 'launch', recorded: true,
+      detail: `its first launch, as the session tree recorded it at ${recordedAt}`,
+      launch_key: stringField(started, 'launch_key'), at: usageTimestamp(stringField(started, 'at')) });
+  }
+  return starts;
+}
+
+/** Drop only the first edge encountered on each cycle, then fill children
+ * in input order and name each missing parent once. */
+export function machineTreeEdges(rows) {
+  const index = new Map(); rows.forEach((row, i) => { const address = stringField(row, 'address'); if (address != null) index.set(address, i); });
+  for (let i = 0; i < rows.length; i++) {
+    const seen = new Set([i]); let current = index.get(stringField(rows[i], 'parent'));
+    while (current != null) {
+      if (current === i) { rows[i].parent = null; rows[i].started_by.cycle = true; break; }
+      if (seen.has(current)) break;
+      seen.add(current); current = index.get(stringField(rows[current], 'parent'));
+    }
+  }
+  const children = new Map(), elsewhere = [];
+  for (const row of rows) {
+    const parent = stringField(row, 'parent'); if (parent == null) continue;
+    if (!children.has(parent)) children.set(parent, []);
+    children.get(parent).push(stringField(row, 'address') ?? '');
+    if (!index.has(parent) && !elsewhere.includes(parent)) elsewhere.push(parent);
+  }
+  for (const row of rows) { const address = stringField(row, 'address') ?? ''; row.children = children.get(address) ?? []; children.delete(address); }
+  return { rows, elsewhere, children };
+}
+
+export function treeRegistryDirectory(homes) {
+  const root = homes.claude_code, parent = root && root !== parse(root).root ? dirname(root) : '.';
+  return treePath(parent, 'sessions');
+}
+
+export async function treeClaudeRegistry(homes, env, { signal } = {}) {
+  const rows = [], starts = new Map();
+  const optionalText = (row, key) => row[key] == null || typeof row[key] === 'string';
+  for (const file of directoryEntries(treeRegistryDirectory(homes))) {
+    const name = textName(file.name); if (!name?.endsWith('.json') || name === '.json') continue;
+    let row; try { row = parseNativeJson(treeReadText(file.path)); } catch { continue; }
+    if (!object(row)) continue;
+    const pid = nativeInteger(row, 'pid');
+    if (pid == null || pid > 0xffffffffn || typeof row.sessionId !== 'string' || !row.sessionId
+      || typeof row.name !== 'string' || !row.name || typeof row.messagingSocketPath !== 'string' || row.parkedJobId != null
+      || !['cwd', 'name', 'messagingSocketPath', 'status', 'version', 'tmux', 'parkedJobId', 'procStart', 'waitingFor'].every(key => optionalText(row, key))
+      || row.updatedAt != null && nativeInteger(row, 'updatedAt') == null
+      || row.statusUpdatedAt != null && nativeInteger(row, 'statusUpdatedAt') == null) continue;
+    let live = false;
+    try { process.kill(process.platform === 'win32' ? Number(pid) : Number(BigInt.asIntN(32, pid)), 0); live = true; }
+    catch (error) { live = process.platform !== 'win32' && error.code === 'EPERM'; }
+    if (live) rows.push(cloneNativeJson(row));
+  }
+  const normalizedWords = value => nativeTrim(value).split(/[\u0009-\u000d\u0020\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]+/u).join(' ');
+  if (process.platform === 'darwin' && rows.some(row => row.procStart != null)) await new Promise(resolve => {
+    execFile('ps', ['-o', 'pid=,lstart=', '-p', rows.map(row => row.pid).join(',')], { env: { ...env, TZ: 'UTC', LC_ALL: 'C' }, signal, timeout: 2000, maxBuffer: 1024 * 1024 }, (error, stdout) => {
+      if (!error) for (const line of stdout.split('\n')) { const match = /^\s*(\d+)\s+(.+)$/.exec(line); if (match) starts.set(Number(match[1]), normalizedWords(match[2])); }
+      resolve();
+    });
+  });
+  return rows.sort((a, b) => a.pid - b.pid).filter(row => {
+    let actual = starts.get(row.pid);
+    if (process.platform === 'linux' && row.procStart != null) {
+      try { const stat = readFileSync(`/proc/${row.pid}/stat`, 'utf8'); actual = stat.slice(stat.lastIndexOf(')') + 1).trim().split(/\s+/)[19]; } catch { /* unread proves no mismatch */ }
+    }
+    return row.procStart == null || actual == null || actual === (process.platform === 'darwin' ? normalizedWords(row.procStart) : nativeTrim(row.procStart));
+  });
+}
+
+// The rollout directory's listings, kept per directory and listed again only when its modification time moved (or was
+// too recent to trust): a lookup costs one stat per directory, never a listing of every day's rollouts.
+const LISTING_SETTLED_NS = 2_000_000_000n, rolloutListings = new Map();
+function rolloutListing(directory, depth) {
+  let stat; try { stat = statSync(directory, { bigint: true }); } catch { stat = null; }
+  const key = `${depth}:${pathKey(directory)}`, kept = rolloutListings.get(key);
+  if (stat != null && kept?.settled && kept.mtime === stat.mtimeNs && kept.ino === stat.ino) return kept.entries;
+  const entries = [];
+  for (const entry of directoryEntries(directory)) entries.push({ path: entry.path, name: textName(entry.name), directory: depth < 3 && isDirectory(entry.path) });
+  if (stat == null) rolloutListings.delete(key);
+  else rolloutListings.set(key, { mtime: stat.mtimeNs, ino: stat.ino, settled: BigInt(Date.now()) * 1_000_000n - stat.mtimeNs > LISTING_SETTLED_NS, entries });
+  return entries;
+}
+export function treeFindRollout(root, id) {
+  const suffix = `-${id}.jsonl`, stack = [[root, 0]];
+  while (stack.length) {
+    const [directory, depth] = stack.pop();
+    for (const entry of rolloutListing(directory, depth)) {
+      if (entry.directory) stack.push([entry.path, depth + 1]);
+      else if (entry.name?.endsWith(suffix)) return entry.path;
+    }
+  }
+  return null;
+}
+
+/** Fresh lifecycle scan, with the native 1 MiB blocks and 64 KiB overlap. */
+export function treeRolloutStatus(path) {
+  return new CodexLifecycleCursor().read(path) ?? 'running';
+}

package/session-materialize-files.mjs

@@ -0,0 +1,78 @@
+// Native continuation files are new, owner-only and synced. The selected home
+// may itself be a symlink; every directory below its canonical root may not.
+import { mkdir, lstat, realpath, open, unlink } from 'node:fs/promises';
+import { join, resolve, sep, toNamespacedPath } from 'node:path';
+export { freshSessionId } from './session-fresh-id.mjs';
+
+export const isObject = value => value != null && typeof value === 'object' && !Array.isArray(value);
+export const nativeJoin = (root, ...parts) => process.platform === 'win32' && /^[A-Za-z]:$/u.test(root)
+  ? root + parts.join(sep) : join(root, ...parts);
+export const operationPath = (path, cwd) => resolve(cwd, path);
+// std::fs::canonicalize returns the extended-length spelling on Windows.
+export const canonicalPath = async path => {
+  const canonical = await realpath(path);
+  return process.platform === 'win32' ? toNamespacedPath(canonical) : canonical;
+};
+
+/** Path::components ignores interior dots/repeated separators, but retains a
+ * leading CurDir, roots and Windows prefixes. Only Normal components qualify. */
+export function safeArtifactPath(path) {
+  if (path === '' || (process.platform === 'win32' ? /^[\\/]|^[A-Za-z]:/u : /^\//u).test(path)) return false;
+  // Unix separators deliberately exclude backslash, which is a normal byte.
+  const components = path.split(process.platform === 'win32' ? /[\\/]+/u : /\/+/u);
+  return components[0] !== '.' && components.every(part => part !== '..') && components.some(part => part !== '' && part !== '.');
+}
+
+export async function writeExclusive(path, content, signal) {
+  signal?.throwIfAborted();
+  let file;
+  try { file = await open(path, 'wx', 0o600); }
+  catch (error) { throw new Error(`refusing to overwrite native continuation: ${error.message}`, { cause: error }); }
+  try {
+    signal?.throwIfAborted();
+    await file.writeFile(content, 'utf8'); await file.sync();
+  } catch (error) {
+    // Only this newly created path belongs to us. Earlier successful bundle
+    // files remain, as in the native writer; cancellation claims no rollback.
+    await unlink(path).catch(() => {}); throw error;
+  } finally { await file.close().catch(() => {}); }
+}
+
+const inside = (root, child) => {
+  const prefix = pathComponents(root), components = pathComponents(child);
+  return prefix.length <= components.length && prefix.every((part, at) => part === components[at]);
+};
+export async function containedDirectory(root, parts, signal, claude = false) {
+  signal?.throwIfAborted();
+  await mkdir(root, { recursive: true });
+  const label = claude ? 'Claude projects root' : 'native store root';
+  try { root = await canonicalPath(root); }
+  catch (error) { throw new Error(`${label} is unavailable: ${error.message}`, { cause: error }); }
+  let directory = root;
+  for (const part of parts) {
+    signal?.throwIfAborted(); directory = join(directory, part);
+    let metadata;
+    try { metadata = await lstat(directory); }
+    catch (error) { if (error.code !== 'ENOENT') throw error; await mkdir(directory); }
+    if (metadata && (metadata.isSymbolicLink() || !metadata.isDirectory())) throw new Error(
+      claude ? 'refusing unsafe Claude project directory' : 'refusing unsafe native store directory');
+  }
+  let canonical;
+  try { canonical = await canonicalPath(directory); }
+  catch (error) { throw new Error(`${claude ? 'Claude project' : 'native store'} directory is unavailable: ${error.message}`, { cause: error }); }
+  if (!inside(root, canonical)) throw new Error(claude
+    ? 'refusing Claude project directory outside its native home' : 'refusing native store directory outside its home');
+  return canonical;
+}
+
+export function pathComponents(path) {
+  const windows = process.platform === 'win32', prefix = windows ? path.match(/^[A-Za-z]:/u)?.[0] ?? '' : '';
+  const tail = path.slice(prefix.length), components = tail.split(windows ? /[\\/]+/u : /\/+/u).filter(part => part !== '' && part !== '.');
+  const root = (windows ? /^[\\/]/u : /^\//u).test(tail);
+  const dot = tail === '.' || (windows ? /^\.[\\/]/u : /^\.\//u).test(tail);
+  return [prefix, root ? '/' : dot ? '.' : '', ...components];
+}
+export async function samePath(a, b, cwd) {
+  try { return await canonicalPath(operationPath(a, cwd)) === await canonicalPath(operationPath(b, cwd)); }
+  catch { return JSON.stringify(pathComponents(a)) === JSON.stringify(pathComponents(b)); }
+}

package/session-materialize-opencode.mjs

@@ -0,0 +1,137 @@
+// OpenCode owns its database writes. This module imports a fresh-ID document
+// through its CLI and opens candidate databases read-only to verify the result.
+import { mkdir, readFile, readdir, stat, rm } from 'node:fs/promises';
+import { join } from 'node:path';
+import { tmpdir } from 'node:os';
+import { randomBytes } from 'node:crypto';
+import { spawn } from 'node:child_process';
+import { DatabaseSync } from 'node:sqlite';
+import { parseNativeJson, stringifyNativeJson, swapRemoveNativeJsonMember } from './native-json.mjs';
+import { decodeSessionUtf8 } from './session-file.mjs';
+import { nativeTrim } from './text.mjs';
+import { isObject, nativeJoin, operationPath, writeExclusive } from './session-materialize-files.mjs';
+
+class OpenCodeIds {
+  counter = 0n;
+  next(prefix, descending) {
+    this.counter = BigInt.asUintN(64, this.counter + 1n);
+    const millis = Date.now(); if (millis < 0) throw new Error('system time is before the Unix epoch');
+    let value = BigInt.asUintN(64, BigInt(millis) * 0x1000n + this.counter);
+    if (descending) value = BigInt.asUintN(64, ~value);
+    const alphabet = '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz';
+    const suffix = [...randomBytes(14)].map(byte => alphabet[byte % alphabet.length]).join('');
+    return `${prefix}_${(value & 0xffffffffffffn).toString(16).padStart(12, '0')}${suffix}`;
+  }
+}
+
+/** This handle belongs only to the command we start. An aborted worker waits
+ * for close before deleting its staging directory, and claims no DB rollback. */
+async function command(program, arguments_, { cwd, env, signal }, stderr = true) {
+  signal?.throwIfAborted();
+  return await new Promise((resolve, reject) => {
+    const stdout = [], errors = [];
+    const child = spawn(program, arguments_, { cwd, env, windowsHide: true, stdio: ['ignore', 'pipe', stderr ? 'pipe' : 'ignore'] });
+    let forceStop, startError;
+    const abort = () => {
+      child.kill('SIGTERM');
+      forceStop = setTimeout(() => child.kill('SIGKILL'), 250); forceStop.unref();
+    };
+    signal?.addEventListener('abort', abort, { once: true }); if (signal?.aborted) abort();
+    child.stdout.on('data', chunk => stdout.push(chunk)); child.stderr?.on('data', chunk => errors.push(chunk));
+    child.once('error', error => { startError = error; });
+    child.once('close', (code, stoppedBy) => {
+      clearTimeout(forceStop); signal?.removeEventListener('abort', abort);
+      if (signal?.aborted) reject(signal.reason ?? new Error('OpenCode import cancelled'));
+      else if (startError) reject(startError);
+      else resolve({ code, stoppedBy, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(errors).toString('utf8') });
+    });
+  });
+}
+
+async function projectId(cwd, context) {
+  const git = async arguments_ => {
+    try {
+      const output = await command('git', ['-C', cwd, ...arguments_], context, false);
+      return output.code === 0 ? output.stdout : null;
+    } catch (error) { if (context.signal?.aborted) throw error; return null; }
+  };
+  const common = await git(['rev-parse', '--path-format=absolute', '--git-common-dir']);
+  if (common == null) return 'global';
+  try {
+    const cached = nativeTrim(decodeSessionUtf8(await readFile(nativeJoin(nativeTrim(common), 'opencode'))));
+    if (cached !== '') return cached;
+  } catch { /* Absent, unreadable or invalid UTF-8 cache falls back to Git roots. */ }
+  const roots = (await git(['rev-list', '--max-parents=0', '--all']))?.split('\n').map(nativeTrim).filter(value => value !== '') ?? [];
+  roots.sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
+  return roots[0] ?? 'global';
+}
+
+async function databaseHolding(root, id, context) {
+  const absolute = operationPath(root, context.cwd); let databases;
+  try {
+    if ((await stat(absolute)).isFile()) databases = [root];
+    else databases = (await readdir(absolute)).filter(name => name.startsWith('opencode') && name.endsWith('.db')).map(name => nativeJoin(root, name));
+  } catch { return null; }
+  databases.sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b)));
+  for (const path of databases) {
+    context.signal?.throwIfAborted(); let database;
+    try {
+      database = new DatabaseSync(operationPath(path, context.cwd), { readOnly: true, allowExtension: false });
+      // The replaced rusqlite connection uses its default five-second busy
+      // handler. This changes no journal mode and performs no database write.
+      database.exec('PRAGMA busy_timeout=5000');
+      if (database.prepare('SELECT 1 FROM session WHERE id = ?1').get(id) != null) return path;
+    } catch { /* A missing row, unreadable store or incompatible schema proves no import here. */ }
+    finally { try { database?.close(); } catch { /* Native connection drop has no reported close result. */ } }
+  }
+  return null;
+}
+
+export async function materializeOpenCode(artifact, cwd, root, context) {
+  let document;
+  try { document = parseNativeJson(artifact.content); }
+  catch (error) { throw new Error(`invalid OpenCode export: ${error.message}`, { cause: error }); }
+  if (artifact.session_id != null && document?.info?.id !== artifact.session_id) throw new Error('native artifact declared session identity does not match its content');
+  const ids = new OpenCodeIds(), id = ids.next('ses', true);
+  if (!isObject(document?.info)) throw new Error('OpenCode export has no session info');
+  document.info.id = id; document.info.directory = cwd; document.info.projectID = await projectId(cwd, context); swapRemoveNativeJsonMember(document.info, 'parentID');
+  const renamed = new Map(), rename = old => {
+    if (renamed.has(old)) return renamed.get(old);
+    const prefix = old.includes('_') ? old.slice(0, old.indexOf('_')) : 'msg', next = ids.next(prefix, false);
+    renamed.set(old, next); return next;
+  };
+  if (!Array.isArray(document.messages)) throw new Error('OpenCode export has no messages');
+  for (const message of document.messages) {
+    if (!isObject(message?.info)) throw new Error('OpenCode message has no info');
+    const info = message.info; info.sessionID = id;
+    const messageId = rename(typeof info.id === 'string' ? info.id : ''); info.id = messageId;
+    if (typeof info.parentID === 'string') info.parentID = rename(info.parentID);
+    if (isObject(info.path)) for (const key of ['cwd', 'root']) if (Object.hasOwn(info.path, key)) info.path[key] = cwd;
+    for (const part of Array.isArray(message.parts) ? message.parts : []) if (isObject(part)) {
+      part.sessionID = id; part.messageID = messageId; part.id = rename(typeof part.id === 'string' ? part.id : '');
+    }
+  }
+  context.signal?.throwIfAborted();
+  const staging = join(tmpdir(), `supercode-opencode-${id}`), file = join(staging, 'session.json');
+  await mkdir(staging); let output;
+  try {
+    await writeExclusive(file, stringifyNativeJson(document), context.signal);
+    try { output = await command('opencode', ['import', file], { ...context, cwd }); }
+    catch (error) {
+      if (context.signal?.aborted) throw error;
+      throw new Error(`\`opencode import\` could not start: ${error.message}`, { cause: error });
+    }
+  } finally { await rm(staging, { recursive: true, force: true }).catch(() => {}); }
+  let reported;
+  for (const line of output.stdout.split('\n')) {
+    const text = nativeTrim(line);
+    if (text.startsWith('Imported session: ')) { reported = nativeTrim(text.slice('Imported session: '.length)); break; }
+  }
+  if (output.code !== 0 || reported !== id) {
+    const status = output.stoppedBy ? `signal: ${output.stoppedBy}` : `exit status: ${output.code}`;
+    throw new Error(`\`opencode import\` did not import ${id} (exit ${status}): ${nativeTrim(output.stdout)}${nativeTrim(output.stderr)}`);
+  }
+  const database = await databaseHolding(root, id, context);
+  if (database == null) throw new Error(`\`opencode import\` reported ${id}, but no OpenCode database under ${root} holds it`);
+  return { harness: 'opencode', session_id: id, storage: { kind: 'sqlite', path: database, selector: id } };
+}