@volter/supercode-interchange 0.1.22 → 0.1.23

package/parity-report.d.ts

@@ -0,0 +1,7 @@
+export type ParityPreset = 'cc-parity' | 'cx-parity' | 'hermes' | 'openclaw' | 'orchestrator';
+export type ParityStatus = 'implemented' | 'partial' | 'absent' | 'irreducible' | 'not_applicable' | 'unaudited';
+export interface ParityGap { id: string; domain: number; capability: string; status: ParityStatus; cost?: 'trivial' | 'architectural'; note: string }
+export interface ParityReport { summary: { preset: ParityPreset; harness_column: string; rows: number; counts: Partial<Record<ParityStatus, number>>; gaps: number }; gaps: ParityGap[] }
+export const PARITY_PRESETS: readonly ParityPreset[];
+export function parityReport(preset: string): ParityReport | undefined;
+export function formatParityReport(report: ParityReport, options?: { json?: boolean }): string;

package/parity-report.mjs

@@ -0,0 +1,46 @@
+// The frozen ledgers are an audited inventory, not a runtime verification.
+import { readFileSync } from 'node:fs';
+import { parseNativeJson, stringifyNativeJsonPretty } from './native-json.mjs';
+
+const catalog = parseNativeJson(readFileSync(new URL('./parity-ledger.json', import.meta.url), 'utf8'));
+const orchestration = parseNativeJson(readFileSync(new URL('./parity-orchestration.json', import.meta.url), 'utf8'));
+export const PARITY_PRESETS = Object.freeze(['cc-parity', 'cx-parity', 'hermes', 'openclaw', 'orchestrator']);
+const gaps = new Set(['partial', 'absent', 'irreducible', 'unaudited']);
+const labels = ['implemented', 'partial', 'absent', 'irreducible', 'not_applicable', 'unaudited'];
+
+/** Fresh report over committed rows, preserving the native denominator and row order. */
+export function parityReport(preset) {
+  if (!PARITY_PRESETS.includes(preset)) return undefined;
+  const column = preset === 'cc-parity' ? 'cc' : preset === 'cx-parity' ? 'cx' : preset;
+  const own = preset === 'orchestrator', gateway = column !== 'cc' && column !== 'cx';
+  const rows = (gateway ? orchestration : catalog).filter(row => own || row[column] !== 'no');
+  const counts = new Map(), missing = [];
+  for (const row of rows) {
+    const status = own ? row.orchestrator_status : row.status;
+    counts.set(status, (counts.get(status) ?? 0) + 1);
+    if (!gaps.has(status)) continue;
+    const cost = own ? row.orchestrator_cost : row.cost;
+    missing.push({ id: row.id, domain: gateway ? 11 : row.domain,
+      capability: row.capability, status, ...(cost == null ? {} : { cost }),
+      note: (own ? row.orchestrator_note : row.note) ?? '' });
+  }
+  return { summary: { preset, harness_column: column, rows: rows.length,
+    counts: Object.fromEntries([...counts].sort(([a], [b]) => a < b ? -1 : a > b ? 1 : 0)), gaps: missing.length }, gaps: missing };
+}
+
+export function formatParityReport(report, { json = false } = {}) {
+  if (json) return `${stringifyNativeJsonPretty(report)}\n`;
+  const summary = report.summary;
+  let text = `${summary.preset}: ${summary.rows} rows · ${summary.gaps} gaps`;
+  for (const status of labels) if (Object.hasOwn(summary.counts, status)) text += ` · ${summary.counts[status]} ${status}`;
+  text += '\n';
+  let domain = 0;
+  for (const row of report.gaps) {
+    if (row.domain !== domain) { domain = row.domain; text += `\nDomain ${domain}\n`; }
+    const cost = row.cost === 'trivial' ? ' [trivial]' : row.cost === 'architectural' ? ' [architectural]' : '';
+    text += `  ${row.status.padEnd(12)}${cost} ${row.capability} (${row.id})`;
+    if (row.note) text += ` — ${row.note}`;
+    text += '\n';
+  }
+  return text;
+}

package/preset-profiles.mjs

@@ -0,0 +1,27 @@
+// Generated by scripts/preset-profiles.mjs from crates/harness/src/presets.rs.
+export const PRESET_PROFILES = Object.freeze([
+  {
+    "name": "cc-parity",
+    "model": "anthropic/claude-opus-4-8"
+  },
+  {
+    "name": "cx-parity",
+    "model": null
+  },
+  {
+    "name": "oc-parity",
+    "model": null
+  },
+  {
+    "name": "pi-core",
+    "model": null
+  },
+  {
+    "name": "supercode-default",
+    "model": null
+  },
+  {
+    "name": "token-saver",
+    "model": null
+  }
+]);

package/profile-command.mjs

@@ -0,0 +1,32 @@
+// Profile commands run directly with null stdin, in the caller's selected
+// environment. Only the child created here is stopped when that caller closes.
+import { spawn } from 'node:child_process';
+import { nativeTrim } from './text.mjs';
+
+export const profileCommandFailure = message => { throw Object.assign(new Error(message), { rpcCode: -32000 }); };
+export const profileShellQuote = value => value && /^[A-Za-z0-9\-_./:@=+,]+$/u.test(value) ? value : `'${value.replaceAll("'", "'\\''")}'`;
+export const profileCommandStatus = output => output.signal ? `signal: ${output.signal}` : process.platform === 'win32' ? `exit code: ${output.code}` : `exit status: ${output.code}`;
+export async function runProfileCommand(command, context) {
+  const closed = () => profileCommandFailure(`${command.owner ?? 'profile'} client closed before the harness command answered`);
+  if (context.signal?.aborted) closed();
+  const output = await new Promise((resolve, reject) => {
+    let child, force; const stdout = [], stderr = [];
+    try { child = spawn(command.program, command.args, { cwd: context.cwd, env: command.env ?? context.env, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true }); }
+    catch (error) { reject(error); return; }
+    const abort = () => { child.kill('SIGTERM'); force = setTimeout(() => child.kill('SIGKILL'), 500); };
+    child.stdout.on('data', data => stdout.push(data)); child.stderr.on('data', data => stderr.push(data));
+    child.once('error', reject);
+    child.once('close', (code, signal) => {
+      clearTimeout(force); context.signal?.removeEventListener('abort', abort);
+      resolve({ code, signal, stdout: Buffer.concat(stdout).toString('utf8'), stderr: Buffer.concat(stderr).toString('utf8') });
+    });
+    context.signal?.addEventListener('abort', abort, { once: true }); if (context.signal?.aborted) abort();
+  }).catch(error => profileCommandFailure(`\`${command.ran}\` could not be executed: ${error.message}`));
+  if (context.signal?.aborted) closed();
+  return output;
+}
+export function requireProfileCommandSuccess(command, output) {
+  if (output.code === 0) return;
+  const detail = nativeTrim(output.stderr) || nativeTrim(output.stdout) || 'the harness printed nothing';
+  profileCommandFailure(`\`${command.ran}\` failed (${profileCommandStatus(output)}): ${detail}`);
+}

package/profile-orchestrator-door.mjs

@@ -0,0 +1,104 @@
+// The orchestrator package owns profile writes. This client selects its live
+// socket or cold operator entry; it never edits a profile folder itself.
+import { readFileSync, statSync } from 'node:fs';
+import { connect } from 'node:net';
+import { hostname } from 'node:os';
+import { dirname, basename, isAbsolute, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { createRequire } from 'node:module';
+import { parseNativeJson, nativeInteger, nativeDuplicateObjectKeys, stringifyNativeJson } from './native-json.mjs';
+import { profilePathJoin } from './profile-paths.mjs';
+import { nativeTrim } from './text.mjs';
+import { profileCommandFailure as failed, profileShellQuote as quote, runProfileCommand, profileCommandStatus } from './profile-command.mjs';
+
+const utf8 = new TextDecoder('utf-8', { fatal: true, ignoreBOM: true });
+const actual = (path, cwd) => !path.length || isAbsolute(path) || process.platform === 'win32' && /^[A-Za-z]:/u.test(path) ? path : profilePathJoin(cwd, path);
+const file = path => { try { return statSync(path).isFile(); } catch { return false; } };
+const exists = path => { try { statSync(path); return true; } catch { return false; } };
+function liveLease(root, context) {
+  let lease;
+  try { lease = parseNativeJson(utf8.decode(readFileSync(actual(profilePathJoin(root, 'orchestrator.lock'), context.cwd)))); } catch { return false; }
+  // Lease is read as a typed struct, unlike the RPC Value followed by a struct.
+  const fields = ['pid', 'started_at', 'root', 'host', 'boot'];
+  if (Array.isArray(lease)) {
+    if (lease.length < 3 || lease.length > fields.length) return false;
+    const pid = nativeInteger(lease, '0'); lease = Object.fromEntries(lease.map((value, at) => [fields[at], value])); lease.pid = pid;
+  } else {
+    if (lease == null || typeof lease !== 'object' || nativeDuplicateObjectKeys(lease).some(key => fields.includes(key))) return false;
+    lease = { ...lease, pid: nativeInteger(lease, 'pid') };
+  }
+  if (lease.pid == null || lease.pid < 0n || lease.pid > 0xffffffffn || typeof lease.started_at !== 'string' || typeof lease.root !== 'string'
+    || lease.host != null && typeof lease.host !== 'string' || lease.boot != null && typeof lease.boot !== 'string') return false;
+  const host = process.platform === 'win32' ? context.env.COMPUTERNAME ?? null : hostname() || null;
+  if (lease.host != null && lease.host !== host) return false;
+  let boot; try { boot = nativeTrim(utf8.decode(readFileSync('/proc/sys/kernel/random/boot_id'))); } catch { /* no boot identity on this platform */ }
+  if (lease.boot != null && boot != null && lease.boot !== boot) return false;
+  if (process.platform === 'win32') return true;
+  if (lease.pid === 0n) return false;
+  const pid = Number(lease.pid); try { process.kill(pid > 0x7fffffff ? pid - 0x100000000 : pid, 0); return true; } catch { return false; }
+}
+function interpret(ran, door, line) {
+  let value; try { value = parseNativeJson(line); }
+  catch (error) { throw Object.assign(new Error(`\`${ran}\` answered something that is not JSON: ${error.message}`), { rpcCode: -32000, brokenDoor: true }); }
+  if (value?.ok === true) return { ran, door, result: value.result ?? null };
+  throw Object.assign(new Error(typeof value?.error === 'string' ? value.error : `\`${ran}\` answered \`${line}\``), { rpcCode: -32000, refusedDoor: true });
+}
+function live(socketPath, op, args, profile, context) {
+  const ran = `${socketPath} ${op} --profile ${profile} --json ${quote(stringifyNativeJson(args))}`;
+  return new Promise((resolve, reject) => {
+    let socket, settled = false; const buffers = [];
+    const finish = (error, answer) => {
+      if (settled) return; settled = true; context.signal?.removeEventListener('abort', abort); socket?.destroy(); error ? reject(error) : resolve(answer);
+    };
+    const abort = () => finish(Object.assign(new Error(`${context.owner ?? 'profile'} client closed before the orchestrator answered`), { rpcCode: -32000, closedDoor: true }));
+    if (context.signal?.aborted) { abort(); return; }
+    try { socket = connect(actual(socketPath, context.cwd)); }
+    catch (error) { finish(error); return; }
+    context.signal?.addEventListener('abort', abort, { once: true }); if (context.signal?.aborted) { abort(); return; }
+    const answer = line => { try { finish(null, interpret(ran, 'live', nativeTrim(line))); } catch (error) { finish(error); } };
+    const read = bytes => { try { answer(utf8.decode(bytes)); } catch (error) { finish(error); } };
+    socket.once('connect', () => socket.write(`${stringifyNativeJson({ op, args, profile })}\n`));
+    socket.on('data', data => {
+      buffers.push(data); const bytes = Buffer.concat(buffers), newline = bytes.indexOf(10);
+      if (newline >= 0) read(bytes.subarray(0, newline));
+    });
+    socket.once('error', error => finish(error));
+    socket.once('end', () => {
+      let line; try { line = utf8.decode(Buffer.concat(buffers)); } catch (error) { finish(error); return; }
+      if (nativeTrim(line)) answer(line); else finish(new Error(`\`${ran}\`: the orchestrator closed the connection without answering`));
+    });
+    socket.once('close', () => { if (!settled) finish(new Error(`\`${ran}\`: the orchestrator closed the connection without answering`)); });
+  });
+}
+function entry(context) {
+  const searched = [], take = path => { if (file(actual(path, context.cwd))) return path; searched.push(path); return null; };
+  if (context.env.SUPERCODE_ORCHESTRATOR_ENTRY != null) {
+    const found = take(context.env.SUPERCODE_ORCHESTRATOR_ENTRY); if (found != null) return found;
+  }
+  const roots = []; let root = dirname(fileURLToPath(import.meta.url));
+  for (;;) { roots.push(root); const parent = dirname(root); if (parent === root) break; root = parent; }
+  for (const parent of roots) { const found = take(join(parent, 'sdk', 'orchestrator', 'bin', 'orchestrator.mjs')); if (found != null) return found; }
+  for (const parent of roots) if (basename(parent) === 'node_modules') {
+    const found = take(join(parent, '@volter', 'supercode-orchestrator', 'bin', 'orchestrator.mjs')); if (found != null) return found;
+  }
+  try {
+    const resolved = createRequire(import.meta.url).resolve('@volter/supercode-orchestrator/package.json');
+    const found = take(join(dirname(resolved), 'bin', 'orchestrator.mjs')); if (found != null) return found;
+  } catch { /* package without an exported manifest is covered by module ancestry */ }
+  failed(`the orchestrator's write door is its own package, and it could not be located: the orchestrator daemon entry was not found (searched: ${searched.join(', ')})`);
+}
+export async function callProfileOrchestrator(root, op, args, context, profile = 'default') {
+  const socketPath = context.env.SUPERCODE_ORCHESTRATOR_SOCK || profilePathJoin(root, 'orchestrator.sock');
+  if (process.platform !== 'win32' && liveLease(root, context) && exists(actual(socketPath, context.cwd))) {
+    try { return await live(socketPath, op, args, profile, context); }
+    catch (error) { if (error.refusedDoor || error.closedDoor || context.signal?.aborted) throw error; /* broken socket uses the package's cold door */ }
+  }
+  const program = nativeTrim(context.env.SUPERCODE_NODE_BIN ?? '') || 'node';
+  const argv = [entry(context), op, '--root', root, '--profile', profile, '--json', stringifyNativeJson(args)];
+  const ran = [program, ...argv].map(quote).join(' '), output = await runProfileCommand({ program, args: argv, ran, owner: context.owner }, context);
+  // The package's last nonempty JSON line is authoritative even on a nonzero
+  // exit, just as in the replaced operator client.
+  const line = output.stdout.split('\n').reverse().find(line => nativeTrim(line));
+  if (line === undefined) failed(`\`${ran}\` printed nothing (${profileCommandStatus(output)})${nativeTrim(output.stderr) ? `: ${nativeTrim(output.stderr)}` : ''}`);
+  return interpret(ran, 'cold', nativeTrim(line));
+}

package/profile-paths.mjs

@@ -0,0 +1,25 @@
+// PathBuf's lexical join/parent rules. Reads retain spelling and '..'; they
+// never canonicalize a profile name into a different selected home.
+import { childPath } from './session-spend-files.mjs';
+const prefixOf = path => process.platform === 'win32' ? /^(?:\\\\[?.]\\(?:UNC\\[^\\]+\\[^\\]+|[A-Za-z]:|[^\\]+)|\\\\[^\\/]+[\\/][^\\/]+|[A-Za-z]:)/iu.exec(path)?.[0] ?? '' : '';
+const separator = char => char === '/' || process.platform === 'win32' && char === '\\';
+export function profilePathJoin(root, name) {
+  const parent = Buffer.isBuffer(root) ? root.toString('utf8') : root, child = Buffer.isBuffer(name) ? name.toString('utf8') : name;
+  if (process.platform === 'win32' && prefixOf(child)) return child;
+  if (separator(child[0])) return process.platform === 'win32' ? prefixOf(parent) + child : child;
+  return childPath(root, name).toString('utf8');
+}
+export function profilePathParent(path) {
+  const prefix = prefixOf(path).length, rooted = separator(path[prefix]), minimum = prefix + Number(rooted);
+  let end = path.length;
+  while (end > minimum && separator(path[end - 1])) end--;
+  for (;;) {
+    if (end <= minimum) return null;
+    let begin = end; while (begin > prefix && !separator(path[begin - 1])) begin--;
+    if (path.slice(begin, end) !== '.' || begin === prefix) {
+      end = begin; while (end > minimum && separator(path[end - 1])) end--;
+      return path.slice(0, end);
+    }
+    end = begin; while (end > minimum && separator(path[end - 1])) end--;
+  }
+}

package/profiles-control.mjs

@@ -0,0 +1,98 @@
+// Controlled profiles belong to their harness's CLI/operator package. The
+// existing profile reader establishes the outcome after that command answers.
+import { resolveHarnessHomes } from './homes.mjs';
+import { listProfiles, PROFILE_HARNESSES } from './profiles-read.mjs';
+import { profilePathJoin, profilePathParent } from './profile-paths.mjs';
+import { nativeTrim } from './text.mjs';
+import { supportRegistryReport } from './support-report.mjs';
+import { callProfileOrchestrator } from './profile-orchestrator-door.mjs';
+import { profileCommandFailure as failed, profileShellQuote as quote, runProfileCommand, requireProfileCommandSuccess } from './profile-command.mjs';
+
+export const CONTROLLED_PROFILE_HARNESSES = Object.freeze(['hermes', 'openclaw', 'orchestrator']);
+const invalid = message => { throw Object.assign(new Error(message), { rpcCode: -32602 }); };
+const unsupported = message => { throw Object.assign(new Error(message), { rpcCode: -32020 }); };
+const display = path => Buffer.isBuffer(path) ? path.toString('utf8') : path;
+function struct(value, fields, name) {
+  if (Array.isArray(value)) {
+    if (value.length > fields.length) invalid(`${name} has too many fields`);
+    return Object.fromEntries(value.map((entry, at) => [fields[at], entry]));
+  }
+  if (value == null || typeof value !== 'object') invalid(`${name} must be a struct`);
+  return value;
+}
+function mutationParams(params, context) {
+  const value = struct(params, ['harness', 'name', 'from', 'workspace', 'homes'], 'profile mutation');
+  for (const key of ['harness', 'name']) if (typeof value[key] !== 'string') invalid(`${key} must be a string`);
+  if (Object.hasOwn(value, 'from') && Object.hasOwn(value, 'template')) invalid('duplicate field `from`');
+  const from = Object.hasOwn(value, 'from') ? value.from : value.template;
+  if (from != null && typeof from !== 'string') invalid('from must be a string');
+  if (value.workspace != null && typeof value.workspace !== 'string') invalid('workspace must be a string');
+  const homes = Object.fromEntries(Object.entries(resolveHarnessHomes(context.env)).map(([key, path]) => [key, display(path)]));
+  if (Object.hasOwn(value, 'homes')) {
+    const supplied = struct(value.homes, Object.keys(homes), 'homes');
+    for (const key of Object.keys(homes)) if (Object.hasOwn(supplied, key)) {
+      if (typeof supplied[key] !== 'string') invalid(`homes.${key} must be a string`);
+      homes[key] = supplied[key];
+    }
+  }
+  return { ...value, from, homes };
+}
+function unsupportedHarness(harness) {
+  if (harness === 'codex') unsupported('codex profiles are file-authored: a profile IS a `[profiles.<name>]` table in `$CODEX_HOME/config.toml`, created by adding that table and deleted by removing it. Codex publishes no `codex profile create|delete` verb a client can call, so supercode names the door rather than editing another harness\'s config file behind its back');
+  if (harness === 'supercode') unsupported('a supercode preset is CODE — one of the compiled-in preset bundles, not a config home a verb can make or remove. supercode publishes no preset create/delete verb, so the profile noun refuses rather than inventing one');
+  unsupported(`harness \`${harness}\` has no profile concept (profiles exist for: ${PROFILE_HARNESSES.join(', ')})`);
+}
+function harnessProgram(harness, context) {
+  const override = nativeTrim(context.env[harness === 'hermes' ? 'SUPERCODE_HERMES_BIN' : 'SUPERCODE_OPENCLAW_BIN'] ?? '');
+  if (override) return override;
+  const program = supportRegistryReport(context).harnesses.find(row => row.id === harness)?.runtime?.default_launch?.program;
+  if (program == null) unsupported(`the registry has no launch for \`${harness}\`, so its CLI cannot be located`);
+  return program.replace(/-acp$/u, '');
+}
+function command(verb, mutation, name, context) {
+  const env = { ...context.env }, args = []; let program;
+  if (mutation.harness === 'hermes') {
+    if (mutation.workspace != null) unsupported('a hermes profile IS its own home (`HERMES_HOME/profiles/<name>`); `hermes profile create` has no workspace flag, so Volter Harness refuses rather than dropping the field');
+    program = harnessProgram('hermes', context); env.HERMES_HOME = profilePathParent(mutation.homes.hermes) ?? '.'; args.push('profile');
+    if (verb === 'create') {
+      args.push('create'); const from = nativeTrim(mutation.from ?? ''); if (from) args.push('--clone-from', from); args.push('--no-alias', name);
+    } else args.push('delete', '--yes', name);
+  } else {
+    if (mutation.from != null) unsupported('`openclaw agents add` takes a workspace, a model and bindings; it has no clone / template source, so Volter Harness refuses rather than dropping `from`');
+    program = harnessProgram('openclaw', context); env.OPENCLAW_STATE_DIR = mutation.homes.openclaw; env.OPENCLAW_CONFIG_PATH = profilePathJoin(mutation.homes.openclaw, 'openclaw.json'); args.push('agents');
+    if (verb === 'create') {
+      const workspace = nativeTrim(mutation.workspace ?? '');
+      if (!workspace) invalid('`openclaw agents add` requires the new agent\'s workspace directory in non-interactive mode (its own message: "Non-interactive agent creation requires --workspace"), so `profiles.create --harness openclaw` needs `workspace`');
+      args.push('add', name, '--workspace', workspace, '--non-interactive', '--json');
+    } else args.push('delete', name, '--force', '--json');
+  }
+  return { program, args, env, ran: [program, ...args].map(quote).join(' ') };
+}
+function readBack(mutation, name, ran, context) {
+  let rows; try { rows = listProfiles({ harness: mutation.harness, homes: mutation.homes }, context).profiles; }
+  catch (error) { failed(`\`${ran}\` succeeded but the profile store could not be re-read: ${error.message}`); }
+  const asciiLower = text => text.replace(/[A-Z]/gu, char => char.toLowerCase());
+  return rows.find(row => row.name === name) ?? rows.find(row => asciiLower(row.name) === asciiLower(name));
+}
+export async function mutateProfile(verb, params, { env = process.env, cwd = process.cwd(), signal } = {}) {
+  const context = { env, cwd, signal }, mutation = mutationParams(params, context);
+  if (!CONTROLLED_PROFILE_HARNESSES.includes(mutation.harness)) unsupportedHarness(mutation.harness);
+  if (!['create', 'delete'].includes(verb)) invalid(`unknown profile mutation: ${verb}`);
+  const name = nativeTrim(mutation.name); if (!name) invalid(`\`profiles.${verb}\` needs the profile name to act on`);
+  if (verb === 'delete' && (mutation.from != null || mutation.workspace != null)) invalid('`profiles.delete` sets no fields; pass definition fields to `profiles.create`');
+  let ran;
+  if (mutation.harness === 'orchestrator') {
+    if (mutation.from != null) unsupported('an orchestrator profile is a FOLDER the package\'s `save()` writes from an empty record (`docs/ORCHESTRATOR-IR.md` §6); the operator door has no clone verb, so Volter Harness refuses rather than dropping `from`');
+    if (mutation.workspace != null) unsupported('an orchestrator profile IS its own home (`<root>/profiles/<name>`), and where its worker runs is the `worker.cwd` key inside that folder\'s `config.yaml`, not a creation argument; Volter Harness refuses rather than dropping `workspace`');
+    const answer = await callProfileOrchestrator(mutation.homes.orchestrator, `profiles.${verb}`, { name }, context); ran = `${answer.ran} [${answer.door}]`;
+  } else {
+    const request = command(verb, mutation, name, context); requireProfileCommandSuccess(request, await runProfileCommand(request, context)); ran = request.ran;
+  }
+  const profile = readBack(mutation, name, ran, context);
+  if (verb === 'delete') {
+    if (profile) failed(`\`${ran}\` reported success but \`${name}\` is still ${mutation.harness === 'orchestrator' ? 'an orchestrator' : `a ${mutation.harness}`} profile`);
+    return { harness: mutation.harness, verb, ran, name, deleted: true };
+  }
+  if (!profile) failed(`\`${ran}\` reported success but ${mutation.harness === 'orchestrator' ? 'the orchestrator' : `\`${mutation.harness}\``} has no profile \`${name}\` afterwards`);
+  return { harness: mutation.harness, verb, ran, name: profile.name, profile };
+}

package/profiles-read.mjs

@@ -0,0 +1,119 @@
+// The read-only profile noun. A missing/invalid home contributes no rows;
+// absent route and session stores remain unknown rather than becoming zero.
+import { readFileSync, readdirSync, statSync } from 'node:fs';
+import { isAbsolute } from 'node:path';
+import { resolveHarnessHomes } from './homes.mjs';
+import { parseSkillToml } from './skill-toml.mjs';
+import { childPath, textName } from './session-spend-files.mjs';
+import { profilePathJoin as joined, profilePathParent as parent } from './profile-paths.mjs';
+import { readProfileFolderHome } from './hermes-read-home.mjs';
+import { readOpenclawProfileHome } from './openclaw-profile-home.mjs';
+import { readHermesRows } from './hermes-read-store.mjs';
+import { nativeInteger, setNativeInteger } from './native-json.mjs';
+import { PRESET_PROFILES } from './preset-profiles.mjs';
+
+export const PROFILE_HARNESSES = Object.freeze(['supercode', 'codex', 'hermes', 'openclaw', 'orchestrator']);
+const schema = 'supercode.profiles.v1';
+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 compare = (a, b) => Buffer.compare(Buffer.from(a), Buffer.from(b));
+const display = path => Buffer.isBuffer(path) ? path.toString('utf8') : path;
+const directory = path => { try { return statSync(path).isDirectory(); } catch { return false; } };
+const file = path => { try { return statSync(path).isFile(); } catch { return false; } };
+const invalid = message => { throw Object.assign(new Error(message), { rpcCode: -32602 }); };
+function struct(value, fields, name) {
+  if (Array.isArray(value)) {
+    if (value.length > fields.length) invalid(`${name} has too many fields`);
+    return Object.fromEntries(value.map((member, at) => [fields[at], member]));
+  }
+  if (!object(value)) invalid(`${name} must be a struct`);
+  return value;
+}
+function query(params, context) {
+  const query = struct(params, ['harness', 'name', 'homes'], 'profiles params');
+  for (const key of ['harness', 'name']) if (query[key] != null && typeof query[key] !== 'string') invalid(`${key} must be a string`);
+  const homes = resolveHarnessHomes(context.env);
+  if (Object.hasOwn(query, 'homes')) {
+    const supplied = struct(query.homes, Object.keys(homes), 'homes');
+    for (const key of Object.keys(homes)) if (Object.hasOwn(supplied, key)) {
+      if (typeof supplied[key] !== 'string') invalid(`homes.${key} must be a string`);
+      homes[key] = supplied[key];
+    }
+  }
+  return { ...query, homes };
+}
+const filesystem = (path, cwd) => !path.length || isAbsolute(path) || process.platform === 'win32' && /^[A-Za-z]:/u.test(path) ? path : joined(cwd, path);
+function row(harness, kind, name, home = null, defaults = false, model = null) {
+  return { name, harness, kind, home, default: defaults, routes: null, sessions: null, model };
+}
+function codexRows(path, cwd) {
+  const home = parent(path); if (home == null) return [];
+  let doc; try { doc = parseSkillToml(utf8.decode(readFileSync(filesystem(joined(home, 'config.toml'), cwd)))); } catch { return []; }
+  if (!object(doc.profiles) || doc.profiles instanceof Date) return [];
+  return Object.keys(doc.profiles).sort(compare).map(name => row('codex', 'codex_profile', name, null, doc.profile === name, string(doc.profiles[name]?.model)));
+}
+function hermesCount(path, profile) {
+  try {
+    const rows = readHermesRows(path, `SELECT COUNT(*) AS count FROM sessions WHERE profile_name ${profile == null ? 'IS NULL' : '= ?'}`, profile == null ? [] : [profile]);
+    const count = rows?.[0] && nativeInteger(rows[0], 'count', { signed: true });
+    return count == null ? null : count < 0n ? 0n : count;
+  } catch { return null; }
+}
+function folderRows(harness, supplied, cwd) {
+  const home = harness === 'hermes' ? parent(supplied) : supplied; if (home == null) return [];
+  let profiles; try { profiles = readProfileFolderHome(filesystem(home, cwd), harness); } catch { return []; }
+  const routesKnown = harness === 'hermes' ? profiles.get('default').configPresent : [...profiles.values()].some(profile => profile.configPresent);
+  const counts = new Map();
+  for (const profile of profiles.values()) for (const route of profile.routes) { const name = route.agent ?? route.profile; counts.set(name, (counts.get(name) ?? 0n) + 1n); }
+  return [...profiles.keys()].sort((a, b) => Number(a !== 'default') - Number(b !== 'default') || compare(a, b)).map(name => {
+    const profile = profiles.get(name), defaultProfile = name === 'default';
+    const result = row(harness, `${harness}_profile`, name, defaultProfile ? home : joined(joined(home, 'profiles'), name), defaultProfile, profile.model);
+    if (routesKnown) setNativeInteger(result, 'routes', counts.get(name) ?? 0n);
+    const sessions = harness === 'hermes' ? hermesCount(filesystem(supplied, cwd), defaultProfile ? null : name) : file(profile.store) ? BigInt(profile.bindings) : null;
+    if (sessions != null) setNativeInteger(result, 'sessions', sessions);
+    if (harness === 'orchestrator' && profile.worker != null) result.worker = profile.worker;
+    return result;
+  });
+}
+function openclawRows(home, cwd) {
+  const root = filesystem(home, cwd); let loaded;
+  try { loaded = readOpenclawProfileHome(root); } catch { return []; }
+  const names = new Set(loaded.byAgent.keys());
+  try {
+    const agents = childPath(root, 'agents');
+    for (const entry of readdirSync(agents, { encoding: 'buffer' })) {
+      const path = childPath(agents, entry); if (!directory(path)) continue;
+      try { if (!readdirSync(path, { encoding: 'buffer' }).length) continue; } catch { /* unread does not establish empty */ }
+      const name = textName(entry); if (name != null) names.add(name);
+    }
+  } catch { /* unavailable directory adds no undeclared names */ }
+  return [...names].sort(compare).map(name => {
+    const result = row('openclaw', 'openclaw_agent', name, joined(joined(home, 'agents'), name), loaded.defaultAgent === name, loaded.byAgent.get(name)?.model ?? null);
+    if (loaded.routes != null) setNativeInteger(result, 'routes', loaded.routes.get(name) ?? 0n);
+    try { setNativeInteger(result, 'sessions', BigInt(readdirSync(joined(joined(joined(root, 'agents'), name), 'sessions'), { encoding: 'buffer' }).filter(entry => entry.toString('utf8').endsWith('.jsonl') && !entry.toString('utf8').endsWith('.trajectory.jsonl')).length)); } catch { /* unknown session count */ }
+    return result;
+  });
+}
+function rows(query, context) {
+  if (query.harness != null && !PROFILE_HARNESSES.includes(query.harness)) throw Object.assign(new Error(`harness \`${query.harness}\` has no profile concept (profiles exist for: ${PROFILE_HARNESSES.join(', ')})`), { rpcCode: -32020 });
+  return PROFILE_HARNESSES.flatMap(harness => {
+    if (query.harness != null && query.harness !== harness) return [];
+    if (harness === 'supercode') return PRESET_PROFILES.map(preset => row(harness, 'preset', preset.name, null, preset.name === 'supercode-default', preset.model));
+    if (harness === 'codex') return codexRows(query.homes.codex, context.cwd);
+    if (harness === 'openclaw') return openclawRows(query.homes.openclaw, context.cwd);
+    return folderRows(harness, query.homes[harness], context.cwd);
+  });
+}
+export function listProfiles(params, { env = process.env, cwd = process.cwd() } = {}) {
+  const context = { env, cwd }, selected = query(params, context);
+  return { schema, profiles: rows(selected, context) };
+}
+export function getProfile(params, { env = process.env, cwd = process.cwd() } = {}) {
+  const context = { env, cwd }, selected = query(params, context);
+  if (selected.harness == null) invalid('`harness` is required');
+  if (selected.name == null) invalid('`name` is required');
+  const profile = rows(selected, context).find(row => row.name === selected.name);
+  if (profile == null) invalid(`\`${selected.harness}\` has no profile \`${selected.name}\``);
+  return { schema, profile };
+}

package/reduction-attribution.mjs

@@ -0,0 +1,54 @@
+// Offline fallback for old logs that did not persist attribution. Runtime
+// policy/candidate generation remains with its own consumer; this uses only
+// the validated saved records, in the native pipeline's fixed pass order.
+import { cloneNativeJson, nativeInteger, setNativeInteger, stringifyNativeJson } from './native-json.mjs';
+import { estimateViewTokens, messageWireText } from './reduction-log.mjs';
+import { reapplyReductionLog } from './reduction-view.mjs';
+
+const max = (1n << 64n) - 1n, add = (a, b) => a + b > max ? max : a + b;
+const sub = (a, b) => a > b ? a - b : 0n;
+const bytes = messages => messages.reduce((sum, message) => (sum + BigInt(Buffer.byteLength(messageWireText(message)))) & max, 0n);
+const kinds = [['DuplicateOutput', 'duplicate'], ['Superseded', 'superseded'], ['OutputNormalized', 'output-normalized'],
+  ['ToolOutputTruncated', 'tool-output'], ['FileReadElided', 'file-read'], ['FileReadDiffed', 'file-read-diffed'],
+  ['ImageRedacted', 'image'], ['ToolInputElided', 'tool-input'], ['TurnsCleared', 'turns-cleared']];
+function recordBytes(record, messages) {
+  const type = Object.keys(record.kind)[0], data = record.kind[type];
+  if (Object.hasOwn(data, 'original_bytes')) return nativeInteger(data, 'original_bytes');
+  if (type === 'TurnsCleared') {
+    const first = nativeInteger(data, 'first'), last = nativeInteger(data, 'last');
+    return first <= last && last < BigInt(messages.length) ? bytes(messages.slice(Number(first), Number(last) + 1)) : 0n;
+  }
+  const message = messages[Number(nativeInteger(record.ptr.addr, 'index'))];
+  if (type === 'FileReadElided') return BigInt(Buffer.byteLength(message?.content ?? ''));
+  const part = message?.content_parts?.[Number(nativeInteger(data, 'part_index'))];
+  return part == null ? 0n : BigInt(Buffer.byteLength(stringifyNativeJson(part)));
+}
+function counts(target, values) { for (const [key, value] of Object.entries(values)) setNativeInteger(target, key, value); return target; }
+export function savedReductionAttribution(log, messages) {
+  if (log.attribution != null) return cloneNativeJson(log.attribution);
+  const fullBytes = bytes(messages), fullTokens = estimateViewTokens(messages), passes = [], cumulative = [];
+  let retainedBytes = fullBytes, retainedTokens = fullTokens, totalBytes = 0n, totalTokens = 0n;
+  const view = records => reapplyReductionLog(messages, { ...log, reductions: records, expanded: [] });
+  for (const [variant, kind] of kinds) {
+    const reductions = log.reductions.filter(record => Object.hasOwn(record.kind, variant));
+    const originalBytes = reductions.reduce((sum, record) => (sum + recordBytes(record, messages)) & max, 0n);
+    const standalone = view(reductions), savedBytes = sub(fullBytes, bytes(standalone)), savedTokens = sub(fullTokens, estimateViewTokens(standalone));
+    totalBytes = add(totalBytes, savedBytes); totalTokens = add(totalTokens, savedTokens);
+    cumulative.push(...reductions);
+    const after = view(cumulative), nextBytes = bytes(after), nextTokens = estimateViewTokens(after);
+    const marginalBytes = sub(retainedBytes, nextBytes), marginalTokens = sub(retainedTokens, nextTokens);
+    passes.push(counts({ kind, enabled: reductions.length > 0 }, {
+      candidate_count: BigInt(reductions.length), candidate_original_bytes: originalBytes, applied_count: BigInt(reductions.length),
+      applied_original_bytes: originalBytes, suppressed_by_later_pass_count: 0n, suppressed_by_later_pass_bytes: 0n,
+      standalone_saved_bytes: savedBytes, standalone_saved_tokens: savedTokens, marginal_saved_bytes: marginalBytes,
+      marginal_saved_tokens: marginalTokens, suppressed_bytes: sub(savedBytes, marginalBytes), suppressed_tokens: sub(savedTokens, marginalTokens),
+      retained_bytes: nextBytes, retained_tokens: nextTokens,
+    }));
+    retainedBytes = nextBytes; retainedTokens = nextTokens;
+  }
+  const final = view(log.reductions), viewBytes = bytes(final), viewTokens = estimateViewTokens(final);
+  const aggregateBytes = sub(fullBytes, viewBytes), aggregateTokens = sub(fullTokens, viewTokens);
+  return counts({ passes }, { full_bytes: fullBytes, view_bytes: viewBytes, full_tokens: fullTokens, view_tokens: viewTokens,
+    aggregate_saved_bytes: aggregateBytes, aggregate_saved_tokens: aggregateTokens, standalone_saved_bytes: totalBytes,
+    standalone_saved_tokens: totalTokens, overlap_suppressed_bytes: sub(totalBytes, aggregateBytes), overlap_suppressed_tokens: sub(totalTokens, aggregateTokens) });
+}