@volter/supercode-interchange 0.1.21 → 0.1.23

package/openclaw-jobs-read.mjs

@@ -0,0 +1,117 @@
+// The OpenClaw codec's job projection, after complete home validation.
+import { nativeInteger, parseNativeJson, setNativeInteger, stringifyNativeJsonMember } from './native-json.mjs';
+import { hermesIsoEpoch } from './hermes-fire-links.mjs';
+
+const object = value => value != null && typeof value === 'object' && !Array.isArray(value);
+const string = value => typeof value === 'string' ? value : null;
+const text = (row, key) => typeof row?.[key] === 'string' ? row[key] || null : typeof row?.[key] === 'number' ? stringifyNativeJsonMember(row, key) : null;
+const jsonObject = value => { try { const parsed = typeof value === 'string' ? parseNativeJson(value) : null; return object(parsed) ? parsed : {}; } catch { return {}; } };
+const first = (...entries) => entries.find(([row, key]) => row != null && Object.hasOwn(row, key));
+const value = entry => entry?.[0]?.[entry[1]];
+const float = value => typeof value === 'number' ? value : typeof value === 'string' && /^[+-]?(?:[0-9]+(?:\.[0-9]*)?|\.[0-9]+)(?:[eE][+-]?[0-9]+)?$/u.test(value) ? Number(value) : typeof value === 'string' && /^[+-]?(?:inf|infinity|nan)$/iu.test(value) ? /nan/iu.test(value) ? NaN : value.startsWith('-') ? -Infinity : Infinity : null;
+const low = -(1n << 63n), high = (1n << 63n) - 1n;
+const cast = n => Number.isNaN(n) ? 0n : n <= Number(low) ? low : n >= Number(high) ? high : BigInt(Math.trunc(n));
+const ms = (row, key) => nativeInteger(row, key, { signed: true }) ?? (float(row?.[key]) == null ? null : cast(float(row[key])));
+const floor = (a, b) => a < 0n ? (a - b + 1n) / b : a / b;
+function moment(ms) {
+  if (ms == null) return null;
+  const seconds = floor(ms, 1000n), days = floor(seconds, 86400n), sod = seconds - days * 86400n;
+  const z = days + 719468n, era = floor(z, 146097n), doe = z - era * 146097n;
+  const yoe = (doe - doe / 1460n + doe / 36524n - doe / 146096n) / 365n;
+  let y = yoe + era * 400n;
+  const doy = doe - (365n * yoe + yoe / 4n - yoe / 100n), mp = (5n * doy + 2n) / 153n;
+  const d = doy - (153n * mp + 2n) / 5n + 1n, m = mp < 10n ? mp + 3n : mp - 9n;
+  y += m <= 2n ? 1n : 0n;
+  const pad = (n, width = 2) => n < 0n ? `-${String(-n).padStart(width - 1, '0')}` : String(n).padStart(width, '0');
+  return `${pad(y, 4)}-${pad(m)}-${pad(d)}T${pad(sod / 3600n)}:${pad(sod % 3600n / 60n)}:${pad(sod % 60n)}Z`;
+}
+function origin(key) {
+  if (typeof key !== 'string') return null;
+  const parts = key.split(':');
+  if (parts[0] === 'agent' && parts.length >= 3) {
+    if (parts[2] === 'main') return { platform: 'main', chat_id: 'main', thread_id: null };
+    if (parts.length < 5) return null;
+    return { platform: parts[2], chat_id: parts[4], thread_id: ['thread', 'topic'].includes(parts[5]) && parts[6] ? parts[6] : null };
+  }
+  if (parts.length < 2) return null;
+  if (parts[0] === 'cron') return { platform: 'cron', chat_id: parts.slice(1).join(':'), thread_id: null };
+  if (parts[0] === 'hook') return { platform: 'webhook', chat_id: parts[1], thread_id: null };
+  if (parts[0] === 'acp-bridge') return { platform: 'acp', chat_id: parts.slice(1).join(':'), thread_id: null };
+  return null;
+}
+function target(delivery, row) {
+  const d = key => delivery?.[key] == null ? undefined : [delivery, key], r = key => row[key] == null ? undefined : [row, key];
+  const mode = string(value(d('mode') ?? d('kind') ?? d('type') ?? r('delivery_mode')));
+  const channel = string(value(d('channel') ?? r('delivery_channel')));
+  if (mode === 'none') return { kind: 'local' };
+  if (['last', 'origin'].includes(channel)) return { kind: 'origin' };
+  if (channel == null) return { kind: 'local' };
+  const to = d('to') ?? r('delivery_to'), thread = d('threadId') ?? d('thread_id') ?? r('delivery_thread_id');
+  return { kind: 'explicit', platform: channel, chat_id: to ? text(...to) : null, thread_id: thread ? text(...thread) : null };
+}
+function decode(row) {
+  const record = jsonObject(row.job_json), state = jsonObject(row.state_json), rawSchedule = object(record.schedule) ? record.schedule : {};
+  const schedule = rawSchedule.kind === 'every' && typeof rawSchedule.everyMs === 'number' ? { kind: 'interval', minutes: rawSchedule.everyMs / 60000 }
+    : rawSchedule.kind === 'cron' && typeof rawSchedule.expr === 'string' ? { kind: 'cron', expr: rawSchedule.expr }
+      : rawSchedule.kind === 'at' && typeof rawSchedule.at === 'string' ? { kind: 'once', run_at: rawSchedule.at } : { kind: 'cron', expr: '' };
+  const payload = object(record.payload) ? record.payload : {};
+  const delivery = object(record.delivery) ? record.delivery : Object.fromEntries([['delivery_mode', 'mode'], ['delivery_channel', 'channel'], ['delivery_to', 'to'], ['delivery_thread_id', 'threadId'], ['delivery_account_id', 'accountId']].flatMap(([column, key]) => row[column] != null && row[column] !== '' ? [[key, row[column]]] : []));
+  const omitted = new Set(['id', 'name', 'enabled', 'schedule', 'payload', 'delivery', 'sessionTarget', 'createdAtMs', 'state']);
+  const raw = Object.fromEntries(Object.keys(record).filter(key => !omitted.has(key)).map(key => [key, record[key]]));
+  if (Object.keys(payload).length) raw.__payload = payload;
+  if (object(record.delivery) || Object.keys(delivery).length) raw.__delivery = delivery;
+  const enabled = row.enabled == null ? true : typeof row.enabled === 'boolean' ? row.enabled : typeof row.enabled === 'number' ? row.enabled !== 0 : row.enabled !== '';
+  return { id: text(row, 'job_id') ?? '', raw, schedule, prompt: ['message', 'text', 'command', 'script'].map(key => string(payload[key])).find(v => v != null) ?? null,
+    deliver: target(delivery, row), origin: origin(row.owner_session_key), enabled,
+    session_target: string(record.sessionTarget) ?? string(row.session_target), next_run_at: moment(ms(row, 'next_run_at_ms') ?? ms(state, 'nextRunAtMs')),
+    last_run_at: moment(ms(row, 'last_run_at_ms') ?? ms(state, 'lastRunAtMs')), last_status: string(row.last_run_status), created_at: moment(ms(row, 'created_at_ms') ?? ms(record, 'createdAtMs')) };
+}
+function legacy(record) {
+  const modern = { ...record }, row = { job_id: ['id', 'job_id', 'jobId'].map(key => string(record[key])).find(v => v != null) ?? '' };
+  let schedule = object(modern.schedule) && Object.hasOwn(modern.schedule, 'kind') ? modern.schedule : typeof modern.schedule === 'string' ? { kind: 'cron', expr: modern.schedule } : null;
+  schedule ??= text(modern, 'cron') == null ? null : { kind: 'cron', expr: text(modern, 'cron') };
+  if (schedule == null && typeof modern.everyMinutes === 'number') { schedule = { kind: 'every' }; setNativeInteger(schedule, 'everyMs', cast(modern.everyMinutes * 60000)); }
+  if (schedule == null && typeof modern.everyMs === 'number') { schedule = { kind: 'every' }; setNativeInteger(schedule, 'everyMs', cast(modern.everyMs)); }
+  const at = first([modern, 'runAt'], [modern, 'run_at']);
+  if (schedule == null && at && text(...at) != null) schedule = { kind: 'at', at: text(...at) };
+  for (const key of ['cron', 'everyMinutes', 'everyMs', 'runAt', 'run_at']) delete modern[key];
+  if (schedule) modern.schedule = schedule;
+  if (typeof modern.delivery === 'string') modern.delivery = { mode: modern.delivery };
+  else if (object(modern.delivery)) {
+    modern.delivery = { ...modern.delivery };
+    if (!Object.hasOwn(modern.delivery, 'mode')) {
+      const field = first([modern.delivery, 'kind'], [modern.delivery, 'type']);
+      if (field) { modern.delivery.mode = value(field); delete modern.delivery[field[1]]; }
+    }
+  }
+  for (const key of ['name', 'enabled']) if (Object.hasOwn(modern, key)) row[key] = modern[key];
+  const oldMs = (record, key) => typeof record[key] === 'number' ? nativeInteger(record, key, { signed: true }) : typeof record[key] === 'string' ? (() => { const n = hermesIsoEpoch(record[key]); return n == null ? null : cast(n * 1000); })() : null;
+  for (const [old, column] of [['nextRunAt', 'next_run_at_ms'], ['next_run_at', 'next_run_at_ms'], ['lastRunAt', 'last_run_at_ms'], ['last_run_at', 'last_run_at_ms']]) if (Object.hasOwn(modern, old)) {
+    const at = oldMs(record, old); delete modern[old]; if (at != null) setNativeInteger(row, column, at);
+  }
+  const status = first([modern, 'lastStatus'], [modern, 'last_status']);
+  if (status) { row.last_run_status = value(status); delete modern[status[1]]; }
+  const created = first([modern, 'createdAt'], [modern, 'created_at']);
+  if (created) { const at = oldMs(record, created[1]); delete modern[created[1]]; if (at != null) setNativeInteger(modern, 'createdAtMs', at); }
+  // Re-emit original unmapped member tokens; spreading a native JSON object
+  // alone would turn integral REAL and large integer residue into new values.
+  const members = Object.keys(modern).map(key => `${JSON.stringify(key)}:${Object.hasOwn(record, key) && modern[key] === record[key] ? stringifyNativeJsonMember(record, key) : stringifyNativeJsonMember(modern, key)}`);
+  row.job_json = `{${members.join(',')}}`;
+  return decode(row);
+}
+export function openclawJobs(loaded) {
+  const profiles = new Map(loaded.profiles.map(name => [name, new Map()]));
+  const owner = agent => { const name = agent === loaded.defaultAgent ? 'default' : agent; return profiles.has(name) ? name : 'default'; };
+  for (const row of loaded.jobs) {
+    const record = jsonObject(row.job_json), field = first([record, 'agentId'], [row, 'agent_id'], [row, 'owner_agent_id']), name = owner(string(value(field)) ?? loaded.defaultAgent);
+    const job = decode(row); profiles.get(name).set(job.id, job);
+  }
+  let records; try { const v = parseNativeJson(loaded.legacy ?? 'null'); records = Array.isArray(v) ? v : Array.isArray(v?.jobs) ? v.jobs : []; } catch { records = []; }
+  for (const record of records) {
+    const id = ['id', 'job_id', 'jobId'].map(key => string(record?.[key])).find(v => v != null);
+    if (!id || [...profiles.values()].some(jobs => jobs.has(id))) continue;
+    const field = first([record, 'agentId'], [record, 'agent_id']), name = owner(string(value(field)) ?? loaded.defaultAgent);
+    profiles.get(name).set(id, legacy(record));
+  }
+  return profiles;
+}

package/openclaw-profile-home.mjs

@@ -0,0 +1,142 @@
+// The validity dependencies of from_openclaw, projected to profile metadata.
+// Row decoders there are infallible; every fallible source read is still made.
+// No home, transcript, queue or configuration is written or exported.
+import { readFileSync, readdirSync, lstatSync, statSync } from 'node:fs';
+import { childPath } from './session-spend-files.mjs';
+import { profilePathJoin } from './profile-paths.mjs';
+import { parseNativeJson } from './native-json.mjs';
+import { openclawTriggerRecords } from './trigger-records.mjs';
+import { openclawChannelRecords } from './channel-records.mjs';
+import { nativeTrim } from './text.mjs';
+import { hermesTableExists, readHermesRows } from './hermes-read-store.mjs';
+
+const object = value => value != null && typeof value === 'object' && !Array.isArray(value);
+const string = value => typeof value === 'string' ? value : null;
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const directory = path => { try { return statSync(path).isDirectory(); } catch { return false; } };
+const file = path => { try { return statSync(path).isFile(); } catch { return false; } };
+const whitespace = char => char != null && /^[\u0009-\u000d\u0020\u0085\u00a0\u1680\u2000-\u200a\u2028\u2029\u202f\u205f\u3000]$/u.test(char);
+
+// Match the native codec's small JSON5 scanner, including its accepted
+// single-quoted strings and ASCII keys; this is not a broader JSON5 parser.
+function stripJson5(text) {
+  const chars = [...text]; let out = '', quoted = false, escaped = false;
+  for (let at = 0; at < chars.length; at++) {
+    const ch = chars[at];
+    if (!quoted && ch === "'") {
+      out += '"'; let escape = false;
+      while (++at < chars.length) {
+        const next = chars[at];
+        if (escape) { if (next !== "'") out += '\\'; out += next; escape = false; }
+        else if (next === '\\') escape = true;
+        else if (next === "'") break;
+        else out += next === '"' ? '\\"' : next;
+      }
+      out += '"'; continue;
+    }
+    if (!quoted && /^[A-Za-z_$]$/u.test(ch)) {
+      let identifier = ch, gap = '';
+      while (at + 1 < chars.length && /^[A-Za-z0-9_$]$/u.test(chars[at + 1])) identifier += chars[++at];
+      while (whitespace(chars[at + 1])) gap += chars[++at];
+      out += ['{', ','].includes(nativeTrim(out).at(-1)) && chars[at + 1] === ':' ? JSON.stringify(identifier) : identifier;
+      out += gap; continue;
+    }
+    if (quoted) {
+      out += ch;
+      if (escaped) escaped = false; else if (ch === '\\') escaped = true; else if (ch === '"') quoted = false;
+      continue;
+    }
+    if (ch === '"') { quoted = true; out += ch; }
+    else if (ch === '/' && chars[at + 1] === '/') { while (++at < chars.length) if (chars[at] === '\n') { out += '\n'; break; } }
+    else if (ch === '/' && chars[at + 1] === '*') {
+      at++; let previous = '\0';
+      while (++at < chars.length) { if (previous === '*' && chars[at] === '/') break; previous = chars[at]; }
+      out += ' ';
+    } else out += ch;
+  }
+  const scanned = [...out]; let cleaned = ''; quoted = false; escaped = false;
+  for (let at = 0; at < scanned.length; at++) {
+    const ch = scanned[at];
+    if (quoted) {
+      cleaned += ch;
+      if (escaped) escaped = false; else if (ch === '\\') escaped = true; else if (ch === '"') quoted = false;
+      continue;
+    }
+    if (ch === '"') quoted = true;
+    if (ch === ',') { let next = at + 1; while (whitespace(scanned[next])) next++; if (['}', ']'].includes(scanned[next])) continue; }
+    cleaned += ch;
+  }
+  return cleaned;
+}
+function agentEntries(config) {
+  if (Array.isArray(config.agents?.list)) return config.agents.list.flatMap(entry => {
+    const id = string(Object.hasOwn(entry ?? {}, 'id') ? entry.id : entry?.agentId);
+    return id ? [[id, entry]] : [];
+  });
+  if (object(config.agents?.entries)) return Object.keys(config.agents.entries).sort((a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b))).map(id => [id, config.agents.entries[id]]);
+  return [];
+}
+const model = value => string(value) ?? string(value?.primary);
+function inventory(root) {
+  const walk = dir => {
+    const entries = readdirSync(dir, { encoding: 'buffer' }); entries.sort(Buffer.compare);
+    for (const entry of entries) {
+      if (['node_modules', '.git'].includes(entry.toString('utf8'))) continue;
+      const path = childPath(dir, entry); let info; try { info = lstatSync(path); } catch { continue; }
+      if (info.isDirectory()) walk(path);
+    }
+  };
+  walk(root);
+}
+function readOpenclawHome(root) {
+  if (!directory(root)) throw new Error('not a directory');
+  const configPath = childPath(root, 'openclaw.json'), present = file(configPath);
+  const config = present ? parseNativeJson(stripJson5(utf8.decode(readFileSync(configPath)))) : Object.create(null);
+  if (!object(config)) throw new Error('expected a JSON5 object');
+  let declared = agentEntries(config);
+  const defaultAgent = declared.find(([, entry]) => entry?.default === true)?.[0] ?? declared[0]?.[0] ?? 'main';
+  if (!declared.length) declared = [[defaultAgent, {}]];
+  const profiles = new Map();
+  for (const [id, entry] of declared) {
+    const name = id === defaultAgent ? 'default' : id, dir = profilePathJoin(childPath(root, 'agents'), id);
+    // These reads are tolerant of unread/malformed transcript or persona text,
+    // but read_dir on a selected sessions directory is a codec refusal.
+    try { utf8.decode(readFileSync(childPath(dir, 'AGENTS.md'))); } catch { /* no persona */ }
+    const sessions = childPath(dir, 'sessions');
+    if (directory(sessions)) for (const leaf of readdirSync(sessions, { encoding: 'buffer' }).sort(Buffer.compare)) {
+      const name = leaf.toString('utf8'); if (!name.endsWith('.jsonl') || name.endsWith('.trajectory.jsonl')) continue;
+      try { utf8.decode(readFileSync(childPath(sessions, leaf))); } catch { /* an unread transcript adds no binding */ }
+    }
+    profiles.set(name, { id, model: model(entry?.model) ?? model(config.agents?.defaults?.model) });
+  }
+  const store = childPath(root, 'state/openclaw.sqlite');
+  const rows = new Map();
+  for (const [table, order] of [
+    ['cron_jobs', 'sort_order, created_at_ms, job_id'], ['cron_run_logs', 'ts, seq'],
+    ['delivery_queue_entries', 'enqueued_at, id'], ['current_conversation_bindings', 'bound_at, binding_key'], ['schema_meta', 'meta_key'],
+  ]) if (hermesTableExists(store, table)) rows.set(table, readHermesRows(store, `select * from ${table} order by ${order}`) ?? []);
+  // Legacy jobs' decoder never refuses malformed JSON or malformed rows.
+  let legacy = null;
+  try { legacy = utf8.decode(readFileSync(childPath(root, 'cron/jobs.json'))); } catch { /* no legacy rows */ }
+  inventory(root);
+  const byAgent = new Map([...profiles.entries()].sort(([a], [b]) => Buffer.compare(Buffer.from(a), Buffer.from(b))).map(([, profile]) => [profile.id, profile]));
+  const routes = new Map();
+  if (Array.isArray(config.bindings)) for (const binding of config.bindings) if (object(binding) && typeof binding.agentId === 'string') routes.set(binding.agentId, (routes.get(binding.agentId) ?? 0n) + 1n);
+  return { defaultAgent, byAgent, profiles, rows, legacy, routes: present ? routes : null,
+    bindings: Array.isArray(config.bindings) ? config.bindings : [], triggerRecords: openclawTriggerRecords(config, profiles, defaultAgent), channelRecords: openclawChannelRecords(config) };
+}
+export function readOpenclawProfileHome(root) {
+  const { defaultAgent, byAgent, routes } = readOpenclawHome(root);
+  return { defaultAgent, byAgent, routes };
+}
+export function readOpenclawRunHome(root) {
+  const { defaultAgent, profiles, rows, legacy } = readOpenclawHome(root);
+  return { defaultAgent, profiles: [...profiles.keys()], jobs: rows.get('cron_jobs') ?? [],
+    fires: rows.get('cron_run_logs') ?? [], legacy };
+}
+export function readOpenclawTriggerHome(root) { return readOpenclawHome(root).triggerRecords; }
+export function readOpenclawChannelHome(root) { return readOpenclawHome(root).channelRecords; }
+export function readOpenclawRouteHome(root) {
+  const { defaultAgent, profiles, bindings } = readOpenclawHome(root);
+  return { defaultAgent, profiles, bindings };
+}

package/orchestrator-read-records.mjs

@@ -0,0 +1,112 @@
+// Serde record admission used by the read-only folder projection. This does
+// not run a workflow, validate relationships, or write an agent layer.
+import { nativeInteger, nativeDuplicateObjectKeys, parseNativeJson, stringifyNativeJsonMember } from './native-json.mjs';
+
+const fail = () => { throw new Error('invalid orchestrator record'); };
+const object = value => value != null && typeof value === 'object' && !Array.isArray(value);
+const string = value => { if (typeof value !== 'string') fail(); };
+const optional = validator => (value, parent, key) => { if (value != null) validator(value, parent, key); };
+const any = () => {};
+const unsigned = (value, parent, key) => { if (nativeInteger(parent, key) == null) fail(); };
+const number = value => { if (typeof value !== 'number') fail(); };
+const enumeration = words => value => {
+  if (words.includes(value)) return;
+  if (!object(value) || Object.keys(value).length !== 1 || !words.includes(Object.keys(value)[0]) || value[Object.keys(value)[0]] !== null) fail();
+};
+const list = validator => value => { if (!Array.isArray(value)) fail(); value.forEach((item, at) => validator(item, value, String(at))); };
+const map = validator => value => { if (!object(value)) fail(); for (const key of Object.keys(value)) validator(value[key], value, key); };
+let directRead = false;
+function record(fields, required = [], strict = false, direct = false) {
+  return value => {
+    if (Array.isArray(value)) {
+      if (value.length > fields.length) fail();
+      value = parseNativeJson(`{${value.map((_, at) => `${JSON.stringify(fields[at][0])}:${stringifyNativeJsonMember(value, String(at))}`).join(',')}}`);
+    }
+    if (!object(value)) fail();
+    const known = new Set(fields.map(([key]) => key));
+    if (strict && Object.keys(value).some(key => !known.has(key))) fail();
+    if ((direct || directRead) && nativeDuplicateObjectKeys(value).some(key => known.has(key))) fail();
+    for (const key of required) if (!Object.hasOwn(value, key)) fail();
+    for (const [key, validator] of fields) if (Object.hasOwn(value, key)) validator(value[key], value, key);
+    return value;
+  };
+}
+function tagged(variants) {
+  return value => {
+    if (!object(value) || !Object.hasOwn(variants, value.kind) || directRead && nativeDuplicateObjectKeys(value).includes('kind')) fail();
+    variants[value.kind](value);
+  };
+}
+const strings = names => names.map(name => [name, string]);
+const optionStrings = names => names.map(name => [name, optional(string)]);
+const surface = record(optionStrings(['key', 'platform', 'kind', 'chat_id', 'thread_id', 'participant_id']));
+function surfaceRecord(value) {
+  const out = surface(value);
+  if (Object.hasOwn(out, 'kind') && Object.hasOwn(out, 'chat_type')) fail();
+  if (Object.hasOwn(out, 'chat_type')) optional(string)(out.chat_type);
+  if (directRead && nativeDuplicateObjectKeys(out).includes('chat_type')) fail();
+  return out;
+}
+const cost = record([['amount', number], ['currency', string], ['source', optional(string)]], ['amount', 'currency']);
+const usage = record([
+  ...strings(['at', 'model']), ['input_tokens', unsigned], ['output_tokens', unsigned],
+  ['cache_read_tokens', optional(unsigned)], ['cache_write_tokens', optional(unsigned)], ['cost', optional(cost)],
+], ['at', 'model', 'input_tokens', 'output_tokens']);
+const participant = record([
+  ['principal', string], ['role', enumeration(['to', 'cc'])], ['since', string], ['until', optional(string)],
+], ['principal', 'role', 'since']);
+const speaker = tagged({
+  addressed: record([['default', optional(string)]]), all: record([]),
+  round_robin: record([['order', list(string)]], ['order']),
+  selector: record([['selector', string]], ['selector']), floor: record([]),
+});
+const history = tagged({ platform: record([]), mailbox: record([['thread', string]], ['thread']), transcript: record([['session', string]], ['session']) });
+const agent = record([...strings(['name', 'profile']), ...optionStrings(['label', 'parent', 'sponsor']), ['residue', map(any)]], ['name', 'profile'], false, true);
+const conversation = record([
+  ['id', string], ['kind', enumeration(['thread', 'private'])], ['surface', optional(surfaceRecord)],
+  ['participants', list(participant)], ['speaker', speaker], ['history', history], ...optionStrings(['holder', 'last_speaker']),
+], ['id', 'kind'], false, true);
+const transfer = record([
+  ...strings(['conversation', 'from', 'to', 'by', 'reason']), ['history', enumeration(['full', 'filtered', 'none'])],
+  ['filter', any], ['state', enumeration(['pending', 'done', 'refused'])], ['at', string], ['error', optional(string)],
+], ['conversation', 'from', 'to', 'by', 'reason', 'history', 'state', 'at'], false, true);
+const handoff = record([
+  ...strings(['session', 'to', 'by']), ['state', enumeration(['pending', 'done', 'failed'])], ['error', optional(string)], ['at', string],
+], ['session', 'to', 'by', 'state', 'at'], false, true);
+const agentLayer = record([
+  ['agents', map(agent)], ['conversations', map(conversation)], ['transfers', list(transfer)], ['handoffs', list(handoff)],
+  ['usage', map(record([['agent', optional(string)], ['usage', list(usage)]], [], false, true))],
+], [], true, true);
+
+export function validateOrchestratorAgentLayer(text) {
+  directRead = true;
+  try { agentLayer(parseNativeJson(text)); } finally { directRead = false; }
+}
+
+const binding = record([
+  ['key', surfaceRecord], ['profile', optional(string)], ['conversation', optional(string)], ['agent', optional(string)],
+  ['worker', record([['harness', string], ...optionStrings(['session_id', 'locator'])], ['harness'])],
+  ['trigger', enumeration(['human', 'channel', 'cron', 'heartbeat', 'webhook', 'parent', 'api', 'task', 'unknown'])],
+  ['recurrence', optional(record([['job_id', string], ['kind', string]], ['job_id']))],
+  ['handoff', optional(record([['to', optional(string)], ['state', string], ['error', optional(string)]], ['state']))],
+  ...optionStrings(['started_at', 'last_activity_at', 'ended_at']),
+  ['end_reason', optional(enumeration(['idle', 'daily', 'reset', 'new', 'handoff', 'transfer', 'left', 'error']))], ['residue', map(any)],
+], ['key', 'worker']);
+export function orchestratorRoutingSlot(row) {
+  try {
+    if (typeof row.entry_json !== 'string') return null;
+    const entry = parseNativeJson(row.entry_json);
+    const sc = entry?.metadata?.supercode;
+    let key;
+    if (sc !== undefined) {
+      const value = binding(sc?.binding); key = surfaceRecord(value.key);
+      if (typeof sc.slot === 'string') return sc.slot;
+    } else {
+      if (typeof entry?.session_key !== 'string') return null;
+      const parts = entry.session_key.split(':');
+      if (parts.length < 4 || parts[0] !== 'agent') return null;
+      key = { platform: parts[2], kind: parts[3], chat_id: parts[4], thread_id: parts[5], participant_id: parts[6] };
+    }
+    return [key.platform, key.kind ?? key.chat_type, key.chat_id, key.thread_id, key.participant_id].map(value => value ?? '').join('|');
+  } catch { return null; }
+}

package/orchestrator-store.mjs

@@ -1,5 +1,5 @@
 import { realpathSync } from 'node:fs';
-import { dirname, join } from 'node:path';
+import { dirname, join, toNamespacedPath } from 'node:path';
 import { readStore, statement, text, integer, unsigned, jsonColumn } from './sqlite-reader.mjs';
 import { finalizeNouns } from './metadata.mjs';
 
@@ -10,15 +10,18 @@ const object = (value) => value != null && typeof value === 'object' && !Array.i
 const nonempty = (value) => typeof value === 'string' && value !== '' ? value : null;
 const columns = "json_extract(g.entry_json, '$.metadata.supercode.binding') AS binding, CAST(strftime('%s', json_extract(g.entry_json, '$.metadata.supercode.binding.last_activity_at')) AS INTEGER) AS epoch";
 
-function routingScope(path) {
+function routingScope(path, surfaceOnly) {
   const sessions = join(dirname(path), 'sessions');
-  try { return realpathSync.native(sessions); } catch { return sessions; }
+  try {
+    const resolved = realpathSync.native(sessions);
+    return surfaceOnly && process.platform === 'win32' ? toNamespacedPath(resolved) : resolved;
+  } catch { return sessions; }
 }
 
 /** Binding's required records and native enum fields are validated before
  * projection. A malformed routing binding is omitted, as by the native codec;
  * its routing key/change position still belongs to the source snapshot. */
-function bindingDescriptor(path, profile, raw, epoch) {
+function bindingDescriptor(path, profile, raw, epoch, surfaceOnly) {
   const binding = jsonColumn(raw);
   if (!object(binding) || !object(binding.key) || !object(binding.worker) || typeof binding.worker.harness !== 'string') return null;
   if (['key', 'platform', 'kind', 'chat_type', 'chat_id', 'thread_id', 'participant_id'].some((field) => !optionalText(binding.key[field]))) return null;
@@ -45,7 +48,11 @@ function bindingDescriptor(path, profile, raw, epoch) {
   let title = `${binding.worker.harness} ${id ?? '(no worker session yet)'}`;
   if (binding.end_reason != null && binding.ended_at != null) title += ` (ended: ${binding.end_reason})`;
   const state = binding.handoff?.state, destination = binding.handoff?.to, error = binding.handoff?.error;
-  const at = epoch == null ? null : unsigned(integer(epoch) < 0n ? 0n : epoch);
+  // A channel count needs the native binding validity and surface, but does
+  // not publish an epoch. Keep integer validation without rounding or using
+  // the metadata index's narrower Number range in that projection.
+  const seconds = epoch == null ? null : integer(epoch);
+  const at = surfaceOnly || seconds == null ? null : unsigned(seconds < 0n ? 0n : seconds);
   if (at != null && !Number.isSafeInteger(at * 1000)) throw new Error(`${path} has an activity epoch outside the exact Node wire range`);
   return finalizeNouns({ locator: { harness: 'orchestrator', session_id: id ?? '', storage: { kind: 'file', path: locator ?? path } },
     cwd: null, title, updated_at_ms: at == null ? null : at * 1000, model: null, message_count: null,
@@ -55,11 +62,11 @@ function bindingDescriptor(path, profile, raw, epoch) {
 
 /** Routing keys are the source-row keys; several bindings may address the
  * same worker id. Do not discard them by deduplicating native session ids. */
-export async function readOrchestratorStore(path, profile, { after, metrics = {} } = {}) {
+export async function readOrchestratorStore(path, profile, { after, metrics = {}, surfaceOnly = false } = {}) {
   return readStore(path, (db) => {
     const hasChanges = db.prepare("SELECT 1 FROM sqlite_master WHERE type='table' AND name='supercode_routing_changes'").get() != null;
     const sequence = hasChanges ? integer(statement(db, 'SELECT COALESCE(MAX(seq),0) AS seq FROM supercode_routing_changes').get().seq) : 0n;
-    const scope = routingScope(path);
+    const scope = routingScope(path, surfaceOnly);
     let values, incremental = after != null && hasChanges;
     if (incremental) {
       const cursor = BigInt(after);
@@ -71,8 +78,13 @@ export async function readOrchestratorStore(path, profile, { after, metrics = {}
       values = statement(db, `SELECT g.session_key, 0 AS deleted, ${columns} FROM gateway_routing g
         WHERE g.scope=? AND json_extract(g.entry_json, '$.metadata.supercode') IS NOT NULL`).all(scope);
     }
-    const rows = values.map((value) => ({ key: text(value.session_key),
-      descriptor: integer(value.deleted) !== 0n ? null : bindingDescriptor(path, profile, value.binding, value.epoch) }));
+    const rows = values.map((value) => {
+      // The native full catalog query validates both columns before decoding
+      // the binding. A bad SQL type refuses the store, even on an invalid row.
+      if (surfaceOnly) { text(value.binding, true); integer(value.epoch, true); }
+      return { key: text(value.session_key),
+        descriptor: integer(value.deleted) !== 0n ? null : bindingDescriptor(path, profile, value.binding, value.epoch, surfaceOnly) };
+    });
     metrics.store_sessions_read = (metrics.store_sessions_read ?? 0) + values.length;
     return { rows, cursor: String(sequence), incremental, has_changes: hasChanges };
   }, metrics);

package/package.json

@@ -1,10 +1,30 @@
 {
   "name": "@volter/supercode-interchange",
-  "version": "0.1.21",
+  "version": "0.1.23",
   "type": "module",
-  "description": "Read-only harness metadata, transcript codecs and session projections for Supercode",
+  "description": "Harness metadata, lossless transcript codecs and session projections for Supercode",
   "license": "MIT OR Apache-2.0",
   "exports": {
+    "./session-convert": {
+      "types": "./session-convert.d.ts",
+      "import": "./session-convert.mjs"
+    },
+    "./session-write": {
+      "types": "./session-write.d.ts",
+      "import": "./session-write.mjs"
+    },
+    "./corpus-audit": {
+      "types": "./corpus-audit.d.ts",
+      "import": "./corpus-audit.mjs"
+    },
+    "./parity-report": {
+      "types": "./parity-report.d.ts",
+      "import": "./parity-report.mjs"
+    },
+    "./ontology-contracts": {
+      "types": "./ontology-contracts.d.ts",
+      "import": "./ontology-contracts.mjs"
+    },
     ".": {
       "types": "./index.d.ts",
       "import": "./index.mjs"
@@ -21,23 +41,58 @@
       "types": "./session-read.d.ts",
       "import": "./session-read.mjs"
     },
+    "./session-machine-tree": {
+      "types": "./session-machine-tree.d.ts",
+      "import": "./session-machine-tree.mjs"
+    },
+    "./hermes-activity-home": {
+      "types": "./hermes-read-home.d.ts",
+      "import": "./hermes-read-home.mjs"
+    },
+    "./session-activity": {
+      "types": "./session-activity.d.ts",
+      "import": "./session-activity.mjs"
+    },
+    "./session-codex-activity": {
+      "types": "./session-codex-activity.d.ts",
+      "import": "./session-codex-activity.mjs"
+    },
     "./session-claude-runtime": {
       "types": "./session-claude-runtime.d.ts",
       "import": "./session-claude-runtime.mjs"
+    },
+    "./session-inspect": {
+      "types": "./session-inspect.d.ts",
+      "import": "./session-inspect.mjs"
+    },
+    "./inspection-schemas": {
+      "types": "./inspection-schemas.d.ts",
+      "import": "./inspection-schemas.mjs"
     }
   },
   "files": [
     "*.mjs",
     "*.d.ts",
+    "support-registry.json",
+    "parity-ledger.json",
+    "parity-orchestration.json",
+    "ontology-schemas.json",
+    "ontology-operations.json",
+    "session-emission-version.json",
     "README.md",
+    "LICENSE-diffy-MIT",
     "LICENSE-MIT",
-    "LICENSE-APACHE"
+    "LICENSE-APACHE",
+    "inspection-config-fields.json",
+    "inspection-builtin-tools.json"
   ],
   "engines": {
     "node": ">=22.15.0"
   },
   "dependencies": {
     "@noble/hashes": "2.4.0",
-    "saxes": "6.0.0"
+    "saxes": "6.0.0",
+    "smol-toml": "1.9.1",
+    "yaml": "2.9.0"
   }
 }