@oracle-agent/oracle 0.13.0 → 0.14.0

package/src/cli/commands/mcp.mjs

@@ -0,0 +1,154 @@
+import { parseArgs } from "node:util";
+import { printOperatorNotInstalled } from "../operator-dispatch.mjs";
+import { installClaudeCode } from "../mcp-targets/claude-code.mjs";
+import { installClaudeDesktop } from "../mcp-targets/claude-desktop.mjs";
+import { installCodex } from "../mcp-targets/codex.mjs";
+import { installChatgpt } from "../mcp-targets/chatgpt.mjs";
+import { installCursor } from "../mcp-targets/cursor.mjs";
+import { installVscode } from "../mcp-targets/vscode.mjs";
+import { buildServerSpecs } from "../mcp-targets/shared.mjs";
+
+function usage() {
+  process.stderr.write(
+    "usage: oracle mcp <install|print> [target] [flags]\n" +
+      "  targets: claude-code | claude-desktop | codex | copilot | chatgpt | cursor | vscode | generic\n" +
+      "  flags:   --with-control --project --print --json\n",
+  );
+}
+
+function emitResult(result, { json = false } = {}) {
+  if (result.print && !result.instructions) {
+    process.stdout.write(JSON.stringify(result.print, null, 2) + "\n");
+  } else if (result.printText) {
+    process.stdout.write(result.printText);
+  }
+  if (result.instructions) {
+    process.stdout.write(result.instructions + "\n");
+    if (result.print && json) process.stdout.write(JSON.stringify(result.print, null, 2) + "\n");
+  }
+  if (!result.print && !result.printText && !result.instructions) {
+    const line = {
+      status: result.status,
+      path: result.path || null,
+      backup: result.backup || null,
+      method: result.method || null,
+    };
+    process.stdout.write(
+      (json ? JSON.stringify(line, null, 2) : `${line.status}${line.path ? " " + line.path : ""}`) + "\n",
+    );
+  }
+}
+
+export default {
+  name: "mcp",
+  summary: "wire Oracle into AI clients",
+  group: "read",
+  usage: "oracle mcp install <target> | oracle mcp print [--target <t>]",
+  async run(ctx) {
+    const verb = ctx.argv[0];
+    if (!verb || verb === "--help" || verb === "-h") {
+      usage();
+      return verb ? 0 : 1;
+    }
+
+    let values, positionals;
+    try {
+      ({ values, positionals } = parseArgs({
+        args: ctx.argv.slice(1),
+        options: {
+          "with-control": { type: "boolean", default: false },
+          project: { type: "boolean", default: false },
+          print: { type: "boolean", default: false },
+          json: { type: "boolean", default: false },
+          target: { type: "string" },
+        },
+        allowPositionals: true,
+        strict: false,
+      }));
+    } catch (err) {
+      process.stderr.write(`oracle mcp: ${err.message}\n`);
+      usage();
+      return 1;
+    }
+
+    const withControl = !!values["with-control"];
+    const project = !!values.project;
+    const json = !!values.json;
+    const operator = ctx.resolveOperator ? ctx.resolveOperator() : { ok: false };
+
+    if (withControl && (!operator || !operator.ok)) {
+      printOperatorNotInstalled(process.stderr);
+      return 3;
+    }
+
+    const opts = { oracleRoot: ctx.root, operator, withControl, project, cwd: process.cwd() };
+
+    if (verb === "print") {
+      const target = values.target || positionals[0] || "claude-code";
+      if (target === "generic" || target === "claude-code") {
+        const built = buildServerSpecs(opts);
+        if (!built.ok) { printOperatorNotInstalled(process.stderr); return 3; }
+        process.stdout.write(JSON.stringify({ mcpServers: built.specs }, null, 2) + "\n");
+        return 0;
+      }
+      if (target === "chatgpt") {
+        const r = await installChatgpt({ printOnly: true });
+        emitResult(r, { json });
+        return 0;
+      }
+      if (target === "codex" || target === "copilot") {
+        emitResult(await installCodex({ ...opts, printOnly: true }), { json });
+        return 0;
+      }
+      if (target === "claude-desktop") {
+        emitResult(await installClaudeDesktop({ ...opts, printOnly: true }), { json });
+        return 0;
+      }
+      if (target === "cursor") {
+        emitResult(await installCursor({ ...opts, printOnly: true }), { json });
+        return 0;
+      }
+      if (target === "vscode" || target === "vs-code") {
+        emitResult(await installVscode({ ...opts, printOnly: true }), { json });
+        return 0;
+      }
+      process.stderr.write(`oracle mcp: unknown target '${target}'\n`);
+      return 1;
+    }
+
+    if (verb === "install") {
+      const target = positionals[0] || values.target;
+      if (!target) { usage(); return 1; }
+      const printOnly = !!values.print;
+      let result;
+      if (target === "claude-code") result = await installClaudeCode({ ...opts, printOnly });
+      else if (target === "claude-desktop") result = await installClaudeDesktop({ ...opts, printOnly });
+      else if (target === "codex" || target === "copilot") result = await installCodex({ ...opts, printOnly });
+      else if (target === "chatgpt") result = await installChatgpt({ printOnly });
+      else if (target === "cursor") result = await installCursor({ ...opts, printOnly });
+      else if (target === "vscode" || target === "vs-code") result = await installVscode({ ...opts, printOnly });
+      else if (target === "generic") {
+        const built = buildServerSpecs(opts);
+        if (!built.ok) { printOperatorNotInstalled(process.stderr); return 3; }
+        process.stdout.write(JSON.stringify({ mcpServers: built.specs }, null, 2) + "\n");
+        return 0;
+      } else {
+        process.stderr.write(`oracle mcp: unknown target '${target}'\n`);
+        return 1;
+      }
+      if (!result.ok) {
+        if (result.code === 3) printOperatorNotInstalled(process.stderr);
+        else process.stderr.write(`oracle mcp: ${result.reason || "failed"}\n`);
+        return result.code || 1;
+      }
+      emitResult(result, { json });
+      if (result.status && String(result.status).startsWith("printed") && result.print) {
+        process.stdout.write(JSON.stringify(result.print, null, 2) + "\n");
+      }
+      return 0;
+    }
+
+    usage();
+    return 1;
+  },
+};

package/src/cli/commands/model.mjs

@@ -0,0 +1,106 @@
+import { spawnChild } from "../spawn-child.mjs";
+import { resolveHermes } from "../runtime.mjs";
+import { readModelConfig, writeModelConfig } from "../model-config.mjs";
+import { oracleHarnessInvocation } from "./chat.mjs";
+
+function option(args, name) {
+  const index = args.indexOf(name);
+  return index >= 0 && args[index + 1] ? args[index + 1] : null;
+}
+
+function standalonePatch(args) {
+  const backend = option(args, "--backend");
+  const provider = option(args, "--provider");
+  const model = option(args, "--model") || option(args, "-m");
+  const baseUrl = option(args, "--base-url");
+  const apiKeyEnv = option(args, "--api-key-env");
+  const contextLength = option(args, "--context-length");
+  const reasoningEffort = option(args, "--reasoning-effort");
+  const computeHost = option(args, "--compute-host") || option(args, "--remote-host");
+  const computeUser = option(args, "--compute-user") || option(args, "--remote-user");
+  const computePath = option(args, "--compute-path") || option(args, "--remote-path");
+  const hasStandaloneField = Boolean(provider || model || baseUrl || apiKeyEnv || contextLength || reasoningEffort || computeHost || computeUser || computePath);
+  if (!backend && !hasStandaloneField) return null;
+  const current = { ...(readModelConfig() || {}) };
+  if (provider) {
+    delete current.apiKeyEnv;
+    if (provider !== "custom" || provider !== current.provider) delete current.baseUrl;
+  }
+  return {
+    ...current,
+    backend: backend || "standalone",
+    ...(provider ? { provider } : {}),
+    ...(model ? { model } : {}),
+    ...(baseUrl ? { baseUrl } : {}),
+    ...(apiKeyEnv ? { apiKeyEnv } : {}),
+    ...(contextLength ? { contextLength } : {}),
+    ...(reasoningEffort ? { reasoningEffort } : {}),
+    ...(computeHost ? { computeHost } : {}),
+    ...(computeUser ? { computeUser } : {}),
+    ...(computePath ? { computePath } : {}),
+  };
+}
+
+function usage() {
+  return [
+    "oracle model, choose standalone model settings or open Hermes' picker",
+    "",
+    "  oracle model",
+    "  oracle model --show",
+    "  oracle model --backend standalone --provider openrouter --model openrouter/auto",
+    "  oracle model --backend remote --compute-host <host>",
+    "  oracle model --backend auto",
+    "",
+    "standalone keys stay in environment variables, never model.json:",
+    "  OPENROUTER_API_KEY, OPENAI_API_KEY, XAI_API_KEY, DEEPSEEK_API_KEY, GEMINI_API_KEY",
+  ].join("\n");
+}
+
+export default {
+  name: "model",
+  summary: "choose Oracle's standalone model or existing Hermes provider",
+  group: "read",
+  usage: usage(),
+  async run(ctx) {
+    const args = [...ctx.argv];
+    if (args.includes("--show")) {
+      process.stdout.write(`${JSON.stringify(readModelConfig() || { backend: "auto" }, null, 2)}\n`);
+      return 0;
+    }
+
+    const patch = standalonePatch(args);
+    if (patch) {
+      try {
+        const saved = writeModelConfig(patch);
+        process.stdout.write(`oracle model: ${saved.backend}`);
+        if (saved.provider) process.stdout.write(` / ${saved.provider}`);
+        if (saved.model) process.stdout.write(` / ${saved.model}`);
+        process.stdout.write("\n");
+        if (saved.backend === "standalone" && saved.apiKeyEnv) {
+          process.stdout.write(`key source: ${saved.apiKeyEnv}\n`);
+        }
+        return 0;
+      } catch (error) {
+        process.stderr.write(`oracle model: ${error.message}\n`);
+        return 1;
+      }
+    }
+
+    const found = resolveHermes();
+    if (!found.ok) {
+      process.stderr.write(
+        "Oracle standalone chat does not require Hermes.\n" +
+          "Configure a provider with: oracle model --backend standalone --provider openrouter --model openrouter/auto\n" +
+          "Then set OPENROUTER_API_KEY.\n",
+      );
+      return 1;
+    }
+    const launch = oracleHarnessInvocation(found.bin, ["-p", "oracle", "model", ...args]);
+    return spawnChild(
+      launch.command,
+      launch.args,
+      { stdio: "inherit", env: process.env },
+      "oracle-model",
+    );
+  },
+};

package/src/cli/commands/plugins.mjs

@@ -0,0 +1,241 @@
+// oracle plugins — install, list, and manage Agent Plugins.
+//
+// Implements the Agent Plugins open standard (https://agent-plugins.org/).
+// Every conformant plugin ships a plugin.json manifest plus optional
+// skills/ and mcp/ directories. Oracle validates, installs, and loads them.
+//
+// Commands:
+//   oracle plugins install <path>     install from a local directory
+//   oracle plugins install <url>      clone a git repo and install
+//   oracle plugins list               show installed plugins
+//   oracle plugins remove <name>      uninstall a plugin
+//   oracle plugins scan <path>        validate without installing
+//   oracle plugins setup              interactive setup wizard
+//
+// Plugins are installed to ~/.config/oracle/plugins/<name>/.
+
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { oracleConfigDir } from "../paths.mjs";
+import { loadPlugin, scanInstalledPlugins, SCHEMA_ID } from "../../plugins/agent-plugin-loader.mjs";
+
+function pluginsDir() {
+  const dir = path.join(oracleConfigDir(), "plugins");
+  if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+function usage() {
+  return [
+    "oracle plugins — manage Agent Plugins (https://agent-plugins.org/)",
+    "",
+    "  oracle plugins install <path>       install from a local directory",
+    "  oracle plugins install <git-url>    clone a repo and install",
+    "  oracle plugins list                 show installed plugins",
+    "  oracle plugins remove <name>        uninstall a plugin",
+    "  oracle plugins scan <path>          validate without installing",
+    "  oracle plugins setup                interactive setup wizard",
+    "",
+    "plugins are installed to ~/.config/oracle/plugins/<name>/",
+    `schema: ${SCHEMA_ID}`,
+  ].join("\n");
+}
+
+function installFromDir(sourceDir, { name: forceName } = {}) {
+  const abs = path.resolve(sourceDir);
+  if (!fs.existsSync(abs) || !fs.statSync(abs).isDirectory()) {
+    process.stderr.write(`error: ${sourceDir} is not a directory\n`);
+    return 1;
+  }
+
+  const result = loadPlugin(abs);
+  if (!result.ok) {
+    process.stderr.write(`error: invalid plugin at ${abs}\n`);
+    if (result.errors) {
+      for (const e of result.errors) process.stderr.write(`  - ${e}\n`);
+    }
+    return 1;
+  }
+
+  const p = result.plugin;
+  const destName = forceName || p.name.replace(/\//g, "-");
+  const dest = path.join(pluginsDir(), destName);
+
+  if (fs.existsSync(dest)) {
+    process.stderr.write(`plugin "${destName}" already installed. use oracle plugins remove first.\n`);
+    return 1;
+  }
+
+  // Copy the plugin directory
+  fs.cpSync(abs, dest, { recursive: true });
+  process.stdout.write(`installed ${p.name} (v${p.version}) to ${dest}\n`);
+  process.stdout.write(`  ${p.skills.length} skills, ${p.mcpServers.length} MCP servers\n`);
+
+  if (p.warnings.length) {
+    for (const w of p.warnings) process.stdout.write(`  warning: ${w}\n`);
+  }
+
+  return 0;
+}
+
+function installFromGit(url) {
+  const tmp = path.join(pluginsDir(), ".tmp-" + Date.now());
+  try {
+    const r = spawnSync("git", ["clone", "--depth", "1", url, tmp], {
+      stdio: "pipe",
+      timeout: 60_000,
+    });
+    if (r.status !== 0) {
+      process.stderr.write(`error: git clone failed: ${String(r.stderr).slice(0, 200)}\n`);
+      return 1;
+    }
+    return installFromDir(tmp);
+  } finally {
+    // Cleanup temp dir
+    try { fs.rmSync(tmp, { recursive: true, force: true }); } catch {}
+  }
+}
+
+function cmdList() {
+  const plugins = scanInstalledPlugins(pluginsDir());
+  if (!plugins.length) {
+    process.stdout.write("no plugins installed\n");
+    process.stdout.write(`install with: oracle plugins install <path|url>\n`);
+    return 0;
+  }
+
+  process.stdout.write(`${plugins.length} plugin(s) installed\n\n`);
+  for (const p of plugins) {
+    const dirName = path.basename(p.root);
+    process.stdout.write(`  ${p.name} (v${p.version})\n`);
+    process.stdout.write(`    path: ${p.root}\n`);
+    if (p.description) process.stdout.write(`    desc: ${p.description}\n`);
+    process.stdout.write(`    ${p.skills.length} skills, ${p.mcpServers.length} MCP servers\n`);
+    if (p.license !== "UNLICENSED") process.stdout.write(`    license: ${p.license}\n`);
+    process.stdout.write("\n");
+  }
+  return 0;
+}
+
+function cmdRemove(name) {
+  if (!name) {
+    process.stderr.write("usage: oracle plugins remove <name>\n");
+    return 1;
+  }
+
+  const dest = path.join(pluginsDir(), name);
+  if (!fs.existsSync(dest)) {
+    process.stderr.write(`plugin "${name}" not found\n`);
+    return 1;
+  }
+
+  fs.rmSync(dest, { recursive: true, force: true });
+  process.stdout.write(`removed plugin "${name}"\n`);
+  return 0;
+}
+
+function cmdScan(sourceDir) {
+  const abs = path.resolve(sourceDir);
+  const result = loadPlugin(abs);
+
+  if (!result.ok) {
+    process.stderr.write(`invalid plugin: ${result.error}\n`);
+    if (result.errors) {
+      for (const e of result.errors) process.stderr.write(`  error: ${e}\n`);
+    }
+    return 1;
+  }
+
+  const p = result.plugin;
+  process.stdout.write(`valid plugin: ${p.name} (v${p.version})\n`);
+  process.stdout.write(`  schema: ${p.manifest.$schema}\n`);
+  process.stdout.write(`  skills: ${p.skills.length} found\n`);
+  for (const s of p.skills) {
+    process.stdout.write(`    - ${s.name} (${s.relativePath})\n`);
+  }
+  process.stdout.write(`  mcp servers: ${p.mcpServers.length} found\n`);
+  for (const m of p.mcpServers) {
+    const status = m.error ? `ERROR: ${m.error}` : "ok";
+    process.stdout.write(`    - ${m.name}: ${status}\n`);
+  }
+  if (p.warnings.length) {
+    process.stdout.write(`  warnings:\n`);
+    for (const w of p.warnings) process.stdout.write(`    - ${w}\n`);
+  }
+  return 0;
+}
+
+function cmdSetup() {
+  process.stdout.write([
+    "oracle plugins setup",
+    "",
+    "Agent Plugins (https://agent-plugins.org/) is an open standard for",
+    "portable AI agent tooling. Plugins ship skills and MCP servers in a",
+    "standard package format that works across compatible clients.",
+    "",
+    "To create a plugin:",
+    "  1. Create a directory with a plugin.json manifest",
+    "  2. Add skills as .md files in skills/",
+    "  3. Add MCP server configs as .json files in mcp/",
+    "  4. Validate: oracle plugins scan <dir>",
+    "  5. Install: oracle plugins install <dir>",
+    "",
+    "To install an existing plugin:",
+    "  oracle plugins install <path>       local directory",
+    "  oracle plugins install <git-url>    git repository",
+    "",
+    `schema: ${SCHEMA_ID}`,
+    "",
+  ].join("\n"));
+  return 0;
+}
+
+export default {
+  name: "plugins",
+  summary: "manage Agent Plugins (open-standard portable agent tooling)",
+  group: "read",
+  usage: usage(),
+  async run(ctx) {
+    const args = [...ctx.argv];
+    const verb = (args[0] || "help").toLowerCase();
+    const rest = args.slice(1);
+
+    if (verb === "-h" || verb === "--help" || verb === "help") {
+      process.stdout.write(usage() + "\n");
+      return 0;
+    }
+
+    if (verb === "list" || verb === "ls") {
+      return cmdList();
+    }
+
+    if (verb === "install" || verb === "add") {
+      const target = rest[0];
+      if (!target) {
+        process.stderr.write("usage: oracle plugins install <path|url>\n");
+        return 1;
+      }
+      // Detect git URL
+      if (target.startsWith("http://") || target.startsWith("https://") || target.startsWith("git@")) {
+        return installFromGit(target);
+      }
+      return installFromDir(target);
+    }
+
+    if (verb === "remove" || verb === "rm" || verb === "uninstall") {
+      return cmdRemove(rest[0]);
+    }
+
+    if (verb === "scan" || verb === "validate") {
+      return cmdScan(rest[0] || ".");
+    }
+
+    if (verb === "setup") {
+      return cmdSetup();
+    }
+
+    process.stderr.write(`oracle plugins: unknown verb '${verb}'\n${usage()}\n`);
+    return 1;
+  },
+};

package/src/cli/commands/prepare.mjs

@@ -0,0 +1,12 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+export default {
+  name: "prepare", summary: "build an unsigned swap (alias of route prepare)", group: "read",
+  usage: "oracle prepare <chain> <tokenIn> <tokenOut> <taker> [amt]",
+  async run(ctx) {
+    const bin = ctx.bin("oracle-route.mjs");
+    const r = spawnSync(process.execPath, [bin, "prepare", ...ctx.argv], { stdio: "inherit" });
+    if (r.error) { process.stderr.write(`oracle: failed to spawn oracle-route: ${r.error.message}\n`); return 1; }
+    return typeof r.status === "number" ? r.status : 1;
+  },
+};

package/src/cli/commands/public.mjs

@@ -0,0 +1,20 @@
+import path from "node:path";
+import { parseArgs } from "node:util";
+import { spawnChild } from "../spawn-child.mjs";
+export default {
+  name: "public", summary: "secret-free public HTTP surface", group: "read",
+  usage: "oracle public serve [--port N]",
+  async run(ctx) {
+    const verb = ctx.argv[0] || "serve";
+    if (verb !== "serve") { process.stderr.write("usage: oracle public serve [--port N]\n"); return 1; }
+    let port = null;
+    try {
+      const { values } = parseArgs({ args: ctx.argv.slice(1), options: { port: { type: "string" } }, allowPositionals: true, strict: false });
+      port = values.port || null;
+    } catch {}
+    const env = { ...process.env };
+    if (port) env.ORACLE_PUBLIC_PORT = String(port);
+    const bin = ctx.bin("oracle-public-server.mjs");
+    return spawnChild(process.execPath, [bin], { stdio: "inherit", env }, "oracle-public-server");
+  },
+};

package/src/cli/commands/resolve.mjs

@@ -0,0 +1,64 @@
+import { lookupName, resolveName, ADDRESS_RE, NAME_SOURCES } from "../../data/names.mjs";
+
+const USAGE = `oracle resolve <name-or-address> [--json]
+
+  oracle resolve demi.hl
+  oracle resolve vitalik.eth
+  oracle resolve 0x4d47b6757afd42c3dbd9691b71b43d74afa4b6b2
+
+Reads on-chain name records. No API key: HL Names publishes a paid REST API,
+but the contract answers primaryName(address) for free.
+
+Sources, in priority order: ${NAME_SOURCES.join(", ")}.`;
+
+async function runResolve(argv = []) {
+  const args = argv.filter((a) => a !== "--json");
+  const asJson = argv.includes("--json");
+  const query = (args[0] || "").trim();
+
+  if (!query || query === "--help" || query === "-h") {
+    process.stdout.write(USAGE + "\n");
+    return query ? 0 : 1;
+  }
+
+  try {
+    if (ADDRESS_RE.test(query)) {
+      const hit = await lookupName(query);
+      if (asJson) {
+        process.stdout.write(JSON.stringify({ address: query, name: hit?.name ?? null, source: hit?.source ?? null }) + "\n");
+        return 0;
+      }
+      if (!hit) {
+        process.stdout.write(`${query}\n  no name record found\n`);
+        return 0;
+      }
+      process.stdout.write(`${query}\n  ${hit.name}  [${hit.source}]\n`);
+      return 0;
+    }
+
+    const hit = await resolveName(query);
+    if (asJson) {
+      process.stdout.write(JSON.stringify({ name: query, address: hit?.address ?? null, source: hit?.source ?? null }) + "\n");
+      return 0;
+    }
+    if (!hit) {
+      // Unresolved is an answer, not an error: the name may simply be unregistered.
+      process.stdout.write(`${query}\n  unresolved (no owner record)\n`);
+      return 0;
+    }
+    process.stdout.write(`${query}\n  ${hit.address}  [${hit.source}]\n`);
+    return 0;
+  } catch (err) {
+    process.stderr.write(`resolve failed: ${err?.message || err}\n`);
+    return 1;
+  }
+}
+
+export default {
+  name: "resolve",
+  summary: "resolve .hl/.hype/.eth names to addresses and back",
+  usage: USAGE,
+  async run(ctx) {
+    return runResolve(ctx.argv || []);
+  },
+};

package/src/cli/commands/route.mjs

@@ -0,0 +1,12 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+export default {
+  name: "route", summary: "swap/bridge prepare helpers", group: "read",
+  usage: "oracle route <swap|bridge|prepare|prepare-bridge> ...",
+  async run(ctx) {
+    const bin = ctx.bin("oracle-route.mjs");
+    const r = spawnSync(process.execPath, [bin, ...ctx.argv], { stdio: "inherit" });
+    if (r.error) { process.stderr.write(`oracle: failed to spawn oracle-route: ${r.error.message}\n`); return 1; }
+    return typeof r.status === "number" ? r.status : 1;
+  },
+};

package/src/cli/commands/runner.mjs

@@ -0,0 +1,9 @@
+export default {
+  name: "runner",
+  summary: "action runner daemon",
+  group: "sign",
+  usage: "oracle runner [--interval-ms N ...]",
+  async run(ctx) {
+    return ctx.dispatchOperator("oracle-runner", ctx.argv, { appendHintOnError: true });
+  },
+};

package/src/cli/commands/scan.mjs

@@ -0,0 +1,12 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+export default {
+  name: "scan", summary: "chain scanner", group: "read",
+  usage: "oracle scan <chains|head|token|pools|risk|quote|sell> ...",
+  async run(ctx) {
+    const bin = ctx.bin("oracle-scan.mjs");
+    const r = spawnSync(process.execPath, [bin, ...ctx.argv], { stdio: "inherit" });
+    if (r.error) { process.stderr.write(`oracle: failed to spawn oracle-scan: ${r.error.message}\n`); return 1; }
+    return typeof r.status === "number" ? r.status : 1;
+  },
+};