@oracle-agent/oracle 0.3.5 → 0.3.6

package/src/profile-upgrade.mjs

@@ -0,0 +1,277 @@
+import fs from "node:fs";
+import path from "node:path";
+import { randomBytes } from "node:crypto";
+import { createRequire } from "node:module";
+
+export const UPGRADE_VERSION = "oracle-profile-upgrade/v1";
+
+function exists(file) {
+  try { fs.accessSync(file); return true; } catch { return false; }
+}
+
+function snapshot(dir) {
+  if (!exists(dir)) return [];
+  return fs.readdirSync(dir, { recursive: true, withFileTypes: true })
+    .filter((entry) => entry.isFile())
+    .map((entry) => path.join(entry.parentPath || entry.path, entry.name))
+    .sort()
+    .map((file) => [path.relative(dir, file), fs.readFileSync(file)]);
+}
+
+function desiredTree(source) {
+  const files = snapshot(source);
+  files.push([".oracle-upgrade-version", Buffer.from(`${UPGRADE_VERSION}\n`)]);
+  return files.sort(([a], [b]) => a.localeCompare(b));
+}
+
+function treeMatches(dest, files) {
+  const actual = snapshot(dest);
+  return actual.length === files.length && actual.every(([name, body], i) =>
+    name === files[i][0] && body.equals(files[i][1]));
+}
+
+function tempSibling(target) {
+  return `${target}.tmp-oracle-upgrade-${process.pid}-${randomBytes(6).toString("hex")}`;
+}
+
+function backupName(target) {
+  let candidate = `${target}.bak-oracle-upgrade`;
+  for (let n = 1; exists(candidate); n += 1) candidate = `${target}.bak-oracle-upgrade-${n}`;
+  return candidate;
+}
+
+function installTree(source, dest, apply, report) {
+  if (!exists(source) || !fs.statSync(source).isDirectory()) return;
+  const files = desiredTree(source);
+  if (treeMatches(dest, files)) {
+    report.unchanged.push(dest);
+    return;
+  }
+  const wasPresent = exists(dest);
+  (wasPresent ? report.updated : report.created).push(dest);
+  if (!apply) return;
+  fs.mkdirSync(path.dirname(dest), { recursive: true });
+  const tmp = tempSibling(dest);
+  let backup = null;
+  fs.mkdirSync(tmp);
+  try {
+    for (const [name, body] of files) {
+      const out = path.join(tmp, name);
+      fs.mkdirSync(path.dirname(out), { recursive: true });
+      fs.writeFileSync(out, body);
+    }
+    if (wasPresent) {
+      backup = backupName(dest);
+      fs.renameSync(dest, backup);
+      report.backups.push({ path: backup, original: dest });
+    }
+    fs.renameSync(tmp, dest);
+  } catch (error) {
+    if (exists(tmp)) fs.rmSync(tmp, { recursive: true, force: true });
+    if (backup && !exists(dest) && exists(backup)) fs.renameSync(backup, dest);
+    throw error;
+  }
+}
+
+// This deliberately accepts only the ordinary block-style YAML Hermes writes.
+// Unsupported constructs fail closed rather than risking a lossy rewrite.
+function validateYaml(text, file) {
+  if (/^mcp_servers:[ \t]*(?!\{\}[ \t]*(?:#.*)?$)\S+/m.test(text)) {
+    throw new Error(`${file}: mcp_servers must be a block mapping`);
+  }
+  const stack = [];
+  const keys = new Map();
+  const lines = text.split(/\r?\n/);
+  let flow = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const raw = lines[index];
+    if (/^\s*#/.test(raw)) continue;
+    if (/^\s*\t|^ +\t/.test(raw)) throw new Error(`${file}:${index + 1}: tabs are not supported in YAML indentation`);
+    const line = raw.replace(/\s+#.*$/, "");
+    if (!line.trim() || /^\s*(?:---|\.\.\.)\s*$/.test(line)) continue;
+    const quoteFree = line.replace(/'(?:[^']|'')*'|"(?:[^"\\]|\\.)*"/g, "");
+    for (const char of quoteFree) {
+      if ("[{".includes(char)) flow += 1;
+      if ("]}".includes(char)) flow -= 1;
+      if (flow < 0) throw new Error(`${file}:${index + 1}: unbalanced flow collection`);
+    }
+    if (/^\s*[^#\-][^:]*:\s*(?:.*)?$/.test(line)) {
+      const indent = line.match(/^ */)[0].length;
+      const key = line.trimStart().match(/^([^:]+):/)[1].trim();
+      while (stack.length && stack.at(-1).indent >= indent) stack.pop();
+      const parent = stack.map((item) => item.key).join("/");
+      const id = `${parent}|${indent}|${key}`;
+      if (keys.has(id)) throw new Error(`${file}:${index + 1}: duplicate mapping key ${key}`);
+      keys.set(id, true);
+      if (/^[^:]+:\s*(?:#.*)?$/.test(line.trimStart())) stack.push({ indent, key });
+    } else if (!/^\s*-\s+/.test(line) && flow === 0) {
+      throw new Error(`${file}:${index + 1}: unsupported or malformed YAML`);
+    }
+  }
+  if (flow !== 0) throw new Error(`${file}: unbalanced flow collection`);
+  if (/^\s*[^#\n]*:\s*[>|][+-]?\s*$/m.test(text)) {
+    // Block scalars are safe to preserve outside mcp_servers, but editing inside
+    // one would require a complete YAML parser.
+    const mcp = topLevelBlock(text, "mcp_servers");
+    if (mcp && /:\s*[>|][+-]?\s*$/m.test(mcp.body)) throw new Error(`${file}: block scalars inside mcp_servers are unsupported`);
+  }
+}
+
+function topLevelBlock(text, name) {
+  const re = new RegExp(`^${name}:[^\\S\\r\\n]*(?:#.*)?$`, "m");
+  const match = re.exec(text);
+  if (!match) return null;
+  const start = match.index;
+  const bodyStart = text.indexOf("\n", start) + 1;
+  if (!bodyStart) return { start, end: text.length, bodyStart: text.length, body: "" };
+  const rest = text.slice(bodyStart);
+  const next = /^(?=\S[^\r\n]*:)/m.exec(rest);
+  const end = next ? bodyStart + next.index : text.length;
+  return { start, bodyStart, end, body: text.slice(bodyStart, end) };
+}
+
+function scalar(value) {
+  return JSON.stringify(value);
+}
+
+function serverBlock(name, command) {
+  const words = command.command === "node" ? [command.script] : command.args;
+  const lines = [`  ${name}:`, `    command: ${scalar(command.command)}`];
+  if (words?.length) lines.push("    args:", ...words.map((arg) => `      - ${scalar(arg)}`));
+  lines.push("    enabled: true", `    # ${UPGRADE_VERSION}`);
+  return `${lines.join("\n")}\n`;
+}
+
+function mergeMcp(text, desired) {
+  text = text.replace(
+    /^(mcp_servers:)\s*\{\}\s*(#.*)?$/m,
+    (_line, head, comment) => `${head}${comment ? ` ${comment}` : ""}`,
+  );
+  const block = topLevelBlock(text, "mcp_servers");
+  if (!block) {
+    const prefix = text.length && !text.endsWith("\n") ? "\n" : "";
+    return `${text}${prefix}mcp_servers:\n${[...desired].map(([n, c]) => serverBlock(n, c)).join("")}`;
+  }
+  let body = block.body;
+  for (const [name, command] of desired) {
+    const child = new RegExp(`^  ${name}:[^\\S\\r\\n]*(?:#.*)?\\r?\\n(?:^(?: {3,}|\\s*$).*\\r?\\n?)*`, "m");
+    const replacement = serverBlock(name, command);
+    body = child.test(body) ? body.replace(child, replacement) : `${body}${body && !body.endsWith("\n") ? "\n" : ""}${replacement}`;
+  }
+  return `${text.slice(0, block.bodyStart)}${body}${text.slice(block.end)}`;
+}
+
+function mergeEnabledPlugin(text, pluginId) {
+  text = text.replace(
+    /^(plugins:)\s*\{\}\s*(#.*)?$/m,
+    (_line, head, comment) => `${head}${comment ? ` ${comment}` : ""}`,
+  );
+  const item = `    - ${scalar(pluginId)}\n`;
+  const block = topLevelBlock(text, "plugins");
+  if (!block) {
+    const prefix = text.length && !text.endsWith("\n") ? "\n" : "";
+    return `${text}${prefix}plugins:\n  enabled:\n${item}`;
+  }
+  let body = block.body;
+  const flow = /^  enabled:\s*\[([^\]]*)\](.*)$/m.exec(body);
+  if (flow) {
+    const values = flow[1].split(",").map((value) => value.trim().replace(/^["']|["']$/g, ""));
+    if (!values.includes(pluginId)) {
+      const joined = flow[1].trim() ? `${flow[1].trimEnd()}, ${scalar(pluginId)}` : scalar(pluginId);
+      body = body.replace(flow[0], `  enabled: [${joined}]${flow[2]}`);
+    }
+  } else {
+    const sequence = /^  enabled:\s*(?:#.*)?\r?\n((?:^ {4}-.*\r?\n?)*)/m.exec(body);
+    if (sequence) {
+      const values = sequence[1].split(/\r?\n/).map((line) => line.replace(/^\s*-\s*/, "").trim().replace(/^["']|["']$/g, ""));
+      if (!values.includes(pluginId)) body = body.replace(sequence[0], `${sequence[0]}${item}`);
+    } else {
+      body = `${body}${body && !body.endsWith("\n") ? "\n" : ""}  enabled:\n${item}`;
+    }
+  }
+  return `${text.slice(0, block.bodyStart)}${body}${text.slice(block.end)}`;
+}
+
+function writeAtomic(file, body, report) {
+  const present = exists(file);
+  const old = present ? fs.readFileSync(file, "utf8") : null;
+  if (old === body) { report.unchanged.push(file); return; }
+  (present ? report.updated : report.created).push(file);
+  if (!report.applied) return;
+  fs.mkdirSync(path.dirname(file), { recursive: true });
+  if (present) {
+    const backup = backupName(file);
+    fs.copyFileSync(file, backup);
+    report.backups.push({ path: backup, original: file });
+  }
+  const tmp = tempSibling(file);
+  try {
+    fs.writeFileSync(tmp, body, { mode: present ? fs.statSync(file).mode : 0o600 });
+    fs.renameSync(tmp, file);
+  } catch (error) {
+    if (exists(tmp)) fs.rmSync(tmp, { force: true });
+    throw error;
+  }
+}
+
+function resolveControl(packageRoot, explicit) {
+  if (explicit) {
+    const [command, ...args] = explicit;
+    return { command, args };
+  }
+  const candidates = [
+    path.join(packageRoot, "bin", "oracle-control-mcp.mjs"),
+    path.join(packageRoot, "plugins", "oracle-owner-gate", "bin", "oracle-control-mcp.mjs"),
+    path.join(packageRoot, "plugins", "oracle-owner-gate", "oracle-control-mcp.mjs"),
+    // Control MCP ships with the local operator package, not the prepare-only public root.
+    path.join(packageRoot, "..", "@oracle-agent", "operator", "bin", "oracle-control-mcp.mjs"),
+    path.join(packageRoot, "..", "..", "@oracle-agent", "operator", "bin", "oracle-control-mcp.mjs"),
+  ];
+  for (const script of candidates) {
+    if (exists(script) && fs.statSync(script).isFile()) return { command: "node", script: path.resolve(script) };
+  }
+  try {
+    const require = createRequire(path.join(packageRoot, "package.json"));
+    const operatorPkg = path.dirname(require.resolve("@oracle-agent/operator/package.json"));
+    const script = path.join(operatorPkg, "bin", "oracle-control-mcp.mjs");
+    if (exists(script) && fs.statSync(script).isFile()) return { command: "node", script: path.resolve(script) };
+  } catch {}
+  return null;
+}
+
+export function upgradeProfiles({ hermesHome, packageRoot, only = null, apply = false, controlCommand = null }) {
+  const profilesRoot = path.join(hermesHome, "profiles");
+  const report = { ok: true, applied: apply, version: UPGRADE_VERSION, hermesHome, packageRoot, profiles: [], created: [], updated: [], unchanged: [], backups: [] };
+  let profiles = exists(profilesRoot) ? fs.readdirSync(profilesRoot, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort() : [];
+  if (only) profiles = profiles.filter((name) => name === only);
+  if (only && profiles.length === 0) throw new Error(`profile not found: ${only}`);
+  report.profiles = profiles;
+
+  // Validate every selected config before planning or performing any write.
+  const configs = new Map();
+  for (const profile of profiles) {
+    const file = path.join(profilesRoot, profile, "config.yaml");
+    const text = exists(file) ? fs.readFileSync(file, "utf8") : "";
+    validateYaml(text, file);
+    configs.set(profile, text);
+  }
+
+  const skillSource = path.join(packageRoot, "skills", "oracle-action-semantics");
+  if (!exists(skillSource)) throw new Error(`required Oracle skill is missing: ${skillSource}`);
+  const pluginSource = path.join(packageRoot, "plugins", "oracle-owner-gate");
+  const control = resolveControl(packageRoot, controlCommand);
+  const dataScript = path.join(packageRoot, "bin", "oracle-data-mcp.mjs");
+  if (!exists(dataScript)) throw new Error(`oracle-data MCP command is missing: ${dataScript}`);
+
+  for (const profile of profiles) {
+    const root = path.join(profilesRoot, profile);
+    installTree(skillSource, path.join(root, "skills", "oracle-action-semantics"), apply, report);
+    if (exists(pluginSource)) installTree(pluginSource, path.join(root, "plugins", "oracle-owner-gate"), apply, report);
+    const desired = new Map([["oracle-data", { command: "node", script: dataScript }]]);
+    if (control) desired.set("oracle-control", control);
+    let config = mergeMcp(configs.get(profile), desired);
+    if (exists(pluginSource)) config = mergeEnabledPlugin(config, "oracle-owner-gate");
+    writeAtomic(path.join(root, "config.yaml"), config, report);
+  }
+  return report;
+}

package/src/scanner/chains.config.mjs

@@ -220,6 +220,8 @@ export const CHAIN_CONFIGS = Object.freeze([
     // the slug, resolvePools reported UNAVAILABLE on every RH token even though the
     // data was there.
     dexscreenerSlug: "robinhood",
+    venueKind: "uniswap-v3",
+    wrappedNative: "0x0bd7d308f8e1639fab988df18a8011f41eacad73",
     venues: [
       {
         kind: "quoter",

package/src/vault-attestation.mjs

@@ -129,6 +129,7 @@ export function assertVaultAttestation(attestation, tx = {}, { chainId, nowMs =
 export function assertVaultApprovalAttestation(attestation, tx = {}, guard = {}, { chainId, nowMs = Date.now(), secret } = {}) {
   if (!attestation || attestation.mode !== "vault-attestation") throw new Error("vault attestation required");
   if (String(attestation.action) !== "deposit") throw new Error("vault approval requires deposit attestation");
+  assertFreshWindow(attestation, nowMs, "vault approval attestation");
   if (Number(attestation.expiresAtMs) <= Number(nowMs)) throw new Error("vault attestation expired");
   const expected = hmac(attestationSecret(secret), canonicalJson(unsigned(attestation)));
   if (!sameSignature(attestation.signature, expected)) throw new Error("vault attestation signature mismatch");

package/src/cards.mjs

@@ -1,369 +0,0 @@
-// Telegram card TEXT renderers.
-//
-// Implements skills/oracle-chain-graphs-telegram-cards/SKILL.md. That spec has
-// existed with no code behind it, so Oracle users were getting raw JSON instead
-// of readable alert cards. This module is the text half only: chart/image
-// rendering lives elsewhere and MUST NOT be required for a card to send.
-//
-// Contract for every exported renderer:
-//   - pure, synchronous, string in / string out
-//   - NO network, NO signing, NO filesystem, NO env reads, NO mutation of input
-//   - unknown data renders as the literal string UNKNOWN — never blank, never
-//     guessed, never interpolated from a neighbouring field
-//   - the only identifier (contract address / mint / market id) is NEVER
-//     truncated: a half-address is worse than no address because it still looks
-//     actionable
-//   - chart failure is cosmetic: the text card always returns
-//   - buy/sell affordances only when a valid local grant/session is supplied
-//
-// Markdown dialect: Telegram *legacy* Markdown. Values are escaped for `_`,
-// `*`, `[`, `]` and backtick; card chrome supplies its own markers. We never
-// emit `$` at all (the spec calls out repeated `$` spans as a formatting trap)
-// — amounts are suffixed with USD instead.
-
-import { chainById } from "./chains.mjs";
-
-/** The one and only stand-in for missing data. */
-export const UNKNOWN = "UNKNOWN";
-
-export const CARD_KINDS = Object.freeze(["token", "launch", "hip3", "hip4", "polymarket"]);
-
-const LEGACY_MD_SPECIALS = /[_*[\]`]/g;
-
-/**
- * Escape Telegram legacy-Markdown control characters in a *value*.
- * Card chrome (bold headers) is written unescaped by the renderers themselves.
- * @param {unknown} value
- * @returns {string} escaped text, or UNKNOWN when there is nothing to show
- */
-export function escapeMd(value) {
-  if (!isPresent(value)) return UNKNOWN;
-  return String(value).replace(LEGACY_MD_SPECIALS, (c) => `\\${c}`);
-}
-
-function isPresent(value) {
-  if (value === null || value === undefined) return false;
-  if (typeof value === "number") return Number.isFinite(value);
-  if (typeof value === "string") return value.trim() !== "";
-  return true;
-}
-
-/** A value that must survive verbatim (addresses, mints, market ids). */
-function code(value) {
-  if (!isPresent(value)) return UNKNOWN;
-  // Backticks would close the span; strip rather than truncate the identifier.
-  const raw = String(value).replace(/`/g, "");
-  return raw === "" ? UNKNOWN : `\`${raw}\``;
-}
-
-function num(value, { decimals = 2 } = {}) {
-  if (!isPresent(value)) return UNKNOWN;
-  const n = typeof value === "bigint" ? Number(value) : Number(value);
-  if (!Number.isFinite(n)) return UNKNOWN;
-  return n.toLocaleString("en-US", { minimumFractionDigits: 0, maximumFractionDigits: decimals });
-}
-
-/** Money. Deliberately no `$` — repeated dollar spans break Telegram parsing. */
-function usd(value, { decimals = 2 } = {}) {
-  const n = num(value, { decimals });
-  return n === UNKNOWN ? UNKNOWN : `${n} USD`;
-}
-
-function pct(value, { decimals = 2 } = {}) {
-  const n = num(value, { decimals });
-  return n === UNKNOWN ? UNKNOWN : `${n}%`;
-}
-
-function bps(value) {
-  const n = num(value, { decimals: 0 });
-  return n === UNKNOWN ? UNKNOWN : `${n} bps`;
-}
-
-/**
- * Exact base-unit -> decimal string. BigInt only: a raw quote like
- * 24325001237995579150138 loses precision the moment it touches a float.
- */
-export function formatUnits(raw, decimals) {
-  if (!isPresent(raw)) return UNKNOWN;
-  const d = Number(decimals);
-  if (!Number.isInteger(d) || d < 0 || d > 77) return UNKNOWN;
-  let value;
-  try {
-    value = BigInt(typeof raw === "string" ? raw.trim() : raw);
-  } catch {
-    return UNKNOWN;
-  }
-  const neg = value < 0n;
-  const abs = neg ? -value : value;
-  const base = 10n ** BigInt(d);
-  const whole = (abs / base).toString();
-  const frac = (abs % base).toString().padStart(d, "0").replace(/0+$/, "");
-  return `${neg ? "-" : ""}${whole}${frac ? `.${frac}` : ""}`;
-}
-
-/** Normalize confidence to a stated band. Every card must state one. */
-export function normalizeConfidence(value) {
-  if (typeof value === "number" && Number.isFinite(value)) {
-    if (value < 0 || value > 1) return UNKNOWN;
-    if (value >= 0.75) return "HIGH";
-    if (value >= 0.4) return "MEDIUM";
-    return "LOW";
-  }
-  if (typeof value === "string") {
-    const v = value.trim().toUpperCase();
-    if (v === "HIGH" || v === "MEDIUM" || v === "LOW") return v;
-  }
-  return UNKNOWN;
-}
-
-function chainLine(data = {}) {
-  const id = data.chainId;
-  if (!isPresent(id) || !Number.isFinite(Number(id))) {
-    return isPresent(data.chain) ? escapeMd(data.chain) : UNKNOWN;
-  }
-  const known = chainById(id);
-  const name = known?.name || (isPresent(data.chain) ? String(data.chain) : UNKNOWN);
-  return `${escapeMd(name)} (chainId ${Number(id)})`;
-}
-
-function venueLine(data = {}) {
-  return escapeMd(data.venue ?? data.dex ?? data.pool?.venue);
-}
-
-/**
- * Chart status. A graph is evidence, not a dependency — if the image failed we
- * say so and the text card still stands.
- */
-function chartLine(chart) {
-  if (chart === null || chart === undefined) return "NONE (text card only)";
-  if (typeof chart === "string") return chart.trim() ? code(chart) : "NONE (text card only)";
-  if (chart.error || chart.ok === false || chart.available === false) {
-    const why = isPresent(chart.error) ? ` — ${escapeMd(chart.error)}` : "";
-    return `UNAVAILABLE${why} (text card stands)`;
-  }
-  if (isPresent(chart.url)) return code(chart.url);
-  return "NONE (text card only)";
-}
-
-/**
- * Buy/sell affordances are gated on a valid LOCAL grant or session. Absent or
- * expired grant => prepare-only. This function is the single gate; renderers
- * never decide on their own.
- * @returns {{ allowed: boolean, reason: string, actions: string[] }}
- */
-export function cardActions(data = {}, { now = Date.now() } = {}) {
-  const grant = data.grant ?? data.session ?? null;
-  if (!grant || typeof grant !== "object") {
-    return { allowed: false, reason: "no local grant/session", actions: [] };
-  }
-  if (grant.local === false) {
-    return { allowed: false, reason: "grant is not local", actions: [] };
-  }
-  if (grant.revoked === true) {
-    return { allowed: false, reason: "grant revoked", actions: [] };
-  }
-  const expiry = grant.expiresAt ?? grant.expiry;
-  if (isPresent(expiry)) {
-    const at = typeof expiry === "number" ? expiry : Date.parse(expiry);
-    if (!Number.isFinite(at)) return { allowed: false, reason: "grant expiry unreadable", actions: [] };
-    if (at <= now) return { allowed: false, reason: "grant expired", actions: [] };
-  }
-  const actions = Array.isArray(grant.actions) && grant.actions.length ? grant.actions.slice() : ["BUY", "SELL"];
-  return { allowed: true, reason: "valid local grant", actions };
-}
-
-function actionsLine(data) {
-  const gate = cardActions(data);
-  return gate.allowed
-    ? `${gate.actions.map((a) => escapeMd(a)).join(" / ")} (${escapeMd(gate.reason)})`
-    : `prepare-only — ${escapeMd(gate.reason)}`;
-}
-
-function build(title, rows, data = {}) {
-  const lines = [`*${title}*`];
-  for (const [label, value] of rows) {
-    // Labels are authored here and contain no markdown specials by construction.
-    lines.push(`${label}: ${value === undefined || value === null || value === "" ? UNKNOWN : value}`);
-  }
-  lines.push(`Chart: ${chartLine(data.chart)}`);
-  lines.push(`Actions: ${actionsLine(data)}`);
-  if (Array.isArray(data.warnings) && data.warnings.length) {
-    lines.push(`Warnings: ${data.warnings.map((w) => escapeMd(w)).join("; ")}`);
-  }
-  if (isPresent(data.source) || isPresent(data.fetchedAt)) {
-    lines.push(`Source: ${escapeMd(data.source)} at ${escapeMd(data.fetchedAt)}`);
-  }
-  return lines.join("\n");
-}
-
-function confidenceRow(data) {
-  return ["Confidence", normalizeConfidence(data.confidence)];
-}
-
-function quoteRows(data) {
-  const q = data.quote;
-  if (!q || typeof q !== "object") return [];
-  const human = isPresent(q.decimals) ? formatUnits(q.amountOutRaw ?? q.out ?? q.raw, q.decimals) : UNKNOWN;
-  return [
-    ["Quote out (raw)", code(q.amountOutRaw ?? q.out ?? q.raw)],
-    ["Quote out", human === UNKNOWN ? UNKNOWN : `${escapeMd(human)} ${escapeMd(q.symbol ?? "")}`.trim()],
-  ];
-}
-
-function slippageRow(data) {
-  const s = data.autoSlippage;
-  if (!s || typeof s !== "object") return ["Auto-slippage", UNKNOWN];
-  const sel = bps(s.selectedBps);
-  const cap = bps(s.capBps);
-  return ["Auto-slippage", sel === UNKNOWN && cap === UNKNOWN ? UNKNOWN : `${sel} selected, cap ${cap}`];
-}
-
-/** Per-chain token card: price, volume, liquidity, market cap, age, venue. */
-export function renderTokenCard(data = {}) {
-  const d = data || {};
-  return build(
-    `ORACLE TOKEN — ${escapeMd(d.symbol ?? d.token ?? d.name)}`,
-    [
-      ["Chain", chainLine(d)],
-      ["Venue", venueLine(d)],
-      ["Name", escapeMd(d.name)],
-      ["Address", code(d.address ?? d.mint ?? d.contract)],
-      ["Price", usd(d.priceUsd, { decimals: 8 })],
-      ["Market cap", usd(d.marketCapUsd)],
-      ["Liquidity", usd(d.liquidityUsd)],
-      ["Volume 24h", usd(d.volume24hUsd)],
-      ["Change 24h", pct(d.priceChange24h)],
-      ["Fee tier", isPresent(d.feeTier) ? `${bps(Number(d.feeTier) / 100)} (${num(d.feeTier, { decimals: 0 })})` : UNKNOWN],
-      ["Age", escapeMd(d.age)],
-      ...quoteRows(d),
-      slippageRow(d),
-      confidenceRow(d),
-    ],
-    d,
-  );
-}
-
-/** Launch/sniper card: route readiness, sellability, overlap, risk, ticket. */
-export function renderLaunchCard(data = {}) {
-  const d = data || {};
-  return build(
-    `ORACLE LAUNCH — ${escapeMd(d.symbol ?? d.token ?? d.name)}`,
-    [
-      ["Chain", chainLine(d)],
-      ["Venue", venueLine(d)],
-      ["Address", code(d.address ?? d.mint ?? d.contract)],
-      ["Pool", code(d.pool?.address ?? d.poolAddress ?? d.pool)],
-      ["Liquidity", usd(d.liquidityUsd)],
-      ["Route ready", escapeMd(d.routeReady)],
-      ["Sellable", escapeMd(d.sellable)],
-      ["Sell sim", escapeMd(d.sellSimulation ?? d.sellSim)],
-      ["Smart wallets", escapeMd(d.smartWalletOverlap)],
-      ["Risk", escapeMd(d.risk ?? d.riskStatus)],
-      ["Prepared ticket", escapeMd(d.preparedTicket ?? d.ticketStatus)],
-      slippageRow(d),
-      confidenceRow(d),
-    ],
-    d,
-  );
-}
-
-/** Hyperliquid HIP-3 builder-dex card. Requires perpDexs + metaAndAssetCtxs. */
-export function renderHip3Card(data = {}) {
-  const d = data || {};
-  return build(
-    `ORACLE HIP-3 — ${escapeMd(d.market ?? d.coin ?? d.name)}`,
-    [
-      ["Venue", `Hyperliquid builder-dex ${escapeMd(d.dex)}`],
-      ["Market", escapeMd(d.market ?? d.coin)],
-      ["Mark", usd(d.markPx, { decimals: 6 })],
-      ["Oracle", usd(d.oraclePx, { decimals: 6 })],
-      ["Funding", pct(d.funding, { decimals: 6 })],
-      ["Open interest", usd(d.openInterestUsd)],
-      ["Depth", escapeMd(d.depth)],
-      ["Liquidation notes", escapeMd(d.liquidationNotes ?? d.riskNotes)],
-      ["Account context", escapeMd(d.accountContext)],
-      confidenceRow(d),
-    ],
-    d,
-  );
-}
-
-/** Hyperliquid HIP-4 outcome-market card. Public reads are keyless. */
-export function renderHip4Card(data = {}) {
-  const d = data || {};
-  return build(
-    `ORACLE HIP-4 — ${escapeMd(d.event ?? d.market ?? d.name)}`,
-    [
-      ["Venue", `Hyperliquid HIP-4 ${escapeMd(d.dex ?? "outcome")}`],
-      ["Event", escapeMd(d.event)],
-      ["Outcome", escapeMd(d.outcome)],
-      ["Market id", code(d.marketId ?? d.market)],
-      ["Bid", usd(d.bid, { decimals: 6 })],
-      ["Ask", usd(d.ask, { decimals: 6 })],
-      ["Depth", escapeMd(d.depth)],
-      ["Edge", pct(d.edge)],
-      ["Position", escapeMd(d.position)],
-      confidenceRow(d),
-    ],
-    d,
-  );
-}
-
-/** Polymarket card. Public reads keyless; orders stay prepared/user-signed. */
-export function renderPolymarketCard(data = {}) {
-  const d = data || {};
-  return build(
-    `ORACLE POLYMARKET — ${escapeMd(d.event ?? d.market ?? d.name)}`,
-    [
-      ["Venue", "Polymarket CLOB"],
-      ["Event", escapeMd(d.event)],
-      ["Market", escapeMd(d.market)],
-      ["Market id", code(d.marketId ?? d.conditionId ?? d.tokenId)],
-      ["Yes", usd(d.yesPrice, { decimals: 4 })],
-      ["No", usd(d.noPrice, { decimals: 4 })],
-      ["Best bid / ask", `${usd(d.bestBid, { decimals: 4 })} / ${usd(d.bestAsk, { decimals: 4 })}`],
-      ["Volume", usd(d.volumeUsd)],
-      ["Resolution risk", escapeMd(d.resolutionRisk)],
-      ["Order intent", escapeMd(d.orderIntent)],
-      confidenceRow(d),
-    ],
-    d,
-  );
-}
-
-const RENDERERS = Object.freeze({
-  token: renderTokenCard,
-  launch: renderLaunchCard,
-  hip3: renderHip3Card,
-  hip4: renderHip4Card,
-  polymarket: renderPolymarketCard,
-});
-
-/**
- * Dispatch by surface kind.
- * @param {"token"|"launch"|"hip3"|"hip4"|"polymarket"} kind
- */
-export function renderCard(kind, data = {}) {
-  const fn = RENDERERS[String(kind)];
-  if (!fn) throw new Error(`unknown card kind: ${kind} (expected one of ${CARD_KINDS.join(", ")})`);
-  return fn(data);
-}
-
-/**
- * Total soft-fail wrapper. An alert that cannot render is still an alert the
- * user needs to see, so a malformed payload degrades to a minimal card rather
- * than throwing and dropping the notification.
- */
-export function safeRenderCard(kind, data = {}) {
-  try {
-    return renderCard(kind, data);
-  } catch (error) {
-    return [
-      `*ORACLE CARD — DEGRADED*`,
-      `Kind: ${escapeMd(kind)}`,
-      `Chain: ${UNKNOWN}`,
-      `Confidence: ${UNKNOWN}`,
-      `Render error: ${escapeMd(error?.message)}`,
-    ].join("\n");
-  }
-}