@oracle-agent/oracle 0.4.1 → 0.5.0

package/src/cli/mcp-targets/chatgpt.mjs

@@ -0,0 +1,51 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fakeHome, report } from "./shared.mjs";
+
+export const CHATGPT_CANNOT_SIGN =
+  "ChatGPT is hosted and can NEVER sign or reach your keys. This connector is read/prepare only; anything it prepares is unsigned until you sign it locally.";
+
+function openApiDoc() {
+  return {
+    openapi: "3.1.0",
+    info: {
+      title: "Oracle Public (read/prepare)",
+      version: "1.0.0",
+      description: "Secret-free public surface for hosted clients. " + CHATGPT_CANNOT_SIGN,
+    },
+    servers: [{ url: "https://REPLACE-WITH-YOUR-TUNNEL" }],
+    paths: {
+      "/public/health": { get: { operationId: "publicHealth", summary: "Health check", responses: { "200": { description: "ok" } } } },
+      "/public/config": { get: { operationId: "publicConfig", summary: "Public config", responses: { "200": { description: "ok" } } } },
+      "/public/connect/request": { post: { operationId: "connectRequest", summary: "Build a connect request (unsigned)", responses: { "200": { description: "unsigned request artifact" } } } },
+      "/public/connect/assemble": { post: { operationId: "connectAssemble", summary: "Assemble an unsigned grant artifact", responses: { "200": { description: "unsigned grant artifact" } } } },
+      "/public/grants/active": { post: { operationId: "grantsActive", summary: "List active grants (read)", responses: { "200": { description: "ok" } } } },
+      "/public/grants/get": { post: { operationId: "grantsGet", summary: "Get a grant by id (read)", responses: { "200": { description: "ok" } } } },
+    },
+  };
+}
+
+export async function installChatgpt({ printOnly = false } = {}) {
+  const doc = openApiDoc();
+  const target = path.join(fakeHome(), ".config", "oracle", "connectors", "chatgpt-openapi.json");
+  const text = JSON.stringify(doc, null, 2) + "\n";
+  if (!printOnly) {
+    fs.mkdirSync(path.dirname(target), { recursive: true });
+    fs.writeFileSync(target, text);
+  }
+  const instructions = [
+    CHATGPT_CANNOT_SIGN, "",
+    "Next steps:",
+    "  1. oracle public serve",
+    "  2. Expose 127.0.0.1:8799 through YOUR HTTPS tunnel (cloudflared, tailscale funnel, etc.).",
+    "     Oracle will not create tunnels for you.",
+    "  3. Paste the OpenAPI spec into a GPT Action, or add the tunnel URL as a developer-mode MCP connector.",
+    printOnly ? "" : `  Spec written to: ${target}`,
+  ].filter(Boolean).join("\n");
+  return {
+    ok: true,
+    ...report(printOnly ? "printed" : "written", {
+      path: target, print: doc, instructions, cannotSign: CHATGPT_CANNOT_SIGN,
+    }),
+  };
+}

package/src/cli/mcp-targets/claude-code.mjs

@@ -0,0 +1,39 @@
+import { spawnSync } from "node:child_process";
+import path from "node:path";
+import { fakeHome, buildServerSpecs, mergeMcpServers, report } from "./shared.mjs";
+
+function claudeJsonPath() { return path.join(fakeHome(), ".claude.json"); }
+function projectMcpPath(cwd) { return path.join(cwd || process.cwd(), ".mcp.json"); }
+
+function tryClaudeCli(name, spec) {
+  const probe = spawnSync("claude", ["--version"], { encoding: "utf8", timeout: 10000 });
+  if (probe.error || probe.status !== 0) return null;
+  const r = spawnSync("claude", ["mcp", "add-json", name, JSON.stringify(spec), "--scope", "user"], {
+    encoding: "utf8", timeout: 30000,
+  });
+  if (r.status !== 0) return { ok: false, stderr: r.stderr || r.stdout || "failed" };
+  return { ok: true };
+}
+
+export async function installClaudeCode({
+  oracleRoot, operator, withControl = false, project = false, printOnly = false, cwd = process.cwd(),
+}) {
+  const built = buildServerSpecs({ oracleRoot, operator, withControl });
+  if (!built.ok) return { ok: false, code: 3, reason: built.reason };
+  if (printOnly) return { ok: true, print: { mcpServers: built.specs } };
+  if (project) {
+    const target = projectMcpPath(cwd);
+    const result = mergeMcpServers(target, built.specs);
+    return { ok: true, ...report(result.status, { path: target, backup: result.backup }) };
+  }
+  let usedCli = false;
+  for (const [name, spec] of Object.entries(built.specs)) {
+    const cli = tryClaudeCli(name, spec);
+    if (cli && cli.ok) { usedCli = true; continue; }
+    break;
+  }
+  if (usedCli) return { ok: true, ...report("written", { method: "claude-cli" }) };
+  const target = claudeJsonPath();
+  const result = mergeMcpServers(target, built.specs);
+  return { ok: true, ...report(result.status, { path: target, backup: result.backup }) };
+}

package/src/cli/mcp-targets/claude-desktop.mjs

@@ -0,0 +1,24 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fakeHome, buildServerSpecs, mergeMcpServers, report } from "./shared.mjs";
+
+function desktopConfigPath() {
+  if (process.platform === "darwin") {
+    return path.join(fakeHome(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  return path.join(fakeHome(), ".config", "Claude", "claude_desktop_config.json");
+}
+
+export async function installClaudeDesktop({ oracleRoot, operator, withControl = false, printOnly = false }) {
+  const built = buildServerSpecs({ oracleRoot, operator, withControl });
+  if (!built.ok) return { ok: false, code: 3, reason: built.reason };
+  const target = desktopConfigPath();
+  const payload = { mcpServers: built.specs };
+  if (printOnly) return { ok: true, print: payload };
+  const parent = path.dirname(target);
+  if (!fs.existsSync(parent)) {
+    return { ok: true, status: "printed (Claude Desktop not detected)", path: target, print: payload };
+  }
+  const result = mergeMcpServers(target, built.specs);
+  return { ok: true, ...report(result.status, { path: target, backup: result.backup }) };
+}

package/src/cli/mcp-targets/codex.mjs

@@ -0,0 +1,41 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fakeHome, buildServerSpecs, backupFile, report } from "./shared.mjs";
+
+const BEGIN = "# oracle-mcp-install begin";
+const END = "# oracle-mcp-install end";
+
+function codexPath() { return path.join(fakeHome(), ".codex", "config.toml"); }
+
+function renderBlock(specs) {
+  const lines = [BEGIN];
+  for (const [name, spec] of Object.entries(specs)) {
+    lines.push(`[mcp_servers.${name}]`);
+    lines.push(`command = ${JSON.stringify(spec.command)}`);
+    lines.push(`args = [${spec.args.map((a) => JSON.stringify(a)).join(", ")}]`);
+    lines.push("");
+  }
+  lines.push(END);
+  return lines.join("\n") + "\n";
+}
+
+function stripExistingBlock(text) {
+  return text.replace(new RegExp(`${BEGIN}[\\s\\S]*?${END}\\n?`, "g"), "");
+}
+
+export async function installCodex({ oracleRoot, operator, withControl = false, printOnly = false }) {
+  const built = buildServerSpecs({ oracleRoot, operator, withControl });
+  if (!built.ok) return { ok: false, code: 3, reason: built.reason };
+  const block = renderBlock(built.specs);
+  const target = codexPath();
+  if (printOnly) return { ok: true, printText: block, path: target };
+  fs.mkdirSync(path.dirname(target), { recursive: true });
+  const prev = fs.existsSync(target) ? fs.readFileSync(target, "utf8") : "";
+  if (prev.includes(block.trim())) return { ok: true, ...report("present", { path: target, backup: null }) };
+  const stripped = stripExistingBlock(prev);
+  const next = (stripped.trimEnd() + "\n\n" + block).replace(/^\n+/, "");
+  if (prev.trim() === next.trim()) return { ok: true, ...report("present", { path: target, backup: null }) };
+  const backup = prev ? backupFile(target) : null;
+  fs.writeFileSync(target, next.endsWith("\n") ? next : next + "\n");
+  return { ok: true, ...report("written", { path: target, backup }) };
+}

package/src/cli/mcp-targets/shared.mjs

@@ -0,0 +1,61 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import { PACKAGE_ROOT } from "../paths.mjs";
+
+export function fakeHome() {
+  return process.env.ORACLE_FAKE_HOME || os.homedir();
+}
+
+export function buildServerSpecs({ oracleRoot = PACKAGE_ROOT, operator = null, withControl = false } = {}) {
+  const specs = {
+    "oracle-data": {
+      command: "node",
+      args: [path.join(oracleRoot, "bin", "oracle-data-mcp.mjs")],
+    },
+  };
+  if (withControl) {
+    if (!operator || !operator.ok) return { ok: false, reason: "operator-missing" };
+    const control = operator.bins?.["oracle-control-mcp"] || operator.controlMcp || null;
+    if (!control) return { ok: false, reason: "control-bin-missing" };
+    specs["oracle-control"] = { command: "node", args: [control] };
+  }
+  return { ok: true, specs };
+}
+
+export function backupFile(filePath) {
+  if (!fs.existsSync(filePath)) return null;
+  const bak = `${filePath}.bak-oracle-${Math.floor(Date.now() / 1000)}`;
+  fs.copyFileSync(filePath, bak);
+  return bak;
+}
+
+export function readJson(filePath, fallback = {}) {
+  if (!fs.existsSync(filePath)) return structuredClone(fallback);
+  return JSON.parse(fs.readFileSync(filePath, "utf8"));
+}
+
+export function writeJson(filePath, obj) {
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, JSON.stringify(obj, null, 2) + "\n");
+}
+
+export function mergeMcpServers(filePath, specs) {
+  const existing = readJson(filePath, {});
+  if (!existing.mcpServers || typeof existing.mcpServers !== "object") existing.mcpServers = {};
+  let changed = false;
+  for (const [name, spec] of Object.entries(specs)) {
+    const prev = existing.mcpServers[name];
+    if (prev && JSON.stringify(prev) === JSON.stringify(spec)) continue;
+    existing.mcpServers[name] = spec;
+    changed = true;
+  }
+  if (!changed) return { status: "present", backup: null };
+  const backup = backupFile(filePath);
+  writeJson(filePath, existing);
+  return { status: "written", backup };
+}
+
+export function report(status, detail = {}) {
+  return { status, ...detail };
+}

package/src/cli/operator-dispatch.mjs

@@ -0,0 +1,258 @@
+import fs from "node:fs";
+import path from "node:path";
+import { spawnSync } from "node:child_process";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+const PACKAGE_ROOT = path.resolve(HERE, "../..");
+
+export const OPERATOR_BIN_NAMES = Object.freeze([
+  "oracle-vault",
+  "oracle-credential",
+  "oracle-signer",
+  "oracle-runner",
+  "oracle-agentic-init",
+  "oracle-agentic-doctor",
+  "oracle-control-mcp",
+  "oracle-operator-caps",
+]);
+
+export const SIGN_NOUNS = Object.freeze([
+  "vault",
+  "credential",
+  "signer",
+  "runner",
+  "sign",
+]);
+
+export const OPERATOR_NOT_INSTALLED_MESSAGE = `oracle: signing lives in @oracle-agent/operator, which is not installed.
+
+  The public 'oracle' package is prepare-only and never handles keys.
+  To enable local signing on THIS machine:
+
+    npm i -g @oracle-agent/operator      # or add it to this project
+    oracle sign init                     # provision keys + policy (interactive)
+
+  Nothing about your read/research setup is affected.
+`;
+
+export const SIGN_HINT =
+  "hint: run 'oracle sign init' to provision keys, or 'oracle sign doctor --json' for detail.";
+
+function whichOnPath(binName) {
+  const pathEnv = process.env.PATH || "";
+  const parts = pathEnv.split(path.delimiter).filter(Boolean);
+  const exts = process.platform === "win32" ? ["", ".cmd", ".exe", ".bat"] : [""];
+  for (const dir of parts) {
+    for (const ext of exts) {
+      const candidate = path.join(dir, binName + ext);
+      try {
+        if (fs.existsSync(candidate) && fs.statSync(candidate).isFile()) {
+          return candidate;
+        }
+      } catch {
+        // ignore
+      }
+    }
+  }
+  return null;
+}
+
+function binsFromDir(binDir) {
+  const bins = {};
+  for (const name of OPERATOR_BIN_NAMES) {
+    const candidates = [
+      path.join(binDir, name),
+      path.join(binDir, `${name}.mjs`),
+      path.join(binDir, `${name}.js`),
+    ];
+    for (const c of candidates) {
+      if (fs.existsSync(c) && fs.statSync(c).isFile()) {
+        bins[name] = c;
+        break;
+      }
+    }
+  }
+  return bins;
+}
+
+function findPackageRoot(entryPath) {
+  let dir = path.dirname(entryPath);
+  while (dir !== path.dirname(dir)) {
+    const pkgJson = path.join(dir, "package.json");
+    if (fs.existsSync(pkgJson)) {
+      try {
+        const pkg = JSON.parse(fs.readFileSync(pkgJson, "utf8"));
+        if (pkg.name === "@oracle-agent/operator") return { root: dir, pkg };
+      } catch {
+        // continue upward
+      }
+    }
+    dir = path.dirname(dir);
+  }
+  return null;
+}
+
+function tryResolvePackage(fromPaths) {
+  for (const from of fromPaths) {
+    try {
+      const req = createRequire(path.join(from, "package.json"));
+      let found;
+      try {
+        const pkgJson = req.resolve("@oracle-agent/operator/package.json");
+        found = {
+          root: path.dirname(pkgJson),
+          pkg: JSON.parse(fs.readFileSync(pkgJson, "utf8")),
+        };
+      } catch {
+        const entry = req.resolve("@oracle-agent/operator");
+        found = findPackageRoot(entry);
+      }
+      if (!found) continue;
+      const { root, pkg } = found;
+      const binField = pkg.bin || {};
+      const bins = {};
+      for (const [name, rel] of Object.entries(binField)) {
+        bins[name] = path.resolve(root, rel);
+      }
+      const extra = binsFromDir(path.join(root, "bin"));
+      for (const [k, v] of Object.entries(extra)) {
+        if (!bins[k]) bins[k] = v;
+      }
+      return {
+        ok: true,
+        binDir: path.join(root, "bin"),
+        version: pkg.version || "unknown",
+        bins,
+        source: `require:${from}`,
+      };
+    } catch {
+      // continue
+    }
+  }
+  return null;
+}
+
+function tryCapsOnPath() {
+  const capsBin = whichOnPath("oracle-operator-caps");
+  if (!capsBin) return null;
+  const r = spawnSync(capsBin, [], {
+    encoding: "utf8",
+    timeout: 5000,
+    env: process.env,
+  });
+  if (r.status !== 0 || !r.stdout) return null;
+  try {
+    const report = JSON.parse(r.stdout);
+    if (!report || typeof report !== "object" || !report.bins) return null;
+    return {
+      ok: true,
+      binDir: path.dirname(Object.values(report.bins)[0] || capsBin),
+      version: report.version || "unknown",
+      bins: report.bins,
+      source: "caps-path",
+      controlMcp: report.controlMcp,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function tryPathProbe() {
+  const bins = {};
+  for (const name of OPERATOR_BIN_NAMES) {
+    const hit = whichOnPath(name);
+    if (hit) bins[name] = hit;
+  }
+  if (!Object.keys(bins).length) return null;
+  return {
+    ok: true,
+    binDir: path.dirname(Object.values(bins)[0]),
+    version: "unknown",
+    bins,
+    source: "path-probe",
+  };
+}
+
+export function resolveOperator() {
+  const envDir = process.env.ORACLE_OPERATOR_BIN_DIR;
+  if (envDir) {
+    const abs = path.resolve(envDir);
+    if (!fs.existsSync(abs)) return { ok: false };
+    const bins = binsFromDir(abs);
+    if (!Object.keys(bins).length) return { ok: false };
+    let version = "unknown";
+    const pkgCandidate = path.resolve(abs, "../package.json");
+    if (fs.existsSync(pkgCandidate)) {
+      try {
+        version = JSON.parse(fs.readFileSync(pkgCandidate, "utf8")).version || version;
+      } catch {
+        // ignore
+      }
+    }
+    return { ok: true, binDir: abs, version, bins, source: "env:ORACLE_OPERATOR_BIN_DIR" };
+  }
+
+  const fromPkg =
+    tryResolvePackage([process.cwd(), PACKAGE_ROOT]) ||
+    tryCapsOnPath() ||
+    tryPathProbe();
+  return fromPkg || { ok: false };
+}
+
+export function printOperatorNotInstalled(stream = process.stderr) {
+  stream.write(OPERATOR_NOT_INSTALLED_MESSAGE);
+  if (!OPERATOR_NOT_INSTALLED_MESSAGE.endsWith("\n")) stream.write("\n");
+}
+
+export function dispatchOperator(binName, argv = [], opts = {}) {
+  const resolved = resolveOperator();
+  if (!resolved.ok) {
+    printOperatorNotInstalled(opts.stderr || process.stderr);
+    return 3;
+  }
+  const binPath = resolved.bins[binName];
+  if (!binPath) {
+    const err = opts.stderr || process.stderr;
+    err.write(`oracle: operator bin '${binName}' not found in resolved operator (${resolved.source})\n`);
+    return 3;
+  }
+
+  const stdio = opts.stdio || "inherit";
+  const isJs = /\.(mjs|cjs|js)$/.test(binPath);
+  const command = isJs ? process.execPath : binPath;
+  const args = isJs ? [binPath, ...argv] : [...argv];
+  const r = spawnSync(command, args, {
+    stdio,
+    env: opts.env || process.env,
+    cwd: opts.cwd || process.cwd(),
+    encoding: stdio === "pipe" ? "utf8" : undefined,
+  });
+
+  if (r.error) {
+    const err = opts.stderr || process.stderr;
+    err.write(`oracle: failed to spawn ${binName}: ${r.error.message}\n`);
+    return 1;
+  }
+
+  const code = typeof r.status === "number" ? r.status : 1;
+  if (code !== 0 && opts.appendHintOnError) {
+    const err = opts.stderr || process.stderr;
+    err.write(SIGN_HINT + "\n");
+  }
+  if (stdio === "pipe") {
+    return { code, stdout: r.stdout || "", stderr: r.stderr || "" };
+  }
+  return code;
+}
+
+export default {
+  resolveOperator,
+  dispatchOperator,
+  printOperatorNotInstalled,
+  OPERATOR_NOT_INSTALLED_MESSAGE,
+  SIGN_HINT,
+  SIGN_NOUNS,
+  OPERATOR_BIN_NAMES,
+};

package/src/cli/paths.mjs

@@ -0,0 +1,78 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const HERE = path.dirname(fileURLToPath(import.meta.url));
+export const PACKAGE_ROOT = path.resolve(HERE, "../..");
+
+export function homeDir() {
+  return process.env.ORACLE_FAKE_HOME || os.homedir();
+}
+
+export function oracleConfigDir() {
+  return path.join(homeDir(), ".config", "oracle");
+}
+
+export function oracleExecEnvPath() {
+  return path.join(oracleConfigDir(), "exec.env");
+}
+
+export function hermesRoot() {
+  if (process.env.HERMES_HOME) return path.resolve(process.env.HERMES_HOME);
+  return path.join(homeDir(), ".hermes");
+}
+
+export function claudeCodeUserConfigPath() {
+  return path.join(homeDir(), ".claude.json");
+}
+
+export function claudeCodeProjectMcpPath(cwd = process.cwd()) {
+  return path.join(cwd, ".mcp.json");
+}
+
+export function claudeDesktopConfigPath() {
+  if (process.platform === "darwin") {
+    return path.join(homeDir(), "Library", "Application Support", "Claude", "claude_desktop_config.json");
+  }
+  return path.join(homeDir(), ".config", "Claude", "claude_desktop_config.json");
+}
+
+export function codexConfigPath() {
+  return path.join(homeDir(), ".codex", "config.toml");
+}
+
+export function chatgptConnectorDir() {
+  return path.join(oracleConfigDir(), "connectors");
+}
+
+export function chatgptOpenApiPath() {
+  return path.join(chatgptConnectorDir(), "chatgpt-openapi.json");
+}
+
+export function packageBin(name) {
+  return path.join(PACKAGE_ROOT, "bin", name);
+}
+
+export function ensureDir(dir) {
+  fs.mkdirSync(dir, { recursive: true });
+  return dir;
+}
+
+export const paths = {
+  homeDir,
+  oracleConfigDir,
+  oracleExecEnvPath,
+  hermesRoot,
+  claudeCodeUserConfigPath,
+  claudeCodeProjectMcpPath,
+  claudeDesktopConfigPath,
+  codexConfigPath,
+  chatgptConnectorDir,
+  chatgptOpenApiPath,
+  packageBin,
+  ensureDir,
+  PACKAGE_ROOT,
+};
+
+export default paths;

package/src/cli/spawn-child.mjs

@@ -0,0 +1,43 @@
+import { spawn } from "node:child_process";
+
+const FORWARDED_SIGNALS = ["SIGINT", "SIGTERM", "SIGHUP"];
+
+export function spawnChild(command, args = [], options = {}, label = command) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, options);
+    let settled = false;
+    let forwardedSignal = null;
+
+    const handlers = new Map(
+      FORWARDED_SIGNALS.map((signal) => [signal, () => {
+        forwardedSignal ||= signal;
+        if (child.exitCode === null && child.signalCode === null) child.kill(signal);
+      }]),
+    );
+    for (const [signal, handler] of handlers) process.on(signal, handler);
+
+    const cleanup = () => {
+      for (const [signal, handler] of handlers) process.off(signal, handler);
+    };
+
+    child.once("error", (error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      process.stderr.write(`oracle: could not start ${label}: ${error.message}\n`);
+      resolve(1);
+    });
+
+    child.once("exit", (code, signal) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      const propagated = forwardedSignal || signal;
+      if (propagated) {
+        process.kill(process.pid, propagated);
+        return;
+      }
+      resolve(code ?? 1);
+    });
+  });
+}

package/src/exec-policy.mjs

@@ -419,6 +419,12 @@ export function enforceTxPolicy(tx = {}, phase = "broadcast") {
   // Spending caps toggle. Set MAD_VALUE_CAPS_ENABLED=0 in exec.env to lift the
   // per-tx + daily native caps (chain/dest allowlists still enforced). Flip back
   // to 1 to re-arm the cap wall. Default = ON when unset.
+  //
+  // Deliberately strict: ONLY the literal "0" lifts the caps. This is the
+  // opposite polarity from a kill switch. Disabling a kill switch makes a
+  // deployment safer, so it accepts 0/false/off/no. Disabling THIS makes a
+  // deployment riskier, so a stray "false" must keep the cap wall standing
+  // rather than silently removing it. Do not route this through envEnabled.
   const capsOn = String(env("ORACLE_VALUE_CAPS_ENABLED", "MAD_VALUE_CAPS_ENABLED", "1")).trim() !== "0";
   if (!capsOn) return true;
 

package/src/index.mjs

@@ -67,3 +67,27 @@ export {
   DEFAULT_SCOPES,
   normalizeScopes,
 } from "./scopes.mjs";
+
+export { emitHarnessConfigs, createHarnessConfigs } from "./onboarding/harness-configs.mjs";
+export {
+  ACTION_RECEIPT_VERSION,
+  ActionReceiptSecretError,
+  assertNoReceiptSecrets,
+  canonicalReceiptJson,
+  computeReceiptId,
+  normalizeActionReceipt,
+  createActionReceipt,
+  summarizeActionReceipt,
+  formatActionReceipt,
+} from "./action-receipts.mjs";
+export { DEFAULT_RISK_THRESHOLDS, summarizePortfolioRisk, portfolioRiskSummary } from "./portfolio-risk.mjs";
+export {
+  WATCH_CATEGORIES,
+  defaultPreferences,
+  subscribe,
+  unsubscribe,
+  createWatch,
+  evaluateAlert,
+  shouldDeliverAlert,
+} from "./watch-preferences.mjs";
+export { SIGNAL_TYPES, scoreSignals, createSignalsEngine } from "./signals/index.mjs";