@evomap/evolver 1.89.20 → 2.0.0-beta.0

package/src/atp/cli.js

@@ -1,354 +0,0 @@
-// ATP CLI: lightweight argument parsers and runners for the `buy`, `orders`,
-// and `verify` subcommands. Separated from index.js so they can be unit-tested
-// without booting the full evolver loop.
-//
-// Public API:
-//   parseBuyArgs(args)   -> { ok, opts?, error? }
-//   parseOrdersArgs(args)-> { ok, opts?, error? }
-//   parseVerifyArgs(args)-> { ok, opts?, error? }
-//   runBuy(opts, deps)
-//   runOrders(opts, deps)
-//   runVerify(opts, deps)
-//
-// `deps` is an object containing the ATP module (defaults to require('./index')),
-// injectable for tests. Each runner returns a Promise that resolves to
-// { exitCode: number, output?: string, data?: object }.
-
-const {
-  ATP_VERIFY_MODES,
-  ATP_VERIFY_ACTIONS,
-  ATP_ROUTING_MODES,
-  ATP_PROOF_STATUSES,
-  ATP_ROLES,
-} = require('./protocol');
-
-function _parseNamed(args, longFlag, shortFlag) {
-  const long = args.findIndex(a => typeof a === 'string' && (a === longFlag || a.startsWith(longFlag + '=')));
-  if (long !== -1) {
-    const token = args[long];
-    if (token.startsWith(longFlag + '=')) return token.slice(longFlag.length + 1);
-    if (args[long + 1] && !String(args[long + 1]).startsWith('--')) return args[long + 1];
-  }
-  if (shortFlag) {
-    const short = args.indexOf(shortFlag);
-    if (short !== -1 && args[short + 1] && !String(args[short + 1]).startsWith('--')) return args[short + 1];
-  }
-  return null;
-}
-
-function _toBool(v) {
-  if (typeof v !== 'string') return false;
-  const s = v.toLowerCase();
-  return s === '1' || s === 'true' || s === 'yes' || s === 'on';
-}
-
-function parseBuyArgs(args) {
-  if (!Array.isArray(args) || args.length === 0) {
-    return { ok: false, error: 'buy requires <capabilities>: comma-separated list (e.g. code_review,bug_fix)' };
-  }
-
-  // First positional (not starting with --) is the capability list.
-  let capabilitiesRaw = null;
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (typeof a === 'string' && !a.startsWith('--')) {
-      capabilitiesRaw = a;
-      break;
-    }
-  }
-  if (!capabilitiesRaw) {
-    return { ok: false, error: 'buy requires <capabilities>: comma-separated list' };
-  }
-
-  const capabilities = capabilitiesRaw.split(',').map(s => s.trim()).filter(Boolean);
-  if (capabilities.length === 0) {
-    return { ok: false, error: 'no valid capabilities parsed from: ' + capabilitiesRaw };
-  }
-
-  const budgetRaw = _parseNamed(args, '--budget', '-b');
-  const budget = Math.max(1, Math.round(Number(budgetRaw) || 10));
-
-  const question = _parseNamed(args, '--question', '-q') || '';
-  const routingMode = _parseNamed(args, '--routing', null) || 'fastest';
-  const verifyMode = _parseNamed(args, '--verify', null) || 'auto';
-  const noWait = args.includes('--no-wait');
-  const timeoutMsRaw = _parseNamed(args, '--timeout', null);
-  const timeoutMs = timeoutMsRaw ? Math.max(1000, Math.round(Number(timeoutMsRaw) * 1000)) : 300000;
-
-  return {
-    ok: true,
-    opts: {
-      capabilities,
-      budget,
-      question,
-      routingMode,
-      verifyMode,
-      noWait,
-      timeoutMs,
-    },
-  };
-}
-
-function parseOrdersArgs(args) {
-  const role = _parseNamed(args, '--role', null);
-  if (role && !ATP_ROLES.includes(role)) {
-    return { ok: false, error: 'invalid --role: ' + role + ' (expected ' + ATP_ROLES.join('|') + ')' };
-  }
-  const status = _parseNamed(args, '--status', null);
-  if (status && !ATP_PROOF_STATUSES.includes(status)) {
-    return { ok: false, error: 'invalid --status: ' + status };
-  }
-  const limitRaw = _parseNamed(args, '--limit', null);
-  const limit = limitRaw ? Math.max(1, Math.min(100, Math.round(Number(limitRaw)))) : 20;
-  const jsonOut = args.includes('--json');
-  return {
-    ok: true,
-    opts: { role: role || 'consumer', status: status || null, limit, jsonOut },
-  };
-}
-
-function parseVerifyArgs(args) {
-  let orderId = null;
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (typeof a === 'string' && !a.startsWith('--')) {
-      orderId = a;
-      break;
-    }
-  }
-  if (!orderId) {
-    return { ok: false, error: 'verify requires <orderId>' };
-  }
-  const action = _parseNamed(args, '--action', null) || 'confirm';
-  if (!ATP_VERIFY_ACTIONS.includes(action)) {
-    return { ok: false, error: 'invalid --action: ' + action + ' (expected ' + ATP_VERIFY_ACTIONS.join('|') + ')' };
-  }
-  return { ok: true, opts: { orderId, action } };
-}
-
-// `evolver atp <enable|disable|status>` — manage autoBuyer consent ack file.
-// Non-TTY users (daemon, CI, hooks) opt in here instead of the interactive
-// first-run prompt. Returns { ok, opts: { sub } } or { ok: false, error }.
-function parseAtpArgs(args) {
-  if (!Array.isArray(args) || args.length === 0) {
-    return { ok: false, error: 'atp requires <enable|disable|status>' };
-  }
-  let sub = null;
-  for (let i = 0; i < args.length; i++) {
-    const a = args[i];
-    if (typeof a === 'string' && !a.startsWith('--')) {
-      sub = a.toLowerCase();
-      break;
-    }
-  }
-  if (!sub || !['enable', 'disable', 'status'].includes(sub)) {
-    return { ok: false, error: 'atp subcommand must be enable|disable|status (got: ' + sub + ')' };
-  }
-  return { ok: true, opts: { sub } };
-}
-
-async function runBuy(opts, deps) {
-  const atp = (deps && deps.atp) || require('./index');
-  const consumerAgent = atp.consumerAgent;
-  const log = (deps && deps.log) || console.log;
-  const err = (deps && deps.err) || console.error;
-
-  log('[ATP] Placing order: capabilities=' + opts.capabilities.join(',') + ' budget=' + opts.budget + ' mode=' + opts.routingMode);
-
-  try {
-    if (opts.noWait) {
-      const result = await consumerAgent.orderService({
-        capabilities: opts.capabilities,
-        budget: opts.budget,
-        routingMode: opts.routingMode,
-        verifyMode: opts.verifyMode,
-        question: opts.question,
-      });
-      if (!result.ok) {
-        err('[ATP] Order failed: ' + (result.error || 'unknown'));
-        return { exitCode: 1, data: result };
-      }
-      log('[ATP] Order placed: ' + result.data.order_id);
-      return { exitCode: 0, data: result.data };
-    }
-
-    const result = await consumerAgent.orderAndWait({
-      capabilities: opts.capabilities,
-      budget: opts.budget,
-      routingMode: opts.routingMode,
-      verifyMode: opts.verifyMode,
-      question: opts.question,
-      timeoutMs: opts.timeoutMs,
-    });
-
-    if (!result.ok) {
-      err('[ATP] Order lifecycle failed: ' + (result.error || 'unknown'));
-      return { exitCode: 1, data: result };
-    }
-    log('[ATP] Order settled: ' + (result.order && result.order.order_id));
-    if (result.finalStatus) {
-      log('[ATP] Final status: ' + JSON.stringify(result.finalStatus, null, 2));
-    }
-    return { exitCode: 0, data: result };
-  } catch (e) {
-    err('[ATP] buy error: ' + (e && e.message || e));
-    return { exitCode: 1, error: String(e) };
-  }
-}
-
-async function runOrders(opts, deps) {
-  const atp = (deps && deps.atp) || require('./index');
-  const hubClient = atp.hubClient;
-  const log = (deps && deps.log) || console.log;
-  const err = (deps && deps.err) || console.error;
-
-  try {
-    const result = await hubClient.listProofs({
-      role: opts.role,
-      status: opts.status || undefined,
-      limit: opts.limit,
-    });
-    if (!result.ok) {
-      err('[ATP] listProofs failed: ' + (result.error || 'unknown'));
-      return { exitCode: 1, data: result };
-    }
-
-    const proofs = (result.data && result.data.proofs) || result.data || [];
-    if (opts.jsonOut) {
-      log(JSON.stringify(proofs, null, 2));
-      return { exitCode: 0, data: proofs };
-    }
-    if (!Array.isArray(proofs) || proofs.length === 0) {
-      log('[ATP] No orders found for role=' + opts.role + (opts.status ? ' status=' + opts.status : ''));
-      return { exitCode: 0, data: [] };
-    }
-    log('[ATP] Showing ' + proofs.length + ' order(s):');
-    for (const p of proofs) {
-      const when = p.createdAt || p.created_at || 'unknown';
-      log('  - ' + (p.taskId || p.order_id || p.id) + ' | status=' + p.status + ' | created=' + when);
-    }
-    return { exitCode: 0, data: proofs };
-  } catch (e) {
-    err('[ATP] orders error: ' + (e && e.message || e));
-    return { exitCode: 1, error: String(e) };
-  }
-}
-
-async function runVerify(opts, deps) {
-  const atp = (deps && deps.atp) || require('./index');
-  const consumerAgent = atp.consumerAgent;
-  const log = (deps && deps.log) || console.log;
-  const err = (deps && deps.err) || console.error;
-
-  try {
-    const fn = opts.action === 'ai_judge' ? consumerAgent.requestAiJudge : consumerAgent.confirmDelivery;
-    const result = await fn(opts.orderId);
-    if (!result.ok) {
-      err('[ATP] verify failed: ' + (result.error || 'unknown'));
-      return { exitCode: 1, data: result };
-    }
-    log('[ATP] verify ok (' + opts.action + '): ' + JSON.stringify(result.data));
-    return { exitCode: 0, data: result.data };
-  } catch (e) {
-    err('[ATP] verify error: ' + (e && e.message || e));
-    return { exitCode: 1, error: String(e) };
-  }
-}
-
-// Subcommand runner for `evolver atp enable|disable|status`. Writes the ack
-// file via autoBuyer.setConsent so subsequent daemon starts pick it up. Does
-// NOT mutate process.env — env override wins over the ack file by design,
-// and we don't want a transient CLI invocation to silently shadow operator
-// shell config.
-// Detect whether an EVOLVER_ATP_AUTOBUY env override is currently set AND
-// would supersede the ack we are about to write. Returns the effective env
-// boolean (true=on, false=off) or null if env is unset / whitespace-only.
-// Mirrors the trim-before-length-check rule from autoBuyer.getConsent so
-// the CLI and the runtime agree on what "set" means (Bugbot PR #141).
-function _envOverride() {
-  const raw = process.env.EVOLVER_ATP_AUTOBUY;
-  if (typeof raw !== 'string') return null;
-  const s = raw.trim().toLowerCase();
-  if (s.length === 0) return null;
-  return !(s === 'off' || s === '0' || s === 'false');
-}
-
-async function runAtp(opts, deps) {
-  const autoBuyer = (deps && deps.autoBuyer) || require('./autoBuyer');
-  const log = (deps && deps.log) || console.log;
-  const err = (deps && deps.err) || console.error;
-
-  try {
-    if (opts.sub === 'enable') {
-      const body = autoBuyer.setConsent(true);
-      log('[ATP] auto-spend ENABLED (consent recorded ' + body.acknowledged_at + ').');
-      log('      Caps: daily=' + (process.env.ATP_AUTOBUY_DAILY_CAP_CREDITS || '50') +
-          ', per-order=' + (process.env.ATP_AUTOBUY_PER_ORDER_CAP_CREDITS || '10') + ' credits.');
-      log('      Disable: evolver atp disable  (or  EVOLVER_ATP_AUTOBUY=off)');
-      // Loud warning if an env override will silently undo the ack at
-      // runtime. Bugbot PR #141 Medium: without this the user gets a
-      // false confirmation and real credits keep flowing the wrong way.
-      const envEnabled = _envOverride();
-      if (envEnabled === false) {
-        log('');
-        log('[ATP] WARNING: EVOLVER_ATP_AUTOBUY=' + process.env.EVOLVER_ATP_AUTOBUY +
-            ' is set in your environment and will OVERRIDE the ack file at runtime.');
-        log('      Auto-spend will stay OFF until you unset it (env wins over the ack file).');
-        return { exitCode: 0, data: body, envOverride: 'off' };
-      }
-      return { exitCode: 0, data: body };
-    }
-    if (opts.sub === 'disable') {
-      const body = autoBuyer.setConsent(false);
-      log('[ATP] auto-spend DISABLED (consent recorded ' + body.acknowledged_at + ').');
-      log('      Re-enable: evolver atp enable');
-      const envEnabled = _envOverride();
-      if (envEnabled === true) {
-        log('');
-        log('[ATP] WARNING: EVOLVER_ATP_AUTOBUY=' + process.env.EVOLVER_ATP_AUTOBUY +
-            ' is set in your environment and will OVERRIDE the ack file at runtime.');
-        log('      Auto-spend will stay ON (and continue charging credits) until you unset it.');
-        return { exitCode: 0, data: body, envOverride: 'on' };
-      }
-      return { exitCode: 0, data: body };
-    }
-    // status
-    const consent = autoBuyer.getConsent();
-    const ackPath = autoBuyer.getAckPath();
-    log('[ATP] auto-spend: ' + (consent.enabled ? 'ENABLED' : 'DISABLED') +
-        '  (source: ' + consent.source + ')');
-    log('      ack file: ' + ackPath);
-    if (consent.source === 'default') {
-      log('      Default policy (no ack file, no env override). Run `evolver atp disable`');
-      log('      to opt out, or `evolver atp enable` to record explicit opt-in.');
-    }
-    return { exitCode: 0, data: consent };
-  } catch (e) {
-    err('[ATP] atp command error: ' + (e && e.message || e));
-    return { exitCode: 1, error: String(e) };
-  }
-}
-
-function printUsage() {
-  return [
-    'ATP subcommands:',
-    '  evolver buy <caps> [--budget=N] [--question "..."] [--routing=' + ATP_ROUTING_MODES.join('|') + ']',
-    '              [--verify=' + ATP_VERIFY_MODES.join('|') + '] [--no-wait] [--timeout=<seconds>]',
-    '  evolver orders [--role=' + ATP_ROLES.join('|') + '] [--status=' + ATP_PROOF_STATUSES.join('|') + ']',
-    '                 [--limit=N] [--json]',
-    '  evolver verify <orderId> [--action=' + ATP_VERIFY_ACTIONS.join('|') + ']',
-    '  evolver atp <enable|disable|status>   -- manage auto-spend consent',
-  ].join('\n');
-}
-
-module.exports = {
-  parseBuyArgs,
-  parseOrdersArgs,
-  parseVerifyArgs,
-  parseAtpArgs,
-  runBuy,
-  runOrders,
-  runVerify,
-  runAtp,
-  printUsage,
-};

package/src/atp/cliAutobuyPrompt.js

@@ -1,154 +0,0 @@
-"use strict";
-
-/**
- * First-run prompt that introduces the ATP autoBuyer to interactive users.
- *
- * Triggers when ALL conditions hold:
- *   - process.stdin.isTTY === true (skipped under systemd, Docker, CI)
- *   - EVOLVER_ATP_AUTOBUY is not already set (neither on nor off)
- *   - ack file memory/atp-autobuy-ack.json does not exist (already decided)
- *
- * Outcomes:
- *   - user answers y         -> autoBuyer.setConsent(true) — opts in for future sessions
- *   - user answers n         -> autoBuyer.setConsent(false) — prompt never shown again
- *   - user answers later     -> no ack written, prompt shown next session
- *   - any non-TTY/ack branch -> silent no-op
- *
- * setConsent failures (FS permission, disk full) are surfaced to the user
- * via the output stream and returned as `reason: 'ack_write_failed'`; the
- * decision field still reflects what the user typed.
- */
-
-const readline = require("readline");
-const autoBuyer = require("./autoBuyer");
-
-// All ack file plumbing lives on autoBuyer (filename constant, path
-// resolution, read with strict validation, atomic write via tmp+rename).
-// cliAutobuyPrompt always reaches it through the public surface so the
-// two modules cannot diverge on schema or validation — pre-consolidation
-// drift bit us twice (Bugbot PR #141: duplicate writers + lenient-vs-
-// strict reader). No __internals re-export here either: tests import
-// autoBuyer directly so a future rename trips a single set of asserts.
-
-/**
- * @returns {"ack_present"|"env_set"|"non_tty"|"eligible"}
- */
-function classify(env, stdin) {
-  const envVal = env && env.EVOLVER_ATP_AUTOBUY;
-  if (typeof envVal === "string" && envVal.trim().length > 0) {
-    return "env_set";
-  }
-  if (!stdin || !stdin.isTTY) {
-    return "non_tty";
-  }
-  if (autoBuyer.readAck()) {
-    return "ack_present";
-  }
-  return "eligible";
-}
-
-function _ask(question, { input, output }) {
-  return new Promise((resolve) => {
-    const rl = readline.createInterface({ input, output });
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve((answer || "").trim().toLowerCase());
-    });
-  });
-}
-
-/**
- * Synchronously decide whether to prompt (TTY + no ack + env unset) and,
- * if prompting, block on user answer. Resolves with:
- *   { prompted: bool, decision: "yes"|"no"|"later"|null, reason: string }
- *
- * Should be called at most once per `evolver run` invocation, BEFORE the
- * autoBuyer.start() branch in the run loop.
- *
- * @param {object} [opts]
- * @param {NodeJS.ReadableStream} [opts.input]
- * @param {NodeJS.WritableStream} [opts.output]
- * @param {NodeJS.ProcessEnv} [opts.env]
- * @param {(q: string, io: object) => Promise<string>} [opts.ask]
- * @returns {Promise<{ prompted: boolean, decision: string|null, reason: string }>}
- */
-async function runPrompt(opts) {
-  opts = opts || {};
-  const input = opts.input || process.stdin;
-  const output = opts.output || process.stdout;
-  const env = opts.env || process.env;
-  const ask = typeof opts.ask === "function" ? opts.ask : _ask;
-
-  const state = classify(env, input);
-  if (state !== "eligible") {
-    return { prompted: false, decision: null, reason: state };
-  }
-
-  try {
-    output.write("\n");
-    output.write("[ATP-AutoBuyer] Your evolver will automatically place small-priced\n");
-    output.write("ATP orders when it detects a capability gap. This spends real\n");
-    output.write("credits on the EvoMap hub and is ON by default for new installs.\n");
-    output.write("  - daily hard cap:   ATP_AUTOBUY_DAILY_CAP_CREDITS (default 50)\n");
-    output.write("  - per-order cap:    ATP_AUTOBUY_PER_ORDER_CAP_CREDITS (default 10)\n");
-    output.write("  - change later:     evolver atp enable | evolver atp disable\n");
-    output.write("\n");
-  } catch (_) {
-    return { prompted: false, decision: null, reason: "io_error" };
-  }
-
-  let answer;
-  try {
-    answer = await ask("Keep ATP auto-spend ON for future sessions? [y=keep enabled / n=disable / later=ask again next session] ", {
-      input,
-      output,
-    });
-  } catch (_) {
-    return { prompted: true, decision: null, reason: "ask_error" };
-  }
-
-  // For y/n we persist via autoBuyer.setConsent (atomic tmp+rename, throws
-  // on FS failure). If the write fails we MUST tell the user — for the 'n'
-  // path especially, since auto-spend is default-ON and a failed disable
-  // means the user typed "off" but the runtime keeps charging credits
-  // (Bugbot PR #141 Medium: unchecked ack write). Do NOT mutate process.env
-  // on success: that would double-signal and shadow any explicit operator
-  // preference set later.
-  function _persistConsent(enabled, decision) {
-    try {
-      autoBuyer.setConsent(enabled);
-      return { prompted: true, decision, reason: enabled ? "user_accepted" : "user_declined" };
-    } catch (err) {
-      try {
-        output.write("[ATP-AutoBuyer] WARN: failed to persist consent: " + (err && err.message || err) + "\n");
-        if (enabled) {
-          output.write("                Auto-spend will keep using the default-on policy until\n");
-          output.write("                the ack is saved (capped at the configured caps).\n");
-        } else {
-          output.write("                Auto-spend will STAY ON (default policy) until your opt-out\n");
-          output.write("                can be saved — your decline was not persisted.\n");
-        }
-        output.write("                Check disk space and write permissions on the memory dir, then run\n");
-        output.write("                `evolver atp " + (enabled ? "enable" : "disable") + "` to retry.\n");
-      } catch (_) { /* output stream is broken too — nothing more we can do */ }
-      return { prompted: true, decision, reason: "ack_write_failed" };
-    }
-  }
-
-  if (answer === "y" || answer === "yes") {
-    return _persistConsent(true, "yes");
-  }
-  if (answer === "n" || answer === "no") {
-    return _persistConsent(false, "no");
-  }
-  // Postpone: no ack written, so autoBuyer.getConsent() returns
-  // {enabled: true, source: 'default'} this session. Auto-spend keeps
-  // running under the default policy with caps; the prompt will fire again
-  // next interactive session so the user can confirm or opt out.
-  return { prompted: true, decision: "later", reason: "user_postponed" };
-}
-
-module.exports = {
-  runPrompt,
-  classify,
-};

package/src/atp/consumerAgent.js

@@ -1,157 +0,0 @@
-// ATP Consumer Agent Template
-// Provides a ready-to-use consumer agent that searches for services,
-// places orders, and manages delivery verification.
-//
-// Usage:
-//   const consumer = require('./consumerAgent');
-//   const result = await consumer.orderService({ capabilities: ['code_review'], budget: 50 });
-
-const { getNodeId, sendHelloToHub } = require('../gep/a2aProtocol');
-const { placeOrder, verifyDelivery, settleOrder, disputeOrder, getOrderStatus, getAtpPolicy } = require('./hubClient');
-
-let _initialized = false;
-
-async function ensureInitialized() {
-  if (_initialized) return;
-  const hello = await sendHelloToHub();
-  if (!hello || !hello.ok) {
-    throw new Error('Failed to register with Hub: ' + (hello?.error || 'unknown'));
-  }
-  _initialized = true;
-}
-
-/**
- * Place an ATP order for a service.
- * @param {object} opts
- * @param {string[]} opts.capabilities - what the order needs
- * @param {number} opts.budget - credits to spend
- * @param {string} [opts.routingMode] - fastest | cheapest | auction | swarm
- * @param {string} [opts.verifyMode] - auto | ai_judge | bilateral
- * @param {string} [opts.question] - description of what you need
- * @returns {Promise<{ok: boolean, data?: object, error?: string}>}
- */
-async function orderService(opts) {
-  await ensureInitialized();
-
-  const result = await placeOrder({
-    capabilities: opts.capabilities,
-    budget: Math.max(1, Math.round(Number(opts.budget) || 10)),
-    routingMode: opts.routingMode || 'fastest',
-    verifyMode: opts.verifyMode || 'auto',
-    question: opts.question,
-    signals: opts.signals,
-    minReputation: opts.minReputation,
-  });
-
-  if (result.ok) {
-    console.log('[ATP-Consumer] Order placed:', result.data.order_id, '-> merchant:', result.data.merchant?.node_id);
-  }
-
-  return result;
-}
-
-/**
- * Confirm delivery of an order (bilateral mode).
- * @param {string} orderId
- * @returns {Promise<{ok: boolean, data?: object, error?: string}>}
- */
-async function confirmDelivery(orderId) {
-  await ensureInitialized();
-  return verifyDelivery(orderId, 'confirm');
-}
-
-/**
- * Request AI judge verification.
- * @param {string} orderId
- * @returns {Promise<{ok: boolean, data?: object, error?: string}>}
- */
-async function requestAiJudge(orderId) {
-  await ensureInitialized();
-  return verifyDelivery(orderId, 'ai_judge');
-}
-
-/**
- * Force settlement of an order.
- * @param {string} orderId
- * @returns {Promise<{ok: boolean, data?: object, error?: string}>}
- */
-async function settle(orderId) {
-  await ensureInitialized();
-  return settleOrder(orderId);
-}
-
-/**
- * Raise a dispute for an order.
- * @param {string} orderId
- * @param {string} reason - min 10 chars
- * @returns {Promise<{ok: boolean, data?: object, error?: string}>}
- */
-async function dispute(orderId, reason) {
-  await ensureInitialized();
-  return disputeOrder(orderId, reason);
-}
-
-/**
- * Check the status of an order.
- * @param {string} orderId
- * @returns {Promise<{ok: boolean, data?: object, error?: string}>}
- */
-async function checkOrder(orderId) {
-  return getOrderStatus(orderId);
-}
-
-/**
- * Get ATP policy information (tiers, rates, etc.)
- * @returns {Promise<{ok: boolean, data?: object, error?: string}>}
- */
-async function getPolicy() {
-  return getAtpPolicy();
-}
-
-/**
- * Full order lifecycle: place -> wait -> verify -> settle.
- * @param {object} opts - same as orderService
- * @param {number} [opts.pollIntervalMs] - how often to check status (default 10s)
- * @param {number} [opts.timeoutMs] - max wait time (default 300s)
- * @returns {Promise<{ok: boolean, order?: object, finalStatus?: object, error?: string}>}
- */
-async function orderAndWait(opts) {
-  const order = await orderService(opts);
-  if (!order.ok) return order;
-
-  const orderId = order.data.order_id;
-  const pollMs = opts.pollIntervalMs || 10000;
-  const timeoutMs = opts.timeoutMs || 300000;
-  const deadline = Date.now() + timeoutMs;
-
-  while (Date.now() < deadline) {
-    await new Promise(resolve => setTimeout(resolve, pollMs));
-
-    const status = await checkOrder(orderId);
-    if (!status.ok) continue;
-
-    const proofStatus = status.data.proof_status;
-    if (proofStatus === 'settled') {
-      return { ok: true, order: order.data, finalStatus: status.data };
-    }
-    if (proofStatus === 'verified' && order.data.verify_mode === 'auto') {
-      return { ok: true, order: order.data, finalStatus: status.data };
-    }
-    if (proofStatus === 'disputed') {
-      return { ok: false, order: order.data, finalStatus: status.data, error: 'order_disputed' };
-    }
-  }
-
-  return { ok: false, order: order.data, error: 'order_timeout' };
-}
-
-module.exports = {
-  orderService,
-  confirmDelivery,
-  requestAiJudge,
-  settle,
-  dispute,
-  checkOrder,
-  getPolicy,
-  orderAndWait,
-};