openclaw-overlay-plugin 0.8.15 → 0.8.17

package/dist/index.js

@@ -1,365 +1,3074 @@
-import path from 'node:path';
-import os from 'node:os';
-import fs from 'node:fs';
-import { initializeServiceSystem, serviceManager } from './src/services/index.js';
-// Direct imports of command logic
-import { cmdStatus, cmdSetup, cmdAddress, cmdIdentity } from './src/scripts/wallet/setup.js';
-import { cmdBalance, cmdImport } from './src/scripts/wallet/balance.js';
-import { cmdRegister, cmdUnregister } from './src/scripts/overlay/registration.js';
-import { cmdDiscover } from './src/scripts/overlay/discover.js';
-import { cmdRequestService } from './src/scripts/services/request.js';
-import { cmdServiceQueue } from './src/scripts/services/queue.js';
-import { cmdRespondService } from './src/scripts/services/respond.js';
-import { cmdConnect } from './src/scripts/messaging/connect.js';
-import { setNoExit } from './src/scripts/output.js';
-import debug from 'debug';
-const log = debug('openclaw:plugin:overlay');
-let isInitialized = false;
-// Track background service state
-let serviceRunning = false;
-let abortController = null;
-// Auto-import tracking
-let autoImportInterval = null;
-let knownTxids = new Set();
-// Track woken service requests to prevent duplicate processing
-let wokenRequests = new Set();
-let requestCleanupInterval = null;
-// Budget tracking
-const BUDGET_FILE = 'daily-spending.json';
-function getBudgetPath(walletDir) {
-    return path.join(walletDir, BUDGET_FILE);
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/scripts/config.ts
+var config_exports = {};
+__export(config_exports, {
+  AGENT_DESCRIPTION: () => AGENT_DESCRIPTION,
+  AGENT_NAME: () => AGENT_NAME,
+  DEFAULT_SLAP_TRACKERS: () => DEFAULT_SLAP_TRACKERS,
+  LOOKUP_SERVICES: () => LOOKUP_SERVICES,
+  NETWORK: () => NETWORK,
+  OVERLAY_STATE_DIR: () => OVERLAY_STATE_DIR,
+  OVERLAY_URL: () => OVERLAY_URL,
+  PATHS: () => PATHS,
+  PROTOCOL_ID: () => PROTOCOL_ID,
+  TOPICS: () => TOPICS,
+  WALLET_DIR: () => WALLET_DIR,
+  WOC_API_KEY: () => WOC_API_KEY
+});
+import path2 from "node:path";
+import os from "node:os";
+import fs2 from "node:fs";
+var overlayEnvPath, WALLET_DIR, NETWORK, OVERLAY_URL, AGENT_NAME, AGENT_DESCRIPTION, WOC_API_KEY, OVERLAY_STATE_DIR, PROTOCOL_ID, TOPICS, DEFAULT_SLAP_TRACKERS, LOOKUP_SERVICES, PATHS;
+var init_config = __esm({
+  "src/scripts/config.ts"() {
+    "use strict";
+    overlayEnvPath = path2.join(os.homedir(), ".openclaw", "openclaw-overlay", ".env");
+    try {
+      if (fs2.existsSync(overlayEnvPath)) {
+        for (const line of fs2.readFileSync(overlayEnvPath, "utf-8").split("\n")) {
+          const match = line.match(/^([A-Z_]+)=(.+)$/);
+          if (match && !process["env"][match[1]]) {
+            process["env"][match[1]] = match[2]?.trim();
+          }
+        }
+      }
+    } catch {
+    }
+    WALLET_DIR = process["env"].BSV_WALLET_DIR || path2.join(os.homedir(), ".openclaw", "bsv-wallet");
+    NETWORK = process["env"].BSV_NETWORK || "mainnet";
+    OVERLAY_URL = process["env"].OVERLAY_URL || "https://clawoverlay.com";
+    AGENT_NAME = process["env"].AGENT_NAME || "openclaw-agent";
+    AGENT_DESCRIPTION = process["env"].AGENT_DESCRIPTION || `AI agent on the OpenClaw Overlay Network. Offers services for BSV micropayments.`;
+    WOC_API_KEY = process["env"].WOC_API_KEY || "";
+    OVERLAY_STATE_DIR = path2.join(os.homedir(), ".openclaw", "openclaw-overlay");
+    PROTOCOL_ID = "clawdbot-overlay-v1";
+    TOPICS = {
+      IDENTITY: "tm_clawdbot_identity",
+      SERVICES: "tm_clawdbot_services",
+      X_VERIFICATION: "tm_clawdbot_x_verification",
+      SHIP: "tm_ship",
+      SLAP: "tm_slap"
+    };
+    DEFAULT_SLAP_TRACKERS = {
+      mainnet: ["https://overlay.babbage.systems"],
+      testnet: ["https://testnet-users.bapp.dev"]
+    };
+    LOOKUP_SERVICES = {
+      AGENTS: "ls_clawdbot_agents",
+      SERVICES: "ls_clawdbot_services",
+      X_VERIFICATIONS: "ls_clawdbot_x_verifications"
+    };
+    PATHS = {
+      walletIdentity: path2.join(WALLET_DIR, "wallet-identity.json"),
+      registration: path2.join(OVERLAY_STATE_DIR, "registration.json"),
+      services: path2.join(OVERLAY_STATE_DIR, "services.json"),
+      latestChange: path2.join(OVERLAY_STATE_DIR, "latest-change.json"),
+      receivedPayments: path2.join(OVERLAY_STATE_DIR, "received-payments.jsonl"),
+      researchQueue: path2.join(OVERLAY_STATE_DIR, "research-queue.jsonl"),
+      serviceQueue: path2.join(OVERLAY_STATE_DIR, "service-queue.jsonl"),
+      notifications: path2.join(OVERLAY_STATE_DIR, "notifications.jsonl"),
+      xVerifications: path2.join(OVERLAY_STATE_DIR, "x-verifications.json"),
+      pendingXVerification: path2.join(OVERLAY_STATE_DIR, "pending-x-verification.json"),
+      xEngagementQueue: path2.join(OVERLAY_STATE_DIR, "x-engagement-queue.jsonl"),
+      memoryStore: path2.join(WALLET_DIR, "memory-store.json"),
+      baemailConfig: path2.join(OVERLAY_STATE_DIR, "baemail-config.json"),
+      baemailLog: path2.join(OVERLAY_STATE_DIR, "baemail-log.jsonl")
+    };
+  }
+});
+
+// src/scripts/output.ts
+function setNoExit(value) {
+  noExitFlag = value;
 }
-function loadDailySpending(walletDir) {
-    const today = new Date().toISOString().slice(0, 10);
-    const budgetPath = getBudgetPath(walletDir);
+function ok(data) {
+  if (noExitFlag) return { success: true, data };
+  console.log(JSON.stringify({ success: true, data }));
+  process.exit(0);
+}
+function fail(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  if (noExitFlag) return { success: false, error: message };
+  console.log(JSON.stringify({ success: false, error: message }));
+  process.exit(1);
+}
+var noExitFlag;
+var init_output = __esm({
+  "src/scripts/output.ts"() {
+    "use strict";
+    noExitFlag = false;
+  }
+});
+
+// ../plugin-core/dist/config.js
+function toChain(network) {
+  if (network === "testnet")
+    return "test";
+  return "main";
+}
+var DEFAULT_TAAL_API_KEYS, DEFAULT_DB_NAME;
+var init_config2 = __esm({
+  "../plugin-core/dist/config.js"() {
+    "use strict";
+    DEFAULT_TAAL_API_KEYS = {
+      main: "mainnet_9596de07e92300c6287e4393594ae39c",
+      test: "testnet_0e6cf72133b43ea2d7861da2a38684e3"
+    };
+    DEFAULT_DB_NAME = "a2a_agent_wallet";
+  }
+});
+
+// ../plugin-core/dist/payment.js
+import { Beef, Utils as Utils2 } from "@bsv/sdk";
+import { randomBytesBase64, ScriptTemplateBRC29 } from "@bsv/wallet-toolbox";
+async function buildPayment(setup, params) {
+  const { to, satoshis, description } = params;
+  const desc = normalizeDescription(description ?? "agent payment");
+  const derivationPrefix = randomBytesBase64(8);
+  const derivationSuffix = randomBytesBase64(8);
+  const keyDeriver = setup.keyDeriver;
+  const t = new ScriptTemplateBRC29({
+    derivationPrefix,
+    derivationSuffix,
+    keyDeriver
+  });
+  let recipientPubKey;
+  if (/^0[23][0-9a-fA-F]{64}$/.test(to)) {
+    recipientPubKey = to;
+  } else {
+    throw new Error("PaymentParams.to must be a compressed public key (hex) for BRC-29 payments. Raw BSV addresses are not supported \u2014 the recipient must share their identity key.");
+  }
+  const lockingScript = t.lock(setup.rootKey.toString(), recipientPubKey);
+  const label = "a2a-payment";
+  const car = await setup.wallet.createAction({
+    outputs: [
+      {
+        lockingScript: lockingScript.toHex(),
+        satoshis,
+        outputDescription: desc,
+        tags: ["relinquish"],
+        customInstructions: JSON.stringify({
+          derivationPrefix,
+          derivationSuffix,
+          type: "BRC29"
+        })
+      }
+    ],
+    options: {
+      randomizeOutputs: false,
+      acceptDelayedBroadcast: false
+    },
+    labels: [label],
+    description: desc
+  });
+  if (!car.tx) {
+    throw new Error("createAction did not return a transaction. Check wallet funding.");
+  }
+  const beef = Beef.fromBinary(car.tx);
+  const lastTx = beef.txs[beef.txs.length - 1];
+  const txid = lastTx.txid;
+  const atomicBinary = beef.toBinaryAtomic(txid);
+  const beefBase64 = Utils2.toBase64(atomicBinary);
+  return {
+    beef: beefBase64,
+    txid,
+    satoshis,
+    derivationPrefix,
+    derivationSuffix,
+    senderIdentityKey: setup.identityKey
+  };
+}
+function normalizeDescription(desc) {
+  if (desc.length < 5)
+    return desc.padEnd(5, " ");
+  if (desc.length > 50)
+    return desc.slice(0, 50);
+  return desc;
+}
+var init_payment = __esm({
+  "../plugin-core/dist/payment.js"() {
+    "use strict";
+  }
+});
+
+// ../plugin-core/dist/verify.js
+import { Beef as Beef2, Utils as Utils3 } from "@bsv/sdk";
+async function verifyPayment(params) {
+  const errors = [];
+  let txid = "";
+  let outputCount = 0;
+  try {
+    const binary = Utils3.toArray(params.beef, "base64");
+    const beef = Beef2.fromBinary(binary);
+    if (beef.txs.length === 0) {
+      errors.push("BEEF contains no transactions");
+    } else {
+      const lastTx = beef.txs[beef.txs.length - 1];
+      txid = lastTx.txid;
+      const tx = beef.findAtomicTransaction(txid);
+      if (tx) {
+        outputCount = tx.outputs.length;
+        try {
+          await tx.verify();
+        } catch (err) {
+          const message = err instanceof Error ? err.message : String(err);
+          errors.push(`SPV verification failed: ${message}`);
+        }
+      } else {
+        errors.push("Could not find atomic transaction in BEEF");
+      }
+    }
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    errors.push(`BEEF parse error: ${message}`);
+  }
+  if (params.expectedSender) {
+    if (!/^0[23][0-9a-fA-F]{64}$/.test(params.expectedSender)) {
+      errors.push("expectedSender is not a valid compressed public key");
+    }
+  }
+  return {
+    valid: errors.length === 0,
+    txid,
+    outputCount,
+    errors
+  };
+}
+async function acceptPayment(setup, params) {
+  const desc = normalizeDescription2(params.description ?? "received payment");
+  const vout = params.vout ?? 0;
+  const binary = Utils3.toArray(params.beef, "base64");
+  const args = {
+    tx: binary,
+    outputs: [
+      {
+        outputIndex: vout,
+        protocol: "wallet payment",
+        paymentRemittance: {
+          derivationPrefix: params.derivationPrefix,
+          derivationSuffix: params.derivationSuffix,
+          senderIdentityKey: params.senderIdentityKey
+        }
+      }
+    ],
+    description: desc
+  };
+  const result = await setup.wallet.internalizeAction(args);
+  return {
+    accepted: result.accepted
+  };
+}
+function normalizeDescription2(desc) {
+  if (desc.length < 5)
+    return desc.padEnd(5, " ");
+  if (desc.length > 50)
+    return desc.slice(0, 50);
+  return desc;
+}
+var init_verify = __esm({
+  "../plugin-core/dist/verify.js"() {
+    "use strict";
+  }
+});
+
+// ../plugin-core/dist/wallet.js
+import { PrivateKey, CachedKeyDeriver as CachedKeyDeriver2 } from "@bsv/sdk";
+import { Wallet, WalletStorageManager, Services, Monitor, StorageKnex, randomBytesHex, ChaintracksServiceClient } from "@bsv/wallet-toolbox";
+import knexLib from "knex";
+import * as path3 from "node:path";
+import * as fs4 from "node:fs";
+import debug from "debug";
+var log, IDENTITY_FILE, BSVAgentWallet;
+var init_wallet = __esm({
+  "../plugin-core/dist/wallet.js"() {
+    "use strict";
+    init_config2();
+    init_payment();
+    init_verify();
+    log = debug("openclaw:plugin:overlay:wallet");
+    IDENTITY_FILE = "wallet-identity.json";
+    BSVAgentWallet = class _BSVAgentWallet {
+      /** @internal — exposed for advanced operations (e.g. direct internalizeAction) */
+      _setup;
+      constructor(setup) {
+        this._setup = setup;
+      }
+      // ---------------------------------------------------------------------------
+      // Factory methods
+      // ---------------------------------------------------------------------------
+      /**
+       * Create a new agent wallet. Generates a fresh root key and persists it.
+       * The SQLite database and identity file are written to `config.storageDir`.
+       */
+      static async create(config) {
+        log("Creating new wallet in: %s", config.storageDir);
+        const rootKeyHex = config.rootKeyHex ?? PrivateKey.fromRandom().toHex();
+        const rootKey = PrivateKey.fromHex(rootKeyHex);
+        const identityKey = rootKey.toPublicKey().toString();
+        fs4.mkdirSync(config.storageDir, { recursive: true });
+        const identity = {
+          rootKeyHex,
+          identityKey,
+          network: config.network
+        };
+        const identityPath = path3.join(config.storageDir, IDENTITY_FILE);
+        fs4.writeFileSync(identityPath, JSON.stringify(identity, null, 2), "utf-8");
+        const setup = await _BSVAgentWallet.buildSetup(config, rootKeyHex);
+        return new _BSVAgentWallet(setup);
+      }
+      /**
+       * Load an existing agent wallet from its storage directory.
+       * Reads the persisted identity file and re-initializes the wallet.
+       */
+      static async load(config) {
+        log("Loading wallet from: %s", config.storageDir);
+        const identityPath = path3.join(config.storageDir, IDENTITY_FILE);
+        if (!fs4.existsSync(identityPath)) {
+          if (config.createIfMissing === false) {
+            log("Wallet not found and createIfMissing is false");
+            throw new Error(`No wallet found in ${config.storageDir}`);
+          }
+          return this.create(config);
+        }
+        const identity = JSON.parse(fs4.readFileSync(identityPath, "utf-8"));
+        const rootKeyHex = config.rootKeyHex ?? identity.rootKeyHex;
+        const setup = await _BSVAgentWallet.buildSetup(config, rootKeyHex);
+        return new _BSVAgentWallet(setup);
+      }
+      // ---------------------------------------------------------------------------
+      // Wallet lifecycle
+      // ---------------------------------------------------------------------------
+      /**
+       * Get this wallet's public identity key (compressed hex, 33 bytes).
+       * This is the key other agents use to send payments to you.
+       */
+      async getIdentityKey() {
+        return this._setup.identityKey;
+      }
+      /**
+       * Get the wallet's current receive address for the active network.
+       */
+      async getAddress() {
+        const network = this._setup.network || "mainnet";
+        return this._setup.rootKey.toPublicKey().toAddress(network);
+      }
+      /**
+       * Get the wallet's current balance in satoshis.
+       *
+       * Uses the BRC-100 wallet's balance method which sums spendable outputs
+       * in the default basket.
+       */
+      async getBalance() {
+        return await this._setup.wallet.balance();
+      }
+      /**
+       * Cleanly shut down the wallet, releasing database connections and
+       * stopping the background monitor.
+       */
+      async destroy() {
+        if (this._setup.monitor) {
+          await this._setup.monitor.destroy();
+        }
+        if (this._setup.wallet) {
+          await this._setup.wallet.destroy();
+        }
+        await this._setup.storage.destroy();
+      }
+      // ---------------------------------------------------------------------------
+      // Payment creation (sender/payer side)
+      // ---------------------------------------------------------------------------
+      /**
+       * Build a BRC-29 payment to another agent.
+       *
+       * The transaction is created with `noSend: true` — the sender does NOT
+       * broadcast it. Instead, the Atomic BEEF and derivation metadata are
+       * returned so they can be transmitted to the recipient, who will
+       * verify and internalize (broadcast) the payment.
+       *
+       * @param params.to — Recipient's compressed public key (hex).
+       * @param params.satoshis — Amount in satoshis.
+       * @param params.description — Optional human-readable note.
+       */
+      async createPayment(params) {
+        return buildPayment(this._setup, params);
+      }
+      // ---------------------------------------------------------------------------
+      // Payment verification & acceptance (receiver/merchant side)
+      // ---------------------------------------------------------------------------
+      /**
+       * Verify an incoming Atomic BEEF payment.
+       *
+       * This performs structural validation and SPV verification via tx.verify().
+       */
+      async verifyPayment(params) {
+        return await verifyPayment(params);
+      }
+      /**
+       * Accept (internalize) a verified payment into this wallet.
+       *
+       * Uses the BRC-29 wallet payment protocol to derive the correct key
+       * and claim the output. This triggers SPV verification and, if the
+       * transaction hasn't been broadcast yet, broadcasts it.
+       */
+      async acceptPayment(params) {
+        return acceptPayment(this._setup, params);
+      }
+      // ---------------------------------------------------------------------------
+      // Access to underlying toolbox objects (for advanced use)
+      // ---------------------------------------------------------------------------
+      /** Get the underlying wallet-toolbox SetupWallet for advanced operations. */
+      getSetup() {
+        return this._setup;
+      }
+      // ---------------------------------------------------------------------------
+      // Private helpers
+      // ---------------------------------------------------------------------------
+      /**
+       * Internal: manually construct a BRC-100 wallet backed by SQLite.
+       *
+       * We build this by hand instead of using Setup.createWalletSQLite because
+       * the toolbox has a bug where its internal randomBytesHex is a stub.
+       * We use the same components but wire them up correctly.
+       */
+      static async buildSetup(config, rootKeyHex) {
+        const chain = toChain(config.network);
+        log("Building setup for chain: %s (network: %s)", chain, config.network);
+        const taalApiKey = config.taalApiKey ?? DEFAULT_TAAL_API_KEYS[chain];
+        const rootKey = PrivateKey.fromHex(rootKeyHex);
+        const identityKey = rootKey.toPublicKey().toString();
+        const keyDeriver = new CachedKeyDeriver2(rootKey);
+        const storage = new WalletStorageManager(identityKey);
+        const serviceOptions = Services.createDefaultOptions(chain);
+        const chaintracksUrl = process["env"].BSV_CHAINTRACKS_URL || "https://chaintracks-us-1.bsvb.tech";
+        const arcUrl = process["env"].BSV_ARC_URL;
+        const isTestMode = config.enableMonitor === false;
+        if (!isTestMode) {
+          serviceOptions.chaintracks = new ChaintracksServiceClient(chain, chaintracksUrl);
+          if (arcUrl) {
+            serviceOptions.arcUrl = arcUrl;
+          }
+        }
+        serviceOptions.taalApiKey = taalApiKey;
+        const services = new Services(serviceOptions);
+        const monopts = Monitor.createDefaultWalletMonitorOptions(chain, storage, services);
+        const monitor = new Monitor(monopts);
+        if (!isTestMode) {
+          monitor.addDefaultTasks();
+        } else {
+          monitor.tasks = [];
+        }
+        const wallet = isTestMode ? void 0 : new Wallet({ chain, keyDeriver, storage, services, monitor });
+        const filePath = path3.join(config.storageDir, `${DEFAULT_DB_NAME}.sqlite`);
+        const knex = knexLib({
+          client: "sqlite3",
+          connection: { filename: filePath },
+          useNullAsDefault: true
+        });
+        const feeModelValue = config.feeModel ?? (process["env"].BSV_FEE_MODEL ? parseInt(process["env"].BSV_FEE_MODEL, 10) : 100);
+        const activeStorage = new StorageKnex({
+          chain,
+          knex,
+          commissionSatoshis: 0,
+          commissionPubKeyHex: void 0,
+          feeModel: { model: "sat/kb", value: feeModelValue }
+        });
+        await activeStorage.migrate(DEFAULT_DB_NAME, randomBytesHex(33));
+        await activeStorage.makeAvailable();
+        await storage.addWalletStorageProvider(activeStorage);
+        await activeStorage.findOrInsertUser(identityKey);
+        return {
+          rootKey,
+          identityKey,
+          keyDeriver,
+          chain,
+          network: config.network,
+          storage,
+          services: isTestMode ? void 0 : services,
+          monitor: isTestMode ? void 0 : monitor,
+          wallet
+        };
+      }
+    };
+  }
+});
+
+// ../plugin-core/dist/index.js
+var init_dist = __esm({
+  "../plugin-core/dist/index.js"() {
+    "use strict";
+    init_wallet();
+    init_config2();
+    init_payment();
+    init_verify();
+  }
+});
+
+// src/scripts/utils/storage.ts
+import fs7 from "node:fs";
+function ensureStateDir() {
+  fs7.mkdirSync(OVERLAY_STATE_DIR, { recursive: true });
+}
+function loadRegistration() {
+  try {
+    if (fs7.existsSync(PATHS.registration)) {
+      return JSON.parse(fs7.readFileSync(PATHS.registration, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveRegistration(data) {
+  ensureStateDir();
+  fs7.writeFileSync(PATHS.registration, JSON.stringify(data, null, 2), "utf-8");
+}
+function deleteRegistration() {
+  try {
+    fs7.unlinkSync(PATHS.registration);
+  } catch {
+  }
+}
+function loadServices() {
+  try {
+    if (fs7.existsSync(PATHS.services)) {
+      return JSON.parse(fs7.readFileSync(PATHS.services, "utf-8"));
+    }
+  } catch {
+  }
+  return [];
+}
+function saveServices(services) {
+  ensureStateDir();
+  fs7.writeFileSync(PATHS.services, JSON.stringify(services, null, 2), "utf-8");
+}
+function appendToJsonl(filePath, entry) {
+  ensureStateDir();
+  fs7.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+}
+function readJsonl(filePath) {
+  if (!fs7.existsSync(filePath)) return [];
+  const lines = fs7.readFileSync(filePath, "utf-8").trim().split("\n").filter(Boolean);
+  return lines.map((line) => {
     try {
-        const data = JSON.parse(fs.readFileSync(budgetPath, 'utf-8'));
-        if (data.date === today)
-            return data;
+      return JSON.parse(line);
+    } catch {
+      return null;
     }
-    catch {
-        // Ignore parse errors
+  }).filter(Boolean);
+}
+function updateServiceQueueStatus(requestId, newStatus, additionalFields = {}) {
+  if (!fs7.existsSync(PATHS.serviceQueue)) return false;
+  const lines = fs7.readFileSync(PATHS.serviceQueue, "utf-8").trim().split("\n").filter(Boolean);
+  let updated = false;
+  const updatedLines = lines.map((line) => {
+    try {
+      const entry = JSON.parse(line);
+      if (entry.requestId === requestId) {
+        updated = true;
+        return JSON.stringify({
+          ...entry,
+          status: newStatus,
+          ...additionalFields,
+          updatedAt: Date.now()
+        });
+      }
+      return line;
+    } catch {
+      return line;
     }
-    return { date: today, totalSats: 0, transactions: [] };
+  });
+  if (updated) {
+    fs7.writeFileSync(PATHS.serviceQueue, updatedLines.join("\n") + "\n");
+  }
+  return updated;
 }
-function recordSpend(walletDir, sats, service, provider) {
-    const spending = loadDailySpending(walletDir);
-    spending.totalSats += sats;
-    spending.transactions.push({ ts: Date.now(), sats, service, provider });
-    fs.writeFileSync(getBudgetPath(walletDir), JSON.stringify(spending, null, 2));
+var init_storage = __esm({
+  "src/scripts/utils/storage.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/scripts/overlay/transaction.ts
+import { Utils as Utils4, PushDrop, Transaction } from "@bsv/sdk";
+async function buildPushDropScript(wallet, payload) {
+  const jsonBytes = Utils4.toArray(JSON.stringify(payload), "utf8");
+  const fields = [jsonBytes];
+  const token = new PushDrop(wallet._setup.wallet);
+  const script = await token.lock(fields, [0, PROTOCOL_ID], "1", "self", true, true);
+  return script.toHex();
 }
-function checkBudget(walletDir, requestedSats, dailyLimit) {
-    const spending = loadDailySpending(walletDir);
-    const remaining = dailyLimit - spending.totalSats;
+async function buildRealOverlayTransaction(payload, topic) {
+  const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const lockingScript = await buildPushDropScript(wallet, payload);
+  const response = await wallet._setup.wallet.createAction({
+    description: "topic manager submission",
+    outputs: [
+      {
+        lockingScript,
+        satoshis: 1,
+        outputDescription: "overlay",
+        basket: topic
+        // basket is the topic manager
+      }
+    ],
+    options: {
+      acceptDelayedBroadcast: false
+    }
+  });
+  const submitResp = await fetch(`${OVERLAY_URL}/submit`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/octet-stream",
+      "X-Topics": JSON.stringify([topic])
+    },
+    body: new Uint8Array(response.tx)
+  });
+  if (!submitResp.ok) {
+    const errText = await submitResp.text();
+    throw new Error(`Overlay submission failed: ${submitResp.status} \u2014 ${errText}`);
+  }
+  const wocNet = NETWORK === "mainnet" ? "" : "test.";
+  return {
+    txid: response.txid,
+    funded: "stored-beef",
+    explorer: `https://${wocNet}whatsonchain.com/tx/${response.txid}`
+  };
+}
+async function lookupOverlay(service, query) {
+  const resp = await fetch(`${OVERLAY_URL}/lookup`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ service, query })
+  });
+  if (!resp.ok) {
+    const errText = await resp.text();
+    throw new Error(`Lookup failed: ${resp.status} \u2014 ${errText}`);
+  }
+  return resp.json();
+}
+async function parseOverlayOutput(beefData, outputIndex) {
+  try {
+    const tx = Transaction.fromBEEF(beefData);
+    const txid = tx.id("hex");
+    const output = tx.outputs[outputIndex];
+    if (!output) return { data: null, txid: null };
+    const { fields } = PushDrop.decode(output.lockingScript);
+    return { data: JSON.parse(Utils4.toUTF8(fields[0])), txid };
+  } catch {
+    return { data: null, txid: null };
+  }
+}
+var init_transaction = __esm({
+  "src/scripts/overlay/transaction.ts"() {
+    "use strict";
+    init_config();
+    init_dist();
+  }
+});
+
+// src/scripts/overlay/services.ts
+var services_exports = {};
+__export(services_exports, {
+  cmdAdvertise: () => cmdAdvertise,
+  cmdReadvertise: () => cmdReadvertise,
+  cmdRemove: () => cmdRemove,
+  cmdServices: () => cmdServices
+});
+async function getBSVAgentWallet6() {
+  return BSVAgentWallet;
+}
+async function cmdServices() {
+  const services = loadServices();
+  return ok({ services, count: services.length });
+}
+async function cmdAdvertise(serviceId, name, priceSatsStr, description) {
+  if (!serviceId || !name || !priceSatsStr) {
+    return fail("Usage: advertise <serviceId> <name> <priceSats> [description]");
+  }
+  const priceSats = parseInt(priceSatsStr, 10);
+  if (isNaN(priceSats) || priceSats < 0) {
+    return fail("priceSats must be a non-negative integer");
+  }
+  const BSVAgentWallet2 = await getBSVAgentWallet6();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const identityKey = await wallet.getIdentityKey();
+  await wallet.destroy();
+  const services = loadServices();
+  const existing = services.find((s) => s.serviceId === serviceId);
+  if (existing) {
+    return fail(`Service '${serviceId}' already exists. Use 'readvertise' to update.`);
+  }
+  const newService = {
+    serviceId,
+    name,
+    description: description || `${name} service`,
+    priceSats,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const servicePayload = {
+    protocol: PROTOCOL_ID,
+    type: "service",
+    identityKey,
+    serviceId,
+    name,
+    description: newService.description,
+    pricing: {
+      model: "per-task",
+      amountSats: priceSats
+    },
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  try {
+    const result = await buildRealOverlayTransaction(servicePayload, TOPICS.SERVICES);
+    newService.txid = result.txid;
+    services.push(newService);
+    saveServices(services);
+    return ok({
+      advertised: true,
+      service: newService,
+      txid: result.txid,
+      funded: result.funded
+    });
+  } catch (err) {
+    return fail(`Failed to advertise service: ${err.message}`);
+  }
+}
+async function cmdRemove(serviceId) {
+  if (!serviceId) {
+    return fail("Usage: remove <serviceId>");
+  }
+  const services = loadServices();
+  const idx = services.findIndex((s) => s.serviceId === serviceId);
+  if (idx === -1) {
+    return fail(`Service '${serviceId}' not found`);
+  }
+  const removed = services.splice(idx, 1)[0];
+  saveServices(services);
+  return ok({
+    removed: true,
+    service: removed,
+    note: "Removed from local registry. On-chain record remains (blockchain is immutable)."
+  });
+}
+async function cmdReadvertise(serviceId, name, priceSatsStr, description) {
+  if (!serviceId) {
+    return fail("Usage: readvertise <serviceId> [name] [priceSats] [description]");
+  }
+  const services = loadServices();
+  const existing = services.find((s) => s.serviceId === serviceId);
+  if (!existing) {
+    return fail(`Service '${serviceId}' not found. Use 'advertise' to create.`);
+  }
+  const BSVAgentWallet2 = await getBSVAgentWallet6();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const identityKey = await wallet.getIdentityKey();
+  await wallet.destroy();
+  if (name) existing.name = name;
+  if (priceSatsStr) {
+    const priceSats = parseInt(priceSatsStr, 10);
+    if (isNaN(priceSats) || priceSats < 0) {
+      return fail("priceSats must be a non-negative integer");
+    }
+    existing.priceSats = priceSats;
+  }
+  if (description) existing.description = description;
+  existing.registeredAt = (/* @__PURE__ */ new Date()).toISOString();
+  const servicePayload = {
+    protocol: PROTOCOL_ID,
+    type: "service",
+    identityKey,
+    serviceId,
+    name: existing.name,
+    description: existing.description,
+    pricing: {
+      model: "per-task",
+      amountSats: existing.priceSats
+    },
+    timestamp: existing.registeredAt
+  };
+  try {
+    const result = await buildRealOverlayTransaction(servicePayload, TOPICS.SERVICES);
+    existing.txid = result.txid;
+    saveServices(services);
+    return ok({
+      readvertised: true,
+      service: existing,
+      txid: result.txid,
+      funded: result.funded
+    });
+  } catch (err) {
+    return fail(`Failed to readvertise service: ${err.message}`);
+  }
+}
+var init_services = __esm({
+  "src/scripts/overlay/services.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_storage();
+    init_transaction();
+    init_dist();
+  }
+});
+
+// index.ts
+import path4 from "node:path";
+import os2 from "node:os";
+import fs13 from "node:fs";
+
+// src/services/types.ts
+var ServiceCategory = /* @__PURE__ */ ((ServiceCategory2) => {
+  ServiceCategory2["UTILITY"] = "utility";
+  ServiceCategory2["AI"] = "ai";
+  ServiceCategory2["BLOCKCHAIN"] = "blockchain";
+  ServiceCategory2["COMMUNICATION"] = "communication";
+  ServiceCategory2["DEVELOPMENT"] = "development";
+  ServiceCategory2["RESEARCH"] = "research";
+  ServiceCategory2["ENTERTAINMENT"] = "entertainment";
+  ServiceCategory2["CUSTOM"] = "custom";
+  return ServiceCategory2;
+})(ServiceCategory || {});
+
+// src/services/registry.ts
+var DefaultServiceRegistry = class {
+  services = /* @__PURE__ */ new Map();
+  /**
+   * Register a new service definition.
+   */
+  register(service) {
+    this.validateServiceDefinition(service);
+    if (this.services.has(service.id)) {
+      throw new Error(`Service '${service.id}' is already registered`);
+    }
+    this.services.set(service.id, { ...service });
+  }
+  /**
+   * Get a service definition by ID.
+   */
+  get(serviceId) {
+    return this.services.get(serviceId);
+  }
+  /**
+   * List all registered services.
+   */
+  list() {
+    return Array.from(this.services.values());
+  }
+  /**
+   * List services by category.
+   */
+  listByCategory(category) {
+    return this.list().filter((service) => service.category === category);
+  }
+  /**
+   * Check if a service is registered.
+   */
+  has(serviceId) {
+    return this.services.has(serviceId);
+  }
+  /**
+   * Unregister a service.
+   */
+  unregister(serviceId) {
+    this.services.delete(serviceId);
+  }
+  /**
+   * Clear all services (useful for testing).
+   */
+  clear() {
+    this.services.clear();
+  }
+  /**
+   * Get service count.
+   */
+  count() {
+    return this.services.size;
+  }
+  /**
+   * Get services by price range.
+   */
+  getByPriceRange(minPrice, maxPrice) {
+    return this.list().filter(
+      (service) => service.defaultPrice >= minPrice && service.defaultPrice <= maxPrice
+    );
+  }
+  /**
+   * Search services by name or description.
+   */
+  search(query) {
+    const lowerQuery = query.toLowerCase();
+    return this.list().filter(
+      (service) => service.name.toLowerCase().includes(lowerQuery) || service.description.toLowerCase().includes(lowerQuery) || service.id.toLowerCase().includes(lowerQuery)
+    );
+  }
+  /**
+   * Validate a service definition.
+   */
+  validateServiceDefinition(service) {
+    if (!service.id) {
+      throw new Error("Service ID is required");
+    }
+    if (typeof service.id !== "string" || service.id.trim().length === 0) {
+      throw new Error("Service ID must be a non-empty string");
+    }
+    if (!/^[a-z0-9]+(-[a-z0-9]+)*$/.test(service.id)) {
+      throw new Error("Service ID must be in kebab-case format (lowercase, hyphens only)");
+    }
+    if (!service.name || typeof service.name !== "string" || service.name.trim().length === 0) {
+      throw new Error("Service name is required and must be a non-empty string");
+    }
+    if (!service.description || typeof service.description !== "string" || service.description.trim().length === 0) {
+      throw new Error("Service description is required and must be a non-empty string");
+    }
+    if (typeof service.defaultPrice !== "number" || service.defaultPrice < 0 || !Number.isInteger(service.defaultPrice)) {
+      throw new Error("Service defaultPrice must be a non-negative integer");
+    }
+    if (service.category && !Object.values(ServiceCategory).includes(service.category)) {
+      throw new Error(`Invalid service category: ${service.category}`);
+    }
+    if (service.inputSchema && typeof service.inputSchema !== "object") {
+      throw new Error("Service inputSchema must be an object");
+    }
+    if (service.handler) {
+      if (typeof service.handler.validate !== "function") {
+        throw new Error("Service handler must have a validate function");
+      }
+      if (typeof service.handler.process !== "function") {
+        throw new Error("Service handler must have a process function");
+      }
+    }
+  }
+};
+var serviceRegistry = new DefaultServiceRegistry();
+
+// src/services/loader.ts
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename = fileURLToPath(import.meta.url);
+var __dirname = path.dirname(__filename);
+var DefaultServiceLoader = class {
+  builtInDir;
+  customDir;
+  constructor() {
+    this.builtInDir = path.resolve(__dirname, "built-in");
+    const homeDir = process["env"].HOME || process["env"].USERPROFILE || "";
+    this.customDir = path.join(homeDir, ".openclaw", "services");
+  }
+  /**
+   * Load services from a directory.
+   */
+  async loadFromDirectory(directory) {
+    if (!fs.existsSync(directory)) {
+      return [];
+    }
+    const services = [];
+    const entries = fs.readdirSync(directory, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) {
+        continue;
+      }
+      try {
+        const serviceDefinition = await this.loadServiceFromDirectory(
+          path.join(directory, entry.name)
+        );
+        if (serviceDefinition) {
+          services.push(serviceDefinition);
+        }
+      } catch (error) {
+        console.warn(`Failed to load service from ${entry.name}:`, error);
+      }
+    }
+    return services;
+  }
+  /**
+   * Load all built-in services.
+   */
+  async loadBuiltInServices() {
+    return this.loadFromDirectory(this.builtInDir);
+  }
+  /**
+   * Load custom user services.
+   */
+  async loadCustomServices() {
+    return this.loadFromDirectory(this.customDir);
+  }
+  /**
+   * Load all services (built-in + custom).
+   */
+  async loadAllServices() {
+    const [builtIn, custom] = await Promise.all([
+      this.loadBuiltInServices(),
+      this.loadCustomServices()
+    ]);
+    return [...builtIn, ...custom];
+  }
+  /**
+   * Load a service definition from a directory.
+   */
+  async loadServiceFromDirectory(serviceDir) {
+    const indexPath = path.join(serviceDir, "index.ts");
+    const jsIndexPath = path.join(serviceDir, "index.js");
+    const promptPath = path.join(serviceDir, "prompt.md");
+    let modulePath;
+    if (fs.existsSync(indexPath)) {
+      modulePath = indexPath;
+    } else if (fs.existsSync(jsIndexPath)) {
+      modulePath = jsIndexPath;
+    } else {
+      throw new Error(`No index.ts or index.js found in ${serviceDir}`);
+    }
+    try {
+      const serviceModule = await import(modulePath);
+      const serviceDefinition = serviceModule.default || serviceModule;
+      if (!serviceDefinition || typeof serviceDefinition !== "object") {
+        throw new Error("Service must export a default ServiceDefinition object");
+      }
+      if (!serviceDefinition.id) {
+        throw new Error("Service definition must have an id");
+      }
+      if (fs.existsSync(promptPath)) {
+        serviceDefinition.promptFile = promptPath;
+      }
+      return serviceDefinition;
+    } catch (error) {
+      throw new Error(`Failed to import service from ${modulePath}: ${error}`);
+    }
+  }
+  /**
+   * Create a new custom service directory.
+   */
+  createCustomServiceDirectory(serviceId) {
+    const serviceDir = path.join(this.customDir, serviceId);
+    fs.mkdirSync(this.customDir, { recursive: true });
+    if (fs.existsSync(serviceDir)) {
+      throw new Error(`Service directory ${serviceId} already exists`);
+    }
+    fs.mkdirSync(serviceDir);
+    return serviceDir;
+  }
+  /**
+   * Create a basic service template.
+   */
+  createServiceTemplate(serviceId, options) {
+    const serviceDir = this.createCustomServiceDirectory(serviceId);
+    const indexContent = this.generateServiceTemplate(serviceId, options);
+    fs.writeFileSync(path.join(serviceDir, "index.ts"), indexContent);
+    const promptContent = this.generatePromptTemplate(serviceId, options);
+    fs.writeFileSync(path.join(serviceDir, "prompt.md"), promptContent);
+    if (options.hasHandler) {
+      const handlerContent = this.generateHandlerTemplate(serviceId, options);
+      fs.writeFileSync(path.join(serviceDir, "handler.ts"), handlerContent);
+    }
+  }
+  /**
+   * Generate service definition template.
+   */
+  generateServiceTemplate(serviceId, options) {
+    return `/**
+ * ${options.name} service definition.
+ */
+
+import { ServiceDefinition${options.hasHandler ? ", ServiceHandler" : ""} } from '../../types.js';
+${options.hasHandler ? `import { ${serviceId.replace(/-/g, "")}Handler } from './handler.js';` : ""}
+
+const ${serviceId.replace(/-/g, "")}Service: ServiceDefinition = {
+  id: '${serviceId}',
+  name: '${options.name}',
+  description: '${options.description}',
+  defaultPrice: ${options.defaultPrice},${options.category ? `
+  category: '${options.category}',` : ""}
+  inputSchema: {
+    type: 'object',
+    properties: {
+      // Define your input schema here
+      query: {
+        type: 'string',
+        description: 'Query or input for the service'
+      }
+    },
+    required: ['query']
+  }${options.hasHandler ? `,
+  handler: ${serviceId.replace(/-/g, "")}Handler` : ""}
+};
+
+export default ${serviceId.replace(/-/g, "")}Service;
+`;
+  }
+  /**
+   * Generate prompt template.
+   */
+  generatePromptTemplate(serviceId, options) {
+    return `# ${options.name} Service
+
+You are processing a request for the "${serviceId}" service.
+
+## Service Description
+${options.description}
+
+## Input
+The user has provided the following input:
+\`\`\`json
+{{input}}
+\`\`\`
+
+## Instructions
+Process the user's request and provide a helpful response based on the service description.
+Format your response as a structured result that can be easily parsed and used.
+
+## Response Format
+Provide your response in this format:
+\`\`\`json
+{
+  "result": "your processed result here",
+  "metadata": {
+    "processingTime": "time taken",
+    "version": "1.0"
+  }
+}
+\`\`\`
+`;
+  }
+  /**
+   * Generate handler template.
+   */
+  generateHandlerTemplate(serviceId, options) {
+    return `/**
+ * ${options.name} service handler.
+ */
+
+import { ServiceHandler, ValidationResult, ServiceContext, ServiceResult } from '../../types.js';
+
+export const ${serviceId.replace(/-/g, "")}Handler: ServiceHandler = {
+  /**
+   * Validate service input.
+   */
+  validate(input: any): ValidationResult {
+    if (!input || typeof input !== 'object') {
+      return { valid: false, error: 'Input must be an object' };
+    }
+
+    if (!input.query || typeof input.query !== 'string') {
+      return { valid: false, error: 'Query must be a non-empty string' };
+    }
+
+    // Add more validation as needed
+    return { valid: true, sanitized: input };
+  },
+
+  /**
+   * Process the service request.
+   */
+  async process(input: any, context: ServiceContext): Promise<ServiceResult> {
+    try {
+      const startTime = Date.now();
+
+      // Your service logic here
+      const result = {
+        query: input.query,
+        response: 'This is a template response. Implement your logic here.',
+        timestamp: new Date().toISOString()
+      };
+
+      const processingTime = Date.now() - startTime;
+
+      return {
+        success: true,
+        data: result,
+        metadata: {
+          processingTime,
+          version: '1.0'
+        }
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+};
+`;
+  }
+  /**
+   * Get the built-in services directory.
+   */
+  getBuiltInDirectory() {
+    return this.builtInDir;
+  }
+  /**
+   * Get the custom services directory.
+   */
+  getCustomDirectory() {
+    return this.customDir;
+  }
+  /**
+   * Check if a service directory exists.
+   */
+  serviceExists(serviceId, inCustom = false) {
+    const baseDir = inCustom ? this.customDir : this.builtInDir;
+    return fs.existsSync(path.join(baseDir, serviceId));
+  }
+};
+var serviceLoader = new DefaultServiceLoader();
+
+// src/services/manager.ts
+var DefaultServiceManager = class {
+  registry;
+  loader;
+  initialized = false;
+  constructor() {
+    this.registry = serviceRegistry;
+    this.loader = serviceLoader;
+  }
+  /**
+   * Initialize the service system.
+   */
+  async initialize() {
+    if (this.initialized) {
+      return;
+    }
+    const services = await this.loader.loadAllServices();
+    for (const service of services) {
+      try {
+        this.registry.register(service);
+      } catch (error) {
+        console.warn(`Failed to register service '${service.id}':`, error);
+      }
+    }
+    this.initialized = true;
+    console.log(`Service manager initialized with ${this.registry.count()} services`);
+  }
+  /**
+   * Execute a service request.
+   */
+  async execute(serviceId, input, context) {
+    if (!this.initialized) {
+      throw new Error("Service manager not initialized");
+    }
+    const service = this.registry.get(serviceId);
+    if (!service) {
+      return {
+        success: false,
+        error: `Service '${serviceId}' not found`
+      };
+    }
+    if (service.handler) {
+      const validation = service.handler.validate(input);
+      if (!validation.valid) {
+        return {
+          success: false,
+          error: `Input validation failed: ${validation.error}`
+        };
+      }
+      input = validation.sanitized || input;
+    }
+    try {
+      if (service.handler) {
+        return await service.handler.process(input, context);
+      } else {
+        return {
+          success: true,
+          data: {
+            serviceId,
+            input,
+            mode: "agent",
+            promptFile: service.promptFile
+          },
+          metadata: {
+            version: "1.0",
+            executionMode: "agent"
+          }
+        };
+      }
+    } catch (error) {
+      return {
+        success: false,
+        error: error instanceof Error ? error.message : String(error),
+        metadata: {
+          serviceId,
+          errorType: "execution_error"
+        }
+      };
+    }
+  }
+  /**
+   * Validate service input.
+   */
+  validate(serviceId, input) {
+    const service = this.registry.get(serviceId);
+    if (!service) {
+      return {
+        valid: false,
+        error: `Service '${serviceId}' not found`
+      };
+    }
+    if (service.handler) {
+      return service.handler.validate(input);
+    }
+    if (service.inputSchema) {
+      return this.validateAgainstSchema(input, service.inputSchema);
+    }
+    return { valid: true };
+  }
+  /**
+   * Reload all services.
+   */
+  async reload() {
+    this.registry.clear();
+    this.initialized = false;
+    await this.initialize();
+  }
+  /**
+   * Get service for agent-mode processing.
+   */
+  getServiceForAgentMode(serviceId) {
+    const service = this.registry.get(serviceId);
+    if (!service) {
+      return null;
+    }
     return {
-        allowed: remaining >= requestedSats,
-        remaining,
-        spent: spending.totalSats
+      service,
+      promptFile: service.promptFile
     };
-}
-function applyConfigToEnv(config) {
-    process['env'].BSV_WALLET_DIR = config.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
-    process['env'].OVERLAY_URL = config.overlayUrl || 'https://clawoverlay.com';
-    process['env'].BSV_NETWORK = config.network || process['env'].BSV_NETWORK || 'mainnet';
-    process['env'].BSV_ARC_URL = config.arcUrl || (process['env'].BSV_NETWORK === 'testnet' ? 'https://testnet.arc.gorillapool.io' : 'https://arc.gorillapool.io');
-    process['env'].AGENT_NAME = config.agentName || 'openclaw-agent';
-    setNoExit(true);
-}
-async function startAutoImport(config, api) {
+  }
+  /**
+   * Check if service is available.
+   */
+  isServiceAvailable(serviceId) {
+    return this.registry.has(serviceId);
+  }
+  /**
+   * Get service execution mode.
+   */
+  getServiceMode(serviceId) {
+    const service = this.registry.get(serviceId);
+    if (!service) {
+      return null;
+    }
+    return service.handler ? "handler" : "agent";
+  }
+  /**
+   * Get all available services for discovery.
+   */
+  getAvailableServices() {
+    return this.registry.list().map((service) => ({
+      id: service.id,
+      name: service.name,
+      description: service.description,
+      defaultPrice: service.defaultPrice,
+      category: service.category,
+      mode: service.handler ? "handler" : "agent"
+    }));
+  }
+  /**
+   * Validate input against JSON schema.
+   */
+  validateAgainstSchema(input, schema) {
     try {
-        applyConfigToEnv(config);
-        const addrOutput = await cmdAddress();
-        if (!addrOutput.success)
-            return;
-        const address = addrOutput.data?.address;
-        if (!address)
-            return;
-        autoImportInterval = setInterval(async () => {
-            try {
-                const network = process['env'].BSV_NETWORK === 'testnet' ? 'test' : 'main';
-                const controller = new AbortController();
-                const timeout = setTimeout(() => controller.abort(), 15000);
-                const resp = await fetch(`https://api.whatsonchain.com/v1/bsv/${network}/address/${address}/unspent/all`, { signal: controller.signal });
-                clearTimeout(timeout);
-                if (!resp.ok)
-                    return;
-                const data = await resp.json();
-                const utxos = data.result || [];
-                for (const utxo of utxos) {
-                    const key = `${utxo.tx_hash}:${utxo.tx_pos}`;
-                    if (knownTxids.has(key))
-                        continue;
-                    if (utxo.value < 200)
-                        continue;
-                    api.logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
-                    try {
-                        applyConfigToEnv(config);
-                        const importOutput = await cmdImport(utxo.tx_hash, String(utxo.tx_pos));
-                        if (importOutput.success) {
-                            knownTxids.add(key);
-                            api.logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
-                            // Notify agent of successful import
-                            wakeAgent(`💰 **Wallet Funded!**\n\nAuto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...\n\nNotify the user their wallet has been funded.`, api.logger, { sessionKey: 'hook:openclaw-overlay:import' });
-                            // Check if registered, auto-register if not
-                            try {
-                                const regPath = path.join(os.homedir(), '.openclaw', 'openclaw-overlay', 'registration.json');
-                                if (!fs.existsSync(regPath)) {
-                                    api.logger?.info?.('[openclaw-overlay] Not yet registered — auto-registering...');
-                                    applyConfigToEnv(config);
-                                    const regOutput = await cmdRegister();
-                                    if (regOutput.success) {
-                                        api.logger?.info?.('[openclaw-overlay] Auto-registered on overlay network!');
-                                        await autoAdvertiseServices(config, api.logger);
-                                    }
-                                }
-                            }
-                            catch (err) {
-                                api.logger?.warn?.('[openclaw-overlay] Auto-registration failed:', err.message);
-                            }
-                        }
-                    }
-                    catch (err) {
-                        knownTxids.add(key);
-                    }
-                }
+      const schemaObj = schema;
+      if (schemaObj.type === "object") {
+        if (!input || typeof input !== "object") {
+          return { valid: false, error: "Input must be an object" };
+        }
+        if (schemaObj.required && Array.isArray(schemaObj.required)) {
+          for (const requiredProp of schemaObj.required) {
+            if (!(requiredProp in input)) {
+              return { valid: false, error: `Missing required property: ${requiredProp}` };
             }
-            catch (err) {
-                // WoC API error
+          }
+        }
+        if (schemaObj.properties) {
+          for (const [propName, propSchema] of Object.entries(schemaObj.properties)) {
+            if (propName in input) {
+              const propType = propSchema.type;
+              const actualType = typeof input[propName];
+              if (propType && propType !== actualType) {
+                return { valid: false, error: `Property '${propName}' must be of type ${propType}` };
+              }
             }
-        }, 30000);
+          }
+        }
+      }
+      return { valid: true, sanitized: input };
+    } catch (error) {
+      return { valid: false, error: `Schema validation error: ${error}` };
     }
-    catch (err) {
-        api.logger?.warn?.('[openclaw-overlay] Auto-import setup failed:', err.message);
+  }
+  /**
+   * Get service statistics.
+   */
+  getStatistics() {
+    const services = this.registry.list();
+    const stats = {
+      totalServices: services.length,
+      handlerServices: 0,
+      agentServices: 0,
+      servicesByCategory: {}
+    };
+    for (const service of services) {
+      if (service.handler) {
+        stats.handlerServices++;
+      } else {
+        stats.agentServices++;
+      }
+      const category = service.category || "uncategorized";
+      stats.servicesByCategory[category] = (stats.servicesByCategory[category] || 0) + 1;
     }
+    return stats;
+  }
+};
+var serviceManager = new DefaultServiceManager();
+async function initializeServiceSystem() {
+  await serviceManager.initialize();
 }
-async function autoAdvertiseServices(config, logger) {
+
+// src/scripts/wallet/setup.ts
+init_config();
+init_output();
+import fs5 from "node:fs";
+
+// src/scripts/wallet/identity.ts
+init_config();
+import fs3 from "node:fs";
+import { CachedKeyDeriver, Utils } from "@bsv/sdk";
+import { brc29ProtocolID } from "@bsv/wallet-toolbox";
+var _sdk = null;
+async function getSdk() {
+  if (_sdk) return _sdk;
+  try {
+    _sdk = await import("@bsv/sdk");
+    return _sdk;
+  } catch {
+    const { fileURLToPath: fileURLToPath2 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname2, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname2, "..", "..", "..", "..", "..", "a2a-bsv", "packages", "core", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(os3.homedir(), "a2a-bsv", "packages", "core", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js")
+    ];
+    for (const p of candidates) {
+      try {
+        _sdk = await import(p);
+        return _sdk;
+      } catch {
+      }
+    }
+    throw new Error("Cannot find @bsv/sdk. Run setup.sh first.");
+  }
+}
+function loadWalletIdentity() {
+  if (!fs3.existsSync(PATHS.walletIdentity)) {
+    throw new Error("Wallet not initialized. Run: cli setup");
+  }
+  try {
+    const fileMode = fs3.statSync(PATHS.walletIdentity).mode & 511;
+    if (fileMode & 36) {
+      console.error(`[security] WARNING: ${PATHS.walletIdentity} has permissive mode 0${fileMode.toString(8)}. Run: chmod 600 ${PATHS.walletIdentity}`);
+    }
+  } catch {
+  }
+  return JSON.parse(fs3.readFileSync(PATHS.walletIdentity, "utf-8"));
+}
+async function loadIdentity() {
+  const identity = loadWalletIdentity();
+  const sdk = await getSdk();
+  const privKey = sdk.PrivateKey.fromHex(identity.rootKeyHex);
+  return { identityKey: identity.identityKey, privKey };
+}
+async function signRelayMessage(privKey, to, type, payload) {
+  const sdk = await getSdk();
+  const preimage = to + type + JSON.stringify(payload);
+  const msgHash = sdk.Hash.sha256(Array.from(new TextEncoder().encode(preimage)));
+  const sig = privKey.sign(msgHash);
+  return Array.from(sig.toDER()).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+async function verifyRelaySignature(fromKey, to, type, payload, signatureHex) {
+  if (!signatureHex) return { valid: false, reason: "no signature" };
+  try {
+    const sdk = await getSdk();
+    const preimage = to + type + JSON.stringify(payload);
+    const msgHash = sdk.Hash.sha256(Array.from(new TextEncoder().encode(preimage)));
+    const sigBytes = [];
+    for (let i = 0; i < signatureHex.length; i += 2) {
+      sigBytes.push(parseInt(signatureHex.substring(i, i + 2), 16));
+    }
+    const sig = sdk.Signature.fromDER(sigBytes);
+    const pubKey = sdk.PublicKey.fromString(fromKey);
+    return { valid: pubKey.verify(msgHash, sig) };
+  } catch (err) {
+    return { valid: false, reason: String(err) };
+  }
+}
+async function deriveWalletAddress(privKey, network = NETWORK) {
+  const keyDeriver = new CachedKeyDeriver(privKey);
+  const pubKey = keyDeriver.derivePublicKey(
+    brc29ProtocolID,
+    Utils.toBase64(Utils.toArray("import")) + " " + Utils.toBase64(Utils.toArray("now")),
+    "self",
+    true
+  );
+  const address = pubKey.toAddress(network);
+  const hash160 = Buffer.from(pubKey.toHash());
+  return { address, hash160, pubKey };
+}
+
+// src/scripts/wallet/setup.ts
+init_dist();
+async function getBSVAgentWallet() {
+  return BSVAgentWallet;
+}
+var _sdk2 = null;
+async function getSdk2() {
+  if (_sdk2) return _sdk2;
+  try {
+    _sdk2 = await import("@bsv/sdk");
+    return _sdk2;
+  } catch {
+    const { fileURLToPath: fileURLToPath2 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname2, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname2, "..", "..", "..", "..", "..", "a2a-bsv", "packages", "core", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(os3.homedir(), "a2a-bsv", "packages", "core", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js")
+    ];
+    for (const p of candidates) {
+      try {
+        _sdk2 = await import(p);
+        return _sdk2;
+      } catch {
+      }
+    }
+    throw new Error("Cannot find @bsv/sdk. Run setup.sh first.");
+  }
+}
+async function cmdSetup() {
+  const BSVAgentWallet2 = await getBSVAgentWallet();
+  if (fs5.existsSync(PATHS.walletIdentity)) {
+    const wallet2 = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const identityKey2 = await wallet2.getIdentityKey();
+    await wallet2.destroy();
+    return ok({
+      identityKey: identityKey2,
+      walletDir: WALLET_DIR,
+      network: NETWORK,
+      overlayUrl: OVERLAY_URL,
+      alreadyExisted: true
+    });
+  }
+  fs5.mkdirSync(WALLET_DIR, { recursive: true });
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const identityKey = await wallet.getIdentityKey();
+  await wallet.destroy();
+  if (fs5.existsSync(PATHS.walletIdentity)) {
+    fs5.chmodSync(PATHS.walletIdentity, 384);
+  }
+  return ok({
+    identityKey,
+    walletDir: WALLET_DIR,
+    network: NETWORK,
+    overlayUrl: OVERLAY_URL,
+    alreadyExisted: false
+  });
+}
+async function cmdIdentity() {
+  const BSVAgentWallet2 = await getBSVAgentWallet();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const identityKey = await wallet.getIdentityKey();
+  await wallet.destroy();
+  return ok({ identityKey });
+}
+async function cmdStatus() {
+  const BSVAgentWallet2 = await getBSVAgentWallet();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const identityKey = await wallet.getIdentityKey();
+  const total = await wallet.getBalance();
+  await wallet.destroy();
+  return ok({
+    identity: { identityKey, network: NETWORK },
+    balance: { walletBalance: total }
+  });
+}
+async function cmdAddress() {
+  if (!fs5.existsSync(PATHS.walletIdentity)) {
+    return fail("Wallet not initialized. Run: setup");
+  }
+  const sdk = await getSdk2();
+  const identity = loadWalletIdentity();
+  const privKey = sdk.PrivateKey.fromHex(identity.rootKeyHex);
+  const { address } = await deriveWalletAddress(privKey);
+  return ok({
+    address,
+    network: NETWORK,
+    identityKey: identity.identityKey,
+    note: NETWORK === "mainnet" ? `Fund this address at an exchange \u2014 Explorer: https://whatsonchain.com/address/${address}` : `Fund via faucet: https://witnessonchain.com/faucet/tbsv \u2014 Explorer: https://test.whatsonchain.com/address/${address}`
+  });
+}
+
+// src/scripts/wallet/balance.ts
+init_config();
+init_output();
+import fs6 from "node:fs";
+
+// src/scripts/utils/woc.ts
+init_config();
+async function wocFetch(urlPath, options = {}, maxRetries = 3, timeoutMs = 3e4) {
+  const wocNet = NETWORK === "mainnet" ? "main" : "test";
+  const base = `https://api.whatsonchain.com/v1/bsv/${wocNet}`;
+  const url = urlPath.startsWith("http") ? urlPath : `${base}${urlPath}`;
+  const headers = { ...options.headers || {} };
+  if (WOC_API_KEY) {
+    headers["Authorization"] = `Bearer ${WOC_API_KEY}`;
+  }
+  let lastError;
+  for (let attempt = 0; attempt <= maxRetries; attempt++) {
+    try {
+      const controller = new AbortController();
+      const timeout = setTimeout(() => controller.abort(), timeoutMs);
+      const resp = await fetch(url, { ...options, headers, signal: controller.signal });
+      clearTimeout(timeout);
+      if ((resp.status === 429 || resp.status >= 500) && attempt < maxRetries) {
+        const delayMs = Math.min(1e3 * Math.pow(2, attempt), 8e3);
+        await new Promise((r) => setTimeout(r, delayMs));
+        continue;
+      }
+      return resp;
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxRetries) {
+        const delayMs = Math.min(1e3 * Math.pow(2, attempt), 8e3);
+        await new Promise((r) => setTimeout(r, delayMs));
+        continue;
+      }
+    }
+  }
+  throw lastError || new Error("WoC fetch failed after retries");
+}
+async function fetchWithTimeout(url, options = {}, timeoutMs = 15e3) {
+  const controller = new AbortController();
+  const timeout = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    const resp = await fetch(url, { ...options, signal: controller.signal });
+    return resp;
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+async function fetchBeefFromWoC(txid) {
+  try {
+    const resp = await wocFetch(`/tx/${txid}/beef`);
+    if (!resp.ok) return null;
+    const hexStr = (await resp.text()).trim();
+    if (!hexStr || hexStr.length < 8) return null;
+    const bytes = hexStr.match(/.{2}/g).map((h) => parseInt(h, 16));
+    return new Uint8Array(bytes);
+  } catch {
+    return null;
+  }
+}
+function getExplorerBaseUrl() {
+  return NETWORK === "mainnet" ? "https://whatsonchain.com" : "https://test.whatsonchain.com";
+}
+
+// src/scripts/utils/merkle.ts
+var _MerklePath = null;
+async function getMerklePath() {
+  if (_MerklePath) return _MerklePath;
+  const sdk = await import("@bsv/sdk");
+  _MerklePath = sdk.MerklePath;
+  return _MerklePath;
+}
+async function buildMerklePathFromTSC(txid, txIndex, nodes, blockHeight) {
+  const MerklePath = await getMerklePath();
+  const treeHeight = nodes.length;
+  const mpPath = [];
+  const level0 = [
+    { offset: txIndex, hash: txid, txid: true }
+  ];
+  if (nodes[0] === "*") {
+    level0.push({ offset: txIndex ^ 1, duplicate: true });
+  } else {
+    level0.push({ offset: txIndex ^ 1, hash: nodes[0] });
+  }
+  level0.sort((a, b) => a.offset - b.offset);
+  mpPath.push(level0);
+  for (let i = 1; i < treeHeight; i++) {
+    const siblingOffset = txIndex >> i ^ 1;
+    if (nodes[i] === "*") {
+      mpPath.push([{ offset: siblingOffset, duplicate: true }]);
+    } else {
+      mpPath.push([{ offset: siblingOffset, hash: nodes[i] }]);
+    }
+  }
+  return new MerklePath(blockHeight, mpPath);
+}
+
+// src/scripts/wallet/balance.ts
+init_dist();
+async function getBSVAgentWallet2() {
+  return BSVAgentWallet;
+}
+var _sdk3 = null;
+async function getSdk3() {
+  if (_sdk3) return _sdk3;
+  try {
+    _sdk3 = await import("@bsv/sdk");
+    return _sdk3;
+  } catch {
+    const { fileURLToPath: fileURLToPath2 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname2, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname2, "..", "..", "..", "..", "..", "a2a-bsv", "packages", "core", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(os3.homedir(), "a2a-bsv", "packages", "core", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js")
+    ];
+    for (const p of candidates) {
+      try {
+        _sdk3 = await import(p);
+        return _sdk3;
+      } catch {
+      }
+    }
+    throw new Error("Cannot find @bsv/sdk. Run setup.sh first.");
+  }
+}
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function cmdBalance() {
+  const BSVAgentWallet2 = await getBSVAgentWallet2();
+  const sdk = await getSdk3();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const total = await wallet.getBalance();
+  await wallet.destroy();
+  return ok({ walletBalance: total });
+}
+async function cmdImport(txidArg, voutStr) {
+  if (!txidArg) {
+    return fail("Usage: import <txid> [vout]");
+  }
+  const vout = parseInt(voutStr || "0", 10);
+  const txid = txidArg.toLowerCase();
+  if (!/^[0-9a-f]{64}$/.test(txid)) {
+    return fail("Invalid txid \u2014 must be 64 hex characters");
+  }
+  const sdk = await getSdk3();
+  const BSVAgentWallet2 = await getBSVAgentWallet2();
+  let txInfo = null;
+  const maxWaitMs = 6e4;
+  const startTime = Date.now();
+  let attempt = 0;
+  while (Date.now() - startTime < maxWaitMs) {
+    const txInfoResp = await wocFetch(`/tx/${txid}`, {}, 1, 1e4);
+    if (txInfoResp.ok) {
+      txInfo = await txInfoResp.json();
+      break;
+    } else if (txInfoResp.status === 404) {
+      attempt++;
+      const delayMs = Math.min(1e3 * Math.pow(1.5, attempt), 1e4);
+      console.error(`[import] Transaction not on WoC yet, waiting ${Math.round(delayMs / 1e3)}s... (attempt ${attempt})`);
+      await sleep(delayMs);
+      continue;
+    } else {
+      return fail(`Failed to fetch tx info: ${txInfoResp.status}`);
+    }
+  }
+  if (!txInfo) {
+    return fail(`Transaction ${txid} not found on WhatsOnChain after ${Math.round((Date.now() - startTime) / 1e3)}s. The transaction may not have been broadcast yet, or the txid may be incorrect.`);
+  }
+  const isConfirmed = txInfo.confirmations && txInfo.confirmations >= 1;
+  const blockHeight = txInfo.blockheight;
+  if (!txInfo.vout || !txInfo.vout[vout]) {
+    return fail(`Output index ${vout} not found in transaction (has ${txInfo.vout?.length || 0} outputs)`);
+  }
+  let atomicBeefBytes;
+  const wocBeefBytes = await fetchBeefFromWoC(txid);
+  if (wocBeefBytes) {
     try {
-        let servicesToAdvertise = [];
-        if (config?.services && Array.isArray(config.services)) {
-            servicesToAdvertise = config.services;
+      const wocBeef = sdk.Beef.fromBinary(Array.from(wocBeefBytes));
+      const foundTx = wocBeef.findTxid(txid);
+      if (foundTx) {
+        const txObj = foundTx.tx || foundTx._tx;
+        if (txObj) {
+          const output = txObj.outputs[vout];
+          if (!output) {
+            return fail(`Output index ${vout} not found in BEEF transaction (has ${txObj.outputs.length} outputs)`);
+          }
         }
-        if (servicesToAdvertise.length === 0)
-            return;
-        for (const serviceId of servicesToAdvertise) {
-            const serviceInfo = serviceManager.registry.get(serviceId);
-            if (!serviceInfo)
-                continue;
-            try {
-                const { cmdAdvertise } = await import('./src/scripts/overlay/services.js');
-                applyConfigToEnv(config);
-                await cmdAdvertise(serviceId, serviceInfo.name, String(serviceInfo.defaultPrice), serviceInfo.description);
+        atomicBeefBytes = wocBeef.toBinaryAtomic(txid);
+      }
+    } catch (beefErr) {
+      console.error(`[import] WoC BEEF parse failed: ${beefErr.message}`);
+    }
+  }
+  if (!atomicBeefBytes && isConfirmed) {
+    try {
+      const rawTxResp = await wocFetch(`/tx/${txid}/hex`);
+      if (!rawTxResp.ok) {
+        return fail(`Failed to fetch raw transaction: ${rawTxResp.status}`);
+      }
+      const rawTxHex = await rawTxResp.text();
+      const sourceTx = sdk.Transaction.fromHex(rawTxHex.trim());
+      const proofResp = await wocFetch(`/tx/${txid}/proof/tsc`);
+      if (!proofResp.ok) {
+        return fail(`Failed to fetch merkle proof: ${proofResp.status}`);
+      }
+      const proofData = await proofResp.json();
+      if (!Array.isArray(proofData) || proofData.length === 0) {
+        return fail("Merkle proof not available from WoC");
+      }
+      const proof = proofData[0];
+      const merklePath = await buildMerklePathFromTSC(txid, proof.index, proof.nodes, blockHeight);
+      sourceTx.merklePath = merklePath;
+      const beef = new sdk.Beef();
+      beef.mergeTransaction(sourceTx);
+      atomicBeefBytes = beef.toBinaryAtomic(txid);
+    } catch (manualErr) {
+      return fail(`Failed to construct BEEF manually: ${manualErr.message}`);
+    }
+  }
+  if (!atomicBeefBytes) {
+    if (isConfirmed) {
+      return fail(`Transaction ${txid} is confirmed but BEEF construction failed. This is unexpected \u2014 please report this issue.`);
+    } else {
+      return fail(
+        `Transaction ${txid} is unconfirmed (${txInfo.confirmations || 0} confirmations) and BEEF is not available.
+
+This usually means the funding transaction spends from other unconfirmed transactions, creating a chain.
+Wait for 1 block confirmation (~10 minutes) and try again, or use a fresh UTXO as the funding source.`
+      );
+    }
+  }
+  const outputSatoshis = txInfo.vout[vout].value != null ? Math.round(txInfo.vout[vout].value * 1e8) : void 0;
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const identityKey = await wallet.getIdentityKey();
+  try {
+    await wallet._setup.wallet.storage.internalizeAction({
+      tx: Array.from(atomicBeefBytes),
+      outputs: [{
+        outputIndex: vout,
+        protocol: "wallet payment",
+        paymentRemittance: {
+          derivationPrefix: sdk.Utils.toBase64(sdk.Utils.toArray("import", "utf8")),
+          derivationSuffix: sdk.Utils.toBase64(sdk.Utils.toArray("now", "utf8")),
+          senderIdentityKey: identityKey
+        }
+      }],
+      description: "External funding import"
+    });
+    const balance = await wallet.getBalance();
+    await wallet.destroy();
+    const explorerBase = getExplorerBaseUrl();
+    return ok({
+      txid,
+      vout,
+      satoshis: outputSatoshis,
+      blockHeight: blockHeight || null,
+      confirmations: txInfo.confirmations || 0,
+      imported: true,
+      unconfirmed: !isConfirmed,
+      balance,
+      explorer: `${explorerBase}/tx/${txid}`
+    });
+  } catch (err) {
+    await wallet.destroy();
+    if (err.message?.includes("already") || err.message?.includes("duplicate")) {
+      return fail(`UTXO ${txid}:${vout} appears to already be imported.`);
+    }
+    if (err.message?.includes("script") || err.message?.includes("locking")) {
+      return fail(`UTXO ${txid}:${vout} does not belong to this wallet's address. Make sure you sent to the correct address.`);
+    }
+    return fail(`Failed to import UTXO: ${err.message}`);
+  }
+}
+
+// src/scripts/overlay/registration.ts
+init_config();
+init_output();
+init_storage();
+init_transaction();
+init_dist();
+import fs8 from "node:fs";
+import { Transaction as Transaction2, Beef as Beef3, Script, PushDrop as PushDrop2 } from "@bsv/sdk";
+async function getBSVAgentWallet3() {
+  return BSVAgentWallet;
+}
+async function cmdRegister() {
+  if (!fs8.existsSync(PATHS.walletIdentity)) {
+    return fail("Wallet not initialized. Run: setup");
+  }
+  const BSVAgentWallet2 = await getBSVAgentWallet3();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const identityKey = await wallet.getIdentityKey();
+  await wallet.destroy();
+  const existingReg = loadRegistration();
+  if (existingReg && existingReg.identityKey === identityKey) {
+    return ok({
+      alreadyRegistered: true,
+      identityKey,
+      identityTxid: existingReg.identityTxid,
+      overlayUrl: OVERLAY_URL
+    });
+  }
+  const agentName = AGENT_NAME;
+  const agentDescription = AGENT_DESCRIPTION;
+  const capabilities = ["services"];
+  const services = loadServices();
+  if (services.some((s) => s.serviceId === "tell-joke")) {
+    capabilities.push("jokes");
+  }
+  const identityPayload = {
+    protocol: PROTOCOL_ID,
+    type: "identity",
+    identityKey,
+    name: agentName,
+    description: agentDescription,
+    channels: {
+      overlay: OVERLAY_URL
+    },
+    capabilities,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let identityResult;
+  try {
+    identityResult = await buildRealOverlayTransaction(identityPayload, TOPICS.IDENTITY);
+  } catch (err) {
+    return fail(`Registration failed: ${err.message}`);
+  }
+  let serviceTxid = null;
+  if (services.length > 0) {
+    for (const service of services) {
+      const servicePayload = {
+        protocol: PROTOCOL_ID,
+        type: "service",
+        identityKey,
+        serviceId: service.serviceId,
+        name: service.name,
+        description: service.description,
+        pricing: {
+          model: "per-task",
+          amountSats: service.priceSats
+        },
+        timestamp: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      try {
+        const serviceResult = await buildRealOverlayTransaction(servicePayload, TOPICS.SERVICES);
+        serviceTxid = serviceResult.txid;
+      } catch {
+      }
+    }
+  }
+  const registration = {
+    identityKey,
+    agentName,
+    agentDescription,
+    overlayUrl: OVERLAY_URL,
+    identityTxid: identityResult.txid,
+    serviceTxid,
+    funded: identityResult.funded,
+    registeredAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  saveRegistration(registration);
+  return ok({
+    registered: true,
+    identityKey,
+    identityTxid: identityResult.txid,
+    serviceTxid,
+    overlayUrl: OVERLAY_URL,
+    funded: identityResult.funded,
+    stateFile: PATHS.registration
+  });
+}
+async function cmdUnregister() {
+  const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const { outputs, BEEF } = await wallet._setup.wallet.listOutputs({ basket: TOPICS.IDENTITY, include: "entire transactions" });
+  const token = new PushDrop2(wallet._setup.wallet);
+  const unlockingScriptTemplate = await token.unlock([0, PROTOCOL_ID], "1", "self", "none", true);
+  const tempTx = new Transaction2();
+  const beef = Beef3.fromBinary(BEEF);
+  outputs.forEach((o) => {
+    const [txid2, v] = o.outpoint.split(".");
+    const sourceOutputIndex = Number(v);
+    const sourceTransaction = beef.findTransactionForSigning(txid2);
+    tempTx.addInput({
+      unlockingScriptTemplate,
+      sourceOutputIndex,
+      sourceTransaction
+    });
+  });
+  tempTx.addOutput({
+    lockingScript: Script.fromASM("OP_FALSE OP_RETURN 330123"),
+    satoshis: 0
+  });
+  await tempTx.sign();
+  const response = await wallet._setup.wallet.createAction({
+    inputBEEF: BEEF,
+    description: "revoke registration token",
+    inputs: tempTx.inputs.map((o) => ({
+      inputDescription: "previous registration",
+      outpoint: o.sourceTXID + "." + String(o.sourceOutputIndex),
+      unlockingScript: o.unlockingScript?.toHex()
+    }))
+  });
+  const txid = response.txid;
+  const submitResp = await fetch(`${OVERLAY_URL}/submit`, {
+    method: "POST",
+    headers: {
+      "Content-Type": "application/octet-stream",
+      "X-Topics": JSON.stringify([TOPICS.IDENTITY])
+    },
+    body: new Uint8Array(response.tx)
+  });
+  if (!submitResp.ok) {
+    const errText = await submitResp.text();
+    throw new Error(`Overlay submission failed: ${submitResp.status} \u2014 ${errText}`);
+  }
+  deleteRegistration();
+  return ok({
+    unregistered: true,
+    txid
+  });
+}
+
+// src/scripts/overlay/discover.ts
+init_config();
+init_output();
+init_transaction();
+async function cmdDiscover(args) {
+  let serviceFilter = null;
+  let agentFilter = null;
+  for (let i = 0; i < args.length; i++) {
+    if (args[i] === "--service" && args[i + 1]) serviceFilter = args[++i];
+    else if (args[i] === "--agent" && args[i + 1]) agentFilter = args[++i];
+  }
+  const results = { agents: [], services: [] };
+  if (!serviceFilter) {
+    try {
+      const agentQuery = agentFilter ? { name: agentFilter } : { type: "list" };
+      const agentResult = await lookupOverlay(LOOKUP_SERVICES.AGENTS, agentQuery);
+      if (agentResult.outputs) {
+        for (const output of agentResult.outputs) {
+          try {
+            const { data, txid } = await parseOverlayOutput(output.beef, output.outputIndex);
+            if (data?.type === "identity") {
+              const name = data.name || data.agentName || "Unknown Agent";
+              results.agents.push({ ...data, name, txid });
             }
-            catch { }
+          } catch {
+          }
         }
+      }
+    } catch (err) {
+      results.agentError = String(err);
     }
-    catch (err) {
-        logger?.warn?.('[openclaw-overlay] Auto-advertising failed:', err.message);
-    }
-}
-function wakeAgent(text, logger, options = {}) {
-    const sessionKey = options.sessionKey || `hook:openclaw-overlay:${Date.now()}`;
-    const gatewayPort = process['env'].OPENCLAW_GATEWAY_PORT || '18789';
-    const httpToken = process['env'].OPENCLAW_HOOKS_TOKEN || null;
-    if (!httpToken)
-        return;
-    fetch(`http://localhost:${gatewayPort}/hooks/agent`, {
-        method: 'POST',
-        headers: { 'Content-Type': 'application/json', 'x-openclaw-token': httpToken },
-        body: JSON.stringify({ prompt: text, sessionKey })
-    }).catch(() => { });
-}
-async function startBackgroundService(config, api) {
-    if (serviceRunning)
-        return;
-    serviceRunning = true;
-    abortController = new AbortController();
-    requestCleanupInterval = setInterval(() => {
-        if (serviceRunning)
-            wokenRequests.clear();
-    }, 5 * 60 * 1000);
-    applyConfigToEnv(config);
-    // Start the connection directly as a library call
-    // This bypasses the child_process detection and is more efficient
-    cmdConnect((event) => {
-        if ((event.action === 'queued-for-agent' || event.action === 'already-queued') && event.serviceId) {
-            const rid = event.id || `${event.from}-${Date.now()}`;
-            if (wokenRequests.has(rid))
-                return;
-            wokenRequests.add(rid);
-            const wakeText = `⚡ Incoming overlay service request!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nPaid: ${event.satoshisReceived || '?'} sats\n\nFulfill it now:\n1. overlay({ action: "pending-requests" })\n2. Process the request\n3. overlay({ action: "fulfill", requestId: "${event.id}", recipientKey: "${event.from}", serviceId: "${event.serviceId}", result: { ... } })`;
-            wakeAgent(wakeText, api.logger, { sessionKey: `hook:openclaw-overlay:${rid}` });
+  }
+  if (!agentFilter) {
+    try {
+      const serviceQuery = serviceFilter ? { serviceType: serviceFilter } : {};
+      const serviceResult = await lookupOverlay(LOOKUP_SERVICES.SERVICES, serviceQuery);
+      if (serviceResult.outputs) {
+        for (const output of serviceResult.outputs) {
+          try {
+            const { data, txid } = await parseOverlayOutput(output.beef, output.outputIndex);
+            if (data?.type === "service") {
+              results.services.push({ ...data, txid });
+            }
+          } catch {
+          }
         }
-        if (event.type === 'service-response' && event.action === 'received') {
-            const wakeText = `📬 Overlay service response received!\n\nService: ${event.serviceId}\nFrom: ${event.from}\nStatus: ${event.status}\n\nFull result:\n${JSON.stringify(event.result, null, 2)}`;
-            wakeAgent(wakeText, api.logger, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
+      }
+    } catch (err) {
+      results.serviceError = String(err);
+    }
+  }
+  return ok({
+    overlayUrl: OVERLAY_URL,
+    agentCount: results.agents.length,
+    serviceCount: results.services.length,
+    agents: results.agents,
+    services: results.services,
+    ...results.agentError && { agentError: results.agentError },
+    ...results.serviceError && { serviceError: results.serviceError }
+  });
+}
+
+// src/scripts/services/request.ts
+init_config();
+init_output();
+
+// src/scripts/payment/build.ts
+init_config();
+init_dist();
+async function getBSVAgentWallet4() {
+  return BSVAgentWallet;
+}
+async function buildDirectPayment(recipientPubKey, sats, desc) {
+  if (!/^0[23][0-9a-fA-F]{64}$/.test(recipientPubKey)) {
+    throw new Error("Recipient must be a compressed public key (66 hex chars starting with 02 or 03)");
+  }
+  const BSVAgentWallet2 = await getBSVAgentWallet4();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  try {
+    const result = await wallet.createPayment({
+      to: recipientPubKey,
+      satoshis: sats,
+      description: desc || "agent payment"
+    });
+    return {
+      beef: result.beef,
+      txid: result.txid,
+      satoshis: result.satoshis,
+      derivationPrefix: result.derivationPrefix,
+      derivationSuffix: result.derivationSuffix,
+      senderIdentityKey: result.senderIdentityKey
+    };
+  } finally {
+    await wallet.destroy();
+  }
+}
+
+// src/scripts/services/request.ts
+async function cmdRequestService(targetKey, serviceId, satsStr, inputJsonStr) {
+  if (!targetKey || !serviceId) {
+    return fail("Usage: request-service <identityKey> <serviceId> [sats] [inputJson]");
+  }
+  if (!/^0[23][0-9a-fA-F]{64}$/.test(targetKey)) {
+    return fail("Target must be a compressed public key (66 hex chars, 02/03 prefix)");
+  }
+  const { identityKey, privKey } = await loadIdentity();
+  const sats = parseInt(satsStr || "5", 10);
+  let inputData = null;
+  if (inputJsonStr) {
+    try {
+      inputData = JSON.parse(inputJsonStr);
+    } catch {
+      return fail("inputJson must be valid JSON");
+    }
+  }
+  let paymentData = null;
+  if (sats > 0) {
+    try {
+      const payment = await buildDirectPayment(targetKey, sats, `service-request: ${serviceId}`);
+      paymentData = {
+        beef: payment.beef,
+        txid: payment.txid,
+        satoshis: payment.satoshis,
+        derivationPrefix: payment.derivationPrefix,
+        derivationSuffix: payment.derivationSuffix,
+        senderIdentityKey: payment.senderIdentityKey
+      };
+    } catch (err) {
+      paymentData = { error: String(err.message || err) };
+    }
+  }
+  const requestPayload = {
+    serviceId,
+    ...inputData ? { input: inputData } : {},
+    payment: paymentData,
+    requestedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  const signature = await signRelayMessage(privKey, targetKey, "service-request", requestPayload);
+  const resp = await fetch(`${OVERLAY_URL}/relay/send`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      from: identityKey,
+      to: targetKey,
+      type: "service-request",
+      payload: requestPayload,
+      signature
+    })
+  });
+  if (!resp.ok) {
+    const body = await resp.text();
+    return fail(`Relay send failed (${resp.status}): ${body}`);
+  }
+  const result = await resp.json();
+  return ok({
+    sent: true,
+    requestId: result.id,
+    to: targetKey,
+    serviceId,
+    paymentIncluded: paymentData && !paymentData.error,
+    paymentTxid: paymentData?.txid || null,
+    satoshis: paymentData?.satoshis || 0,
+    note: "Poll for service-response to get the result"
+  });
+}
+
+// src/scripts/services/queue.ts
+init_config();
+init_output();
+init_storage();
+import fs9 from "node:fs";
+async function cmdServiceQueue() {
+  if (!fs9.existsSync(PATHS.serviceQueue)) {
+    return ok({ pending: [], count: 0 });
+  }
+  const entries = readJsonl(PATHS.serviceQueue);
+  const pending = entries.filter((e) => e.status === "pending");
+  return ok({ pending, count: pending.length, total: entries.length });
+}
+
+// src/scripts/services/respond.ts
+init_config();
+init_output();
+import fs10 from "node:fs";
+init_storage();
+async function cmdRespondService(requestId, recipientKey, serviceId, resultJson) {
+  if (!requestId || !recipientKey || !serviceId || !resultJson) {
+    return fail("Usage: respond-service <requestId> <recipientKey> <serviceId> <resultJson>");
+  }
+  let result;
+  try {
+    result = JSON.parse(resultJson);
+  } catch {
+    return fail("resultJson must be valid JSON");
+  }
+  const { identityKey, privKey } = await loadIdentity();
+  if (fs10.existsSync(PATHS.serviceQueue)) {
+    const lines = fs10.readFileSync(PATHS.serviceQueue, "utf-8").trim().split("\n").filter(Boolean);
+    const finalStatuses = ["fulfilled", "rejected", "delivery_failed", "failed", "error"];
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.requestId === requestId && finalStatuses.includes(entry.status)) {
+          return ok({
+            sent: false,
+            requestId,
+            serviceId,
+            to: recipientKey,
+            message: `Request already processed with status: ${entry.status}`,
+            alreadyProcessed: true,
+            previousStatus: entry.status
+          });
         }
-    }, abortController.signal).catch((err) => {
-        if (serviceRunning && !abortController?.signal.aborted) {
-            api.logger?.error?.(`[openclaw-overlay] WebSocket error: ${err.message}`);
+      } catch {
+      }
+    }
+  }
+  const responsePayload = {
+    requestId,
+    serviceId,
+    status: "fulfilled",
+    result
+  };
+  const sig = await signRelayMessage(privKey, recipientKey, "service-response", responsePayload);
+  const resp = await fetch(`${OVERLAY_URL}/relay/send`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      from: identityKey,
+      to: recipientKey,
+      type: "service-response",
+      payload: responsePayload,
+      signature: sig
+    })
+  });
+  if (!resp.ok) {
+    updateServiceQueueStatus(requestId, "failed", {
+      failedAt: Date.now(),
+      error: `Relay send failed: ${resp.status}`
+    });
+    return fail(`Relay send failed: ${resp.status}`);
+  }
+  updateServiceQueueStatus(requestId, "fulfilled", {
+    fulfilledAt: Date.now()
+  });
+  return ok({ sent: true, requestId, serviceId, to: recipientKey });
+}
+
+// src/scripts/messaging/connect.ts
+init_config();
+init_output();
+import fs12 from "node:fs";
+
+// src/scripts/messaging/handlers.ts
+init_config();
+import fs11 from "node:fs";
+init_storage();
+init_dist();
+var _sdk4 = null;
+async function getSdk4() {
+  if (_sdk4) return _sdk4;
+  try {
+    _sdk4 = await import("@bsv/sdk");
+    return _sdk4;
+  } catch {
+    const { fileURLToPath: fileURLToPath2 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname2 = path5.dirname(fileURLToPath2(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname2, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname2, "..", "..", "..", "..", "..", "a2a-bsv", "packages", "core", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(os3.homedir(), "a2a-bsv", "packages", "core", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js")
+    ];
+    for (const p of candidates) {
+      try {
+        _sdk4 = await import(p);
+        return _sdk4;
+      } catch {
+      }
+    }
+    throw new Error("Cannot find @bsv/sdk. Run setup.sh first.");
+  }
+}
+async function getBSVAgentWallet5() {
+  return BSVAgentWallet;
+}
+async function getNetwork() {
+  const config = await Promise.resolve().then(() => (init_config(), config_exports));
+  return config.NETWORK;
+}
+async function verifyAndAcceptPayment(payment, minSats, senderKey, serviceId, ourHash160) {
+  if (!payment) {
+    return { accepted: false, txid: null, satoshis: 0, outputIndex: 0, walletAccepted: false, error: "no payment" };
+  }
+  if (payment.error) {
+    return { accepted: false, txid: null, satoshis: 0, outputIndex: 0, walletAccepted: false, error: payment.error };
+  }
+  if (!payment.beef || !payment.satoshis) {
+    return { accepted: false, txid: null, satoshis: 0, outputIndex: 0, walletAccepted: false, error: "missing beef or satoshis" };
+  }
+  if (payment.satoshis < minSats) {
+    return { accepted: false, txid: payment.txid || null, satoshis: payment.satoshis, outputIndex: 0, walletAccepted: false, error: `insufficient payment: ${payment.satoshis} < ${minSats}` };
+  }
+  const BSVAgentWallet2 = await getBSVAgentWallet5();
+  const network = await getNetwork();
+  const wallet = await BSVAgentWallet2.load({ network, storageDir: WALLET_DIR });
+  try {
+    const verifyResult = await wallet.verifyPayment({ beef: payment.beef });
+    if (!verifyResult.valid) {
+      await wallet.destroy();
+      return { accepted: false, txid: payment.txid || null, satoshis: payment.satoshis, outputIndex: 0, walletAccepted: false, error: `verification failed: ${verifyResult.errors.join(", ")}` };
+    }
+    const acceptResult = await wallet.acceptPayment({
+      beef: payment.beef,
+      derivationPrefix: payment.derivationPrefix,
+      derivationSuffix: payment.derivationSuffix,
+      senderIdentityKey: payment.senderIdentityKey,
+      description: `Payment for ${serviceId}`
+    });
+    await wallet.destroy();
+    if (!acceptResult.accepted) {
+      return { accepted: false, txid: payment.txid || null, satoshis: payment.satoshis, outputIndex: 0, walletAccepted: false, error: "wallet rejected payment" };
+    }
+    return {
+      accepted: true,
+      txid: payment.txid,
+      satoshis: payment.satoshis,
+      outputIndex: 0,
+      walletAccepted: true,
+      error: null
+    };
+  } catch (err) {
+    await wallet.destroy();
+    return { accepted: false, txid: payment.txid || null, satoshis: payment.satoshis, outputIndex: 0, walletAccepted: false, error: err.message };
+  }
+}
+async function queueForAgent(msg, identityKey, privKey, serviceId) {
+  if (fs11.existsSync(PATHS.serviceQueue)) {
+    const lines = fs11.readFileSync(PATHS.serviceQueue, "utf-8").trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      try {
+        const entry = JSON.parse(line);
+        if (entry.requestId === msg.id) {
+          return {
+            id: msg.id,
+            type: "service-request",
+            serviceId,
+            action: entry.status === "pending" ? "already-queued" : `already-${entry.status}`,
+            paymentAccepted: true,
+            paymentTxid: entry.paymentTxid,
+            satoshisReceived: entry.satoshisReceived,
+            from: msg.from,
+            ack: true
+          };
         }
+      } catch {
+      }
+    }
+  }
+  const sdk = await getSdk4();
+  const payment = msg.payload?.payment;
+  const input = msg.payload?.input || msg.payload;
+  const walletIdentity = loadWalletIdentity();
+  const ourHash160 = sdk.Hash.hash160(sdk.PrivateKey.fromHex(walletIdentity.rootKeyHex).toPublicKey().encode(true));
+  const serviceDefinition = serviceManager.registry.get(serviceId);
+  let minPrice = 5;
+  if (serviceDefinition) {
+    minPrice = serviceDefinition.defaultPrice;
+    const validation = serviceManager.validate(serviceId, input);
+    if (!validation.valid) {
+      const rejectPayload = {
+        requestId: msg.id,
+        serviceId,
+        status: "rejected",
+        reason: `Input validation failed: ${validation.error}`
+      };
+      const sig = await signRelayMessage(privKey, msg.from, "service-response", rejectPayload);
+      await fetchWithTimeout(`${OVERLAY_URL}/relay/send`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ from: identityKey, to: msg.from, type: "service-response", payload: rejectPayload, signature: sig })
+      });
+      const rejectedEntry = {
+        status: "rejected",
+        requestId: msg.id,
+        serviceId,
+        from: msg.from,
+        identityKey,
+        input,
+        paymentTxid: null,
+        satoshisReceived: 0,
+        walletAccepted: false,
+        error: validation.error,
+        _ts: Date.now()
+      };
+      appendToJsonl(PATHS.serviceQueue, rejectedEntry);
+      return {
+        id: msg.id,
+        type: "service-request",
+        serviceId,
+        action: "rejected",
+        reason: validation.error || "input validation failed",
+        from: msg.from,
+        ack: true
+      };
+    }
+  } else {
+    const services = loadServices();
+    const svc = services.find((s) => s.serviceId === serviceId);
+    minPrice = svc?.priceSats || 5;
+  }
+  const payResult = await verifyAndAcceptPayment(payment, minPrice, msg.from, serviceId, ourHash160);
+  if (!payResult.accepted) {
+    const rejectPayload = { requestId: msg.id, serviceId, status: "rejected", reason: `Payment rejected: ${payResult.error}` };
+    const sig = await signRelayMessage(privKey, msg.from, "service-response", rejectPayload);
+    await fetchWithTimeout(`${OVERLAY_URL}/relay/send`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ from: identityKey, to: msg.from, type: "service-response", payload: rejectPayload, signature: sig })
     });
+    const rejectedEntry = {
+      status: "rejected",
+      requestId: msg.id,
+      serviceId,
+      from: msg.from,
+      identityKey,
+      input,
+      paymentTxid: null,
+      satoshisReceived: 0,
+      walletAccepted: false,
+      error: payResult.error,
+      _ts: Date.now()
+    };
+    appendToJsonl(PATHS.serviceQueue, rejectedEntry);
+    return { id: msg.id, type: "service-request", serviceId, action: "rejected", reason: payResult.error || "payment rejected", from: msg.from, ack: true };
+  }
+  const queueEntry = {
+    status: "pending",
+    requestId: msg.id,
+    serviceId,
+    from: msg.from,
+    identityKey,
+    input,
+    paymentTxid: payResult.txid,
+    satoshisReceived: payResult.satoshis,
+    walletAccepted: payResult.walletAccepted,
+    _ts: Date.now()
+  };
+  appendToJsonl(PATHS.serviceQueue, queueEntry);
+  return {
+    id: msg.id,
+    type: "service-request",
+    serviceId,
+    action: "queued-for-agent",
+    paymentAccepted: true,
+    paymentTxid: payResult.txid,
+    satoshisReceived: payResult.satoshis,
+    from: msg.from,
+    ack: true
+  };
 }
-function stopBackgroundService() {
-    serviceRunning = false;
-    if (abortController) {
-        abortController.abort();
-        abortController = null;
-    }
-    if (requestCleanupInterval) {
-        clearInterval(requestCleanupInterval);
-        requestCleanupInterval = null;
-    }
-    wokenRequests.clear();
-    if (autoImportInterval) {
-        clearInterval(autoImportInterval);
-        autoImportInterval = null;
-    }
-}
-export function register(api) {
-    const version = "0.8.15";
-    if (isInitialized)
-        return;
-    isInitialized = true;
-    api.logger?.info?.(`[openclaw-overlay] Initializing Plugin v${version}`);
-    const entries = api.getConfig?.()?.plugins?.entries || {};
-    const entry = entries['openclaw-overlay-plugin'] || entries['openclaw-overlay'] || {};
-    const pluginConfig = { ...entry, ...(entry.config || {}), ...(api.config || {}) };
-    // 1. Tool
-    api.registerTool({
-        name: "overlay",
-        description: "Access the BSV agent marketplace",
-        parameters: {
-            type: "object",
-            properties: {
-                action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister"] },
-                service: { type: "string" },
-                input: { type: "object" },
-                identityKey: { type: "string" },
-                sats: { type: "number" },
-                requestId: { type: "string" },
-                recipientKey: { type: "string" },
-                serviceId: { type: "string" },
-                result: { type: "object" }
-            },
-            required: ["action"]
-        },
-        async execute(_id, params) {
-            try {
-                return await executeOverlayAction(params, pluginConfig, api);
-            }
-            catch (error) {
-                return { content: [{ type: "text", text: `Error: ${error.message}` }] };
-            }
+async function processMessage(msg, identityKey, privKey) {
+  const sigCheck = msg.signature ? await verifyRelaySignature(msg.from, msg.to, msg.type, msg.payload, msg.signature) : { valid: null };
+  if (msg.type === "service-request" && sigCheck.valid !== true) {
+    console.error(JSON.stringify({ event: "signature-rejected", type: msg.type, from: msg.from, reason: sigCheck.reason || "missing signature" }));
+    return {
+      id: msg.id,
+      type: msg.type,
+      from: msg.from,
+      action: "rejected",
+      reason: "invalid-signature",
+      signatureValid: sigCheck.valid,
+      ack: true
+    };
+  }
+  if (msg.type === "ping") {
+    const pongPayload = {
+      text: "pong",
+      inReplyTo: msg.id,
+      originalText: msg.payload?.text || null
+    };
+    const pongSig = await signRelayMessage(privKey, msg.from, "pong", pongPayload);
+    await fetch(`${OVERLAY_URL}/relay/send`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({
+        from: identityKey,
+        to: msg.from,
+        type: "pong",
+        payload: pongPayload,
+        signature: pongSig
+      })
+    });
+    return { id: msg.id, type: "ping", action: "replied-pong", from: msg.from, ack: true };
+  }
+  if (msg.type === "service-request") {
+    const serviceId = msg.payload?.serviceId;
+    if (process["env"].AGENT_ROUTED === "true") {
+      return await queueForAgent(msg, identityKey, privKey, serviceId);
+    }
+    return await queueForAgent(msg, identityKey, privKey, serviceId);
+  }
+  if (msg.type === "pong") {
+    return {
+      id: msg.id,
+      type: "pong",
+      action: "received",
+      from: msg.from,
+      text: msg.payload?.text,
+      inReplyTo: msg.payload?.inReplyTo,
+      ack: true
+    };
+  }
+  if (msg.type === "service-response") {
+    const serviceId = msg.payload?.serviceId;
+    const status = msg.payload?.status;
+    const result = msg.payload?.result;
+    return {
+      id: msg.id,
+      type: "service-response",
+      action: "received",
+      from: msg.from,
+      serviceId,
+      status,
+      result,
+      requestId: msg.payload?.requestId,
+      direction: "incoming-response",
+      ack: true
+    };
+  }
+  return {
+    id: msg.id,
+    type: msg.type,
+    from: msg.from,
+    payload: msg.payload,
+    signatureValid: sigCheck.valid,
+    action: "unhandled",
+    ack: false
+  };
+}
+
+// src/scripts/messaging/connect.ts
+init_storage();
+import debug2 from "debug";
+var log2 = debug2("openclaw:plugin:overlay:connect");
+async function cmdConnect(onMessage, signal) {
+  let WebSocketClient;
+  try {
+    const ws = await import("ws");
+    WebSocketClient = ws.default || ws.WebSocket || ws;
+  } catch {
+    return fail("WebSocket client not available. Install it: npm install ws");
+  }
+  const { identityKey, privKey } = await loadIdentity();
+  const wsUrl = OVERLAY_URL.replace(/^http/, "ws") + "/relay/subscribe?identity=" + identityKey;
+  log2("Connecting to WebSocket relay: %s", wsUrl);
+  let reconnectDelay = 1e3;
+  let shouldReconnect = true;
+  let currentWs = null;
+  function shutdown() {
+    shouldReconnect = false;
+    if (currentWs) {
+      try {
+        currentWs.close();
+      } catch {
+      }
+    }
+    if (!onMessage) {
+      process.exit(0);
+    }
+  }
+  if (!onMessage) {
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+  }
+  if (signal) {
+    signal.addEventListener("abort", () => {
+      shouldReconnect = false;
+      if (currentWs) {
+        try {
+          currentWs.close();
+        } catch {
         }
+      }
     });
-    // 2. Command
-    api.registerCommand({
-        name: "overlay",
-        description: "BSV Overlay Marketplace commands",
-        acceptsArgs: true,
-        handler: async (ctx) => {
+  }
+  function connect() {
+    if (signal?.aborted) return;
+    const ws = new WebSocketClient(wsUrl);
+    currentWs = ws;
+    ws.on("open", () => {
+      log2("WebSocket connection established!");
+      reconnectDelay = 1e3;
+      const logMsg = { event: "connected", identity: identityKey, overlay: OVERLAY_URL };
+      if (onMessage) onMessage(logMsg);
+      else console.error(JSON.stringify(logMsg));
+    });
+    ws.on("message", async (data) => {
+      log2("Incoming WebSocket message received");
+      try {
+        const envelope = JSON.parse(data.toString());
+        log2("Message type: %s", envelope.type);
+        if (envelope.type === "message") {
+          const result = await processMessage(envelope.message, identityKey, privKey);
+          log2("Processed message: %s", result.id);
+          if (onMessage) onMessage(result);
+          else console.log(JSON.stringify(result));
+          ensureStateDir();
+          try {
+            fs12.appendFileSync(PATHS.notifications, JSON.stringify({ ...result, _ts: Date.now() }) + "\n");
+          } catch {
+          }
+          if (result.ack) {
             try {
-                api.logger?.info?.(`[openclaw-overlay] Command received with args: ${JSON.stringify(ctx.args)} (type: ${typeof ctx.args})`);
-                const args = Array.isArray(ctx.args) ? ctx.args : (typeof ctx.args === 'string' ? ctx.args.split(' ').filter(Boolean) : []);
-                const action = args[0] || 'status';
-                const result = await executeOverlayAction({ action }, pluginConfig, api);
-                return { text: `**Overlay ${action.toUpperCase()}**\n\n${typeof result === 'string' ? result : JSON.stringify(result, null, 2)}` };
-            }
-            catch (error) {
-                return { text: `❌ Error: ${error.message}` };
+              await fetch(OVERLAY_URL + "/relay/ack", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ identity: identityKey, messageIds: [result.id] })
+              });
+            } catch (ackErr) {
+              const log4 = { event: "ack-error", id: result.id, message: String(ackErr) };
+              if (onMessage) onMessage(log4);
+              else console.error(JSON.stringify(log4));
             }
+          }
         }
+        if (envelope.type === "service-announced") {
+          const svc = envelope.service || {};
+          const announcement = {
+            event: "service-announced",
+            serviceId: svc.serviceId,
+            name: svc.name,
+            description: svc.description,
+            priceSats: svc.pricingSats,
+            provider: svc.identityKey,
+            txid: envelope.txid,
+            _ts: Date.now()
+          };
+          if (onMessage) onMessage(announcement);
+          else console.log(JSON.stringify(announcement));
+          ensureStateDir();
+          try {
+            fs12.appendFileSync(PATHS.notifications, JSON.stringify(announcement) + "\n");
+          } catch {
+          }
+        }
+      } catch (err) {
+        const log4 = { event: "process-error", message: String(err) };
+        if (onMessage) onMessage(log4);
+        else console.error(JSON.stringify(log4));
+      }
     });
-    // 3. Service
-    api.registerService({
-        id: "openclaw-overlay-relay",
-        start: async () => {
-            try {
-                await initializeServiceSystem();
-            }
-            catch { }
-            await startBackgroundService(pluginConfig, api);
-            await startAutoImport(pluginConfig, api);
-        },
-        stop: () => stopBackgroundService()
+    ws.on("close", () => {
+      currentWs = null;
+      if (shouldReconnect && !signal?.aborted) {
+        const log4 = { event: "disconnected", reconnectMs: reconnectDelay };
+        if (onMessage) onMessage(log4);
+        else console.error(JSON.stringify(log4));
+        setTimeout(connect, reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 2, 3e4);
+      }
     });
-    // 4. CLI
-    api.registerCli(({ program }) => {
-        const overlay = program.command("overlay").description("BSV Overlay Network management");
-        overlay.command("status").description("Show identity and balance").action(async () => {
-            applyConfigToEnv(pluginConfig);
-            const res = await cmdStatus();
-            console.log(JSON.stringify(res.data, null, 2));
-        });
-        overlay.command("balance").description("Show current wallet balance").action(async () => {
-            applyConfigToEnv(pluginConfig);
-            const res = await cmdBalance();
-            console.log(JSON.stringify(res.data, null, 2));
-        });
-        overlay.command("discover").description("Find agents and services").option("-s, --service <type>", "Filter by service type").option("-a, --agent <name>", "Filter by agent name").action(async (options) => {
-            applyConfigToEnv(pluginConfig);
-            const args = [];
-            if (options.service)
-                args.push('--service', options.service);
-            if (options.agent)
-                args.push('--agent', options.agent);
-            const res = await cmdDiscover(args);
-            console.log(JSON.stringify(res.data, null, 2));
-        });
-    }, { commands: ["overlay"] });
+    ws.on("error", (err) => {
+      const log4 = { event: "error", message: err.message };
+      if (onMessage) onMessage(log4);
+      else console.error(JSON.stringify(log4));
+    });
+  }
+  connect();
+  return new Promise((resolve) => {
+    if (signal) {
+      signal.addEventListener("abort", () => resolve());
+    }
+  });
 }
-async function executeOverlayAction(params, config, api) {
-    const { action } = params;
-    log('Executing action: %s with params: %O', action, params);
+
+// index.ts
+init_output();
+import debug3 from "debug";
+var log3 = debug3("openclaw:plugin:overlay");
+var isInitialized = false;
+var serviceRunning = false;
+var abortController = null;
+var autoImportInterval = null;
+var knownTxids = /* @__PURE__ */ new Set();
+var wokenRequests = /* @__PURE__ */ new Set();
+var requestCleanupInterval = null;
+var BUDGET_FILE = "daily-spending.json";
+function getBudgetPath(walletDir) {
+  return path4.join(walletDir, BUDGET_FILE);
+}
+function loadDailySpending(walletDir) {
+  const today = (/* @__PURE__ */ new Date()).toISOString().slice(0, 10);
+  const budgetPath = getBudgetPath(walletDir);
+  try {
+    if (fs13.existsSync(budgetPath)) {
+      const data = JSON.parse(fs13.readFileSync(budgetPath, "utf-8"));
+      if (data.date === today) return data;
+    }
+  } catch {
+  }
+  return { date: today, totalSats: 0, transactions: [] };
+}
+function recordSpend(walletDir, sats, service, provider) {
+  const spending = loadDailySpending(walletDir);
+  spending.totalSats += sats;
+  spending.transactions.push({ ts: Date.now(), sats, service, provider });
+  fs13.writeFileSync(getBudgetPath(walletDir), JSON.stringify(spending, null, 2));
+}
+function checkBudget(walletDir, requestedSats, dailyLimit) {
+  const spending = loadDailySpending(walletDir);
+  const remaining = dailyLimit - spending.totalSats;
+  return {
+    allowed: remaining >= requestedSats,
+    remaining,
+    spent: spending.totalSats
+  };
+}
+function applyConfigToEnv(config) {
+  process["env"].BSV_WALLET_DIR = config.walletDir || path4.join(os2.homedir(), ".openclaw", "bsv-wallet");
+  process["env"].OVERLAY_URL = config.overlayUrl || "https://clawoverlay.com";
+  process["env"].BSV_NETWORK = config.network || process["env"].BSV_NETWORK || "mainnet";
+  process["env"].BSV_ARC_URL = config.arcUrl || (process["env"].BSV_NETWORK === "testnet" ? "https://testnet.arc.gorillapool.io" : "https://arc.gorillapool.io");
+  process["env"].AGENT_NAME = config.agentName || "openclaw-agent";
+  setNoExit(true);
+}
+function wakeAgent(text, logger, port, token, options = {}) {
+  const sessionKey = options.sessionKey || `hook:openclaw-overlay:${Date.now()}`;
+  if (!token) return;
+  const target = `http://localhost:${port}/hooks/agent`;
+  fetch(target, {
+    method: "POST",
+    headers: { "Content-Type": "application/json", "x-openclaw-token": token },
+    body: JSON.stringify({ prompt: text, sessionKey })
+  }).catch(() => {
+  });
+}
+async function startAutoImport(config, api, port, token) {
+  try {
     applyConfigToEnv(config);
-    switch (action) {
-        case "request": {
-            const { service, input } = params;
-            const walletDir = config?.walletDir || path.join(os.homedir(), '.openclaw', 'bsv-wallet');
-            const discoverOutput = await cmdDiscover(['--service', service]);
-            const providers = discoverOutput.data.services;
-            if (!providers || providers.length === 0)
-                throw new Error(`No providers found for ${service}`);
-            providers.sort((a, b) => (a.pricing?.amountSats || 0) - (b.pricing?.amountSats || 0));
-            const best = providers[0];
-            const price = best.pricing?.amountSats || 0;
-            const budget = checkBudget(walletDir, price, config.dailyBudgetSats || 5000);
-            if (!budget.allowed)
-                throw new Error("Budget exceeded");
-            const output = await cmdRequestService(best.identityKey, service, price.toString(), input ? JSON.stringify(input) : undefined);
-            recordSpend(walletDir, price, service, best.name);
-            return { status: "sent", requestId: output.data?.messageId, message: `Request sent to ${best.name} for ${price} sats.` };
-        }
-        case "discover": return (await cmdDiscover(params.service ? ['--service', params.service] : [])).data;
-        case "balance": return (await cmdBalance()).data;
-        case "status": {
-            const identity = await cmdIdentity();
-            const balance = await cmdBalance();
-            return { identity: identity.data, balance: balance.data };
-        }
-        case "onboard": {
-            await cmdSetup();
-            const addr = (await cmdAddress()).data.address;
-            const bal = (await cmdBalance()).data.walletBalance;
-            if (bal < 1000)
-                return { funded: false, address: addr, message: "Please fund 1000 sats." };
-            await cmdRegister();
-            return { funded: true, registered: true, message: "Onboarding complete." };
-        }
-        case "pending-requests": return (await cmdServiceQueue()).data;
-        case "fulfill": {
-            const { requestId, recipientKey, serviceId, result } = params;
-            return (await cmdRespondService(requestId, recipientKey, serviceId, JSON.stringify(result))).data;
+    const addrOutput = await cmdAddress();
+    if (!addrOutput.success) return;
+    const address = addrOutput.data?.address;
+    if (!address) return;
+    autoImportInterval = setInterval(async () => {
+      try {
+        const network = process["env"].BSV_NETWORK === "testnet" ? "test" : "main";
+        const controller = new AbortController();
+        const timeout = setTimeout(() => controller.abort(), 15e3);
+        const resp = await fetch(`https://api.whatsonchain.com/v1/bsv/${network}/address/${address}/unspent/all`, { signal: controller.signal });
+        clearTimeout(timeout);
+        if (!resp.ok) return;
+        const data = await resp.json();
+        const utxos = data.result || [];
+        for (const utxo of utxos) {
+          const key = `${utxo.tx_hash}:${utxo.tx_pos}`;
+          if (knownTxids.has(key)) continue;
+          if (utxo.value < 200) continue;
+          api.logger?.info?.(`[openclaw-overlay] Auto-importing UTXO: ${utxo.tx_hash}:${utxo.tx_pos} (${utxo.value} sats)`);
+          try {
+            applyConfigToEnv(config);
+            const importOutput = await cmdImport(utxo.tx_hash, String(utxo.tx_pos));
+            if (importOutput.success) {
+              knownTxids.add(key);
+              api.logger?.info?.(`[openclaw-overlay] Auto-imported ${utxo.value} sats from ${utxo.tx_hash}`);
+              wakeAgent(`\u{1F4B0} **Wallet Funded!**
+
+Auto-imported ${utxo.value} sats from transaction ${utxo.tx_hash.slice(0, 16)}...
+
+Notify the user their wallet has been funded.`, api.logger, port, token, { sessionKey: "hook:openclaw-overlay:import" });
+              try {
+                const regPath = path4.join(os2.homedir(), ".openclaw", "openclaw-overlay", "registration.json");
+                if (!fs13.existsSync(regPath)) {
+                  api.logger?.info?.("[openclaw-overlay] Not yet registered \u2014 auto-registering...");
+                  applyConfigToEnv(config);
+                  const regOutput = await cmdRegister();
+                  if (regOutput.success) {
+                    api.logger?.info?.("[openclaw-overlay] Auto-registered on overlay network!");
+                    await autoAdvertiseServices(config, api.logger);
+                  }
+                }
+              } catch (err) {
+                api.logger?.warn?.("[openclaw-overlay] Auto-registration failed:", err.message);
+              }
+            }
+          } catch (err) {
+            knownTxids.add(key);
+          }
         }
-        case "unregister": return (await cmdUnregister()).data;
-        default: throw new Error(`Unknown action: ${action}`);
+      } catch (err) {
+      }
+    }, 3e4);
+  } catch (err) {
+    api.logger?.warn?.("[openclaw-overlay] Auto-import setup failed:", err.message);
+  }
+}
+async function autoAdvertiseServices(config, logger) {
+  try {
+    let servicesToAdvertise = [];
+    if (config?.services && Array.isArray(config.services)) {
+      servicesToAdvertise = config.services;
+    }
+    if (servicesToAdvertise.length === 0) return;
+    for (const serviceId of servicesToAdvertise) {
+      const serviceInfo = serviceManager.registry.get(serviceId);
+      if (!serviceInfo) continue;
+      try {
+        const { cmdAdvertise: cmdAdvertise2 } = await Promise.resolve().then(() => (init_services(), services_exports));
+        applyConfigToEnv(config);
+        await cmdAdvertise2(serviceId, serviceInfo.name, String(serviceInfo.defaultPrice), serviceInfo.description);
+      } catch {
+      }
+    }
+  } catch (err) {
+    logger?.warn?.("[openclaw-overlay] Auto-advertising failed:", err.message);
+  }
+}
+async function startBackgroundService(config, api, port, token) {
+  if (serviceRunning) return;
+  serviceRunning = true;
+  abortController = new AbortController();
+  requestCleanupInterval = setInterval(() => {
+    if (serviceRunning) wokenRequests.clear();
+  }, 5 * 60 * 1e3);
+  applyConfigToEnv(config);
+  cmdConnect((event) => {
+    if ((event.action === "queued-for-agent" || event.action === "already-queued") && event.serviceId) {
+      const rid = event.id || `${event.from}-${Date.now()}`;
+      if (wokenRequests.has(rid)) return;
+      wokenRequests.add(rid);
+      const wakeText = `\u26A1 Incoming overlay service request!
+
+Service: ${event.serviceId}
+From: ${event.from}
+Paid: ${event.satoshisReceived || "?"} sats
+
+Fulfill it now:
+1. overlay({ action: "pending-requests" })
+2. Process the request
+3. overlay({ action: "fulfill", requestId: "${event.id}", recipientKey: "${event.from}", serviceId: "${event.serviceId}", result: { ... } })`;
+      wakeAgent(wakeText, api.logger, port, token, { sessionKey: `hook:openclaw-overlay:${rid}` });
+    }
+    if (event.type === "service-response" && event.action === "received") {
+      const wakeText = `\u{1F4EC} Overlay service response received!
+
+Service: ${event.serviceId}
+From: ${event.from}
+Status: ${event.status}
+
+Full result:
+${JSON.stringify(event.result, null, 2)}`;
+      wakeAgent(wakeText, api.logger, port, token, { sessionKey: `hook:openclaw-overlay:resp-${event.requestId || Date.now()}` });
     }
+  }, abortController.signal).catch((err) => {
+    if (serviceRunning && !abortController?.signal.aborted) {
+      api.logger?.error?.(`[openclaw-overlay] WebSocket error: ${err.message}`);
+    }
+  });
+}
+function stopBackgroundService() {
+  serviceRunning = false;
+  if (abortController) {
+    abortController.abort();
+    abortController = null;
+  }
+  if (requestCleanupInterval) {
+    clearInterval(requestCleanupInterval);
+    requestCleanupInterval = null;
+  }
+  wokenRequests.clear();
+  if (autoImportInterval) {
+    clearInterval(autoImportInterval);
+    autoImportInterval = null;
+  }
+}
+function register(api) {
+  const version = "0.8.17";
+  if (isInitialized) return;
+  isInitialized = true;
+  api.logger?.info?.(`[openclaw-overlay] Initializing Plugin v${version}`);
+  const entries = api.getConfig?.()?.plugins?.entries || {};
+  const entry = entries["openclaw-overlay-plugin"] || entries["openclaw-overlay"] || {};
+  const pluginConfig = { ...entry, ...entry.config || {}, ...api.config || {} };
+  api.registerTool({
+    name: "overlay",
+    description: "Access the BSV agent marketplace",
+    parameters: {
+      type: "object",
+      properties: {
+        action: { type: "string", enum: ["request", "discover", "balance", "status", "pay", "onboard", "pending-requests", "fulfill", "unregister"] },
+        service: { type: "string" },
+        input: { type: "object" },
+        identityKey: { type: "string" },
+        sats: { type: "number" },
+        requestId: { type: "string" },
+        recipientKey: { type: "string" },
+        serviceId: { type: "string" },
+        result: { type: "object" }
+      },
+      required: ["action"]
+    },
+    async execute(_id, params) {
+      log3("Executing tool action: %s with params: %O", params.action, params);
+      try {
+        return await executeOverlayAction(params, pluginConfig, api);
+      } catch (error) {
+        return { content: [{ type: "text", text: `Error: ${error.message}` }] };
+      }
+    }
+  });
+  api.registerCommand({
+    name: "overlay",
+    description: "BSV Overlay Marketplace commands",
+    acceptsArgs: true,
+    handler: async (ctx) => {
+      try {
+        api.logger?.info?.(`[openclaw-overlay] Command received with args: ${JSON.stringify(ctx.args)} (type: ${typeof ctx.args})`);
+        const args = Array.isArray(ctx.args) ? ctx.args : typeof ctx.args === "string" ? ctx.args.split(" ").filter(Boolean) : [];
+        const action = args[0] || "status";
+        const result = await executeOverlayAction({ action }, pluginConfig, api);
+        return { text: `**Overlay ${action.toUpperCase()}**
+
+${typeof result === "string" ? result : JSON.stringify(result, null, 2)}` };
+      } catch (error) {
+        return { text: `\u274C Error: ${error.message}` };
+      }
+    }
+  });
+  api.registerService({
+    id: "openclaw-overlay-relay",
+    start: async () => {
+      try {
+        await initializeServiceSystem();
+      } catch {
+      }
+      const gatewayPort = process["env"].OPENCLAW_GATEWAY_PORT || "18789";
+      const httpToken = process["env"].OPENCLAW_HOOKS_TOKEN || "";
+      await startBackgroundService(pluginConfig, api, gatewayPort, httpToken);
+      await startAutoImport(pluginConfig, api, gatewayPort, httpToken);
+    },
+    stop: () => stopBackgroundService()
+  });
+  api.registerCli(({ program }) => {
+    const overlay = program.command("overlay").description("BSV Overlay Network management");
+    overlay.command("status").description("Show identity and balance").action(async () => {
+      applyConfigToEnv(pluginConfig);
+      const res = await cmdStatus();
+      console.log(JSON.stringify(res.data, null, 2));
+    });
+    overlay.command("balance").description("Show current wallet balance").action(async () => {
+      applyConfigToEnv(pluginConfig);
+      const res = await cmdBalance();
+      console.log(JSON.stringify(res.data, null, 2));
+    });
+    overlay.command("discover").description("Find agents and services").option("-s, --service <type>", "Filter by service type").option("-a, --agent <name>", "Filter by agent name").action(async (options) => {
+      applyConfigToEnv(pluginConfig);
+      const args = [];
+      if (options.service) args.push("--service", options.service);
+      if (options.agent) args.push("--agent", options.agent);
+      const res = await cmdDiscover(args);
+      console.log(JSON.stringify(res.data, null, 2));
+    });
+  }, { commands: ["overlay"] });
+}
+async function executeOverlayAction(params, config, api) {
+  const { action } = params;
+  applyConfigToEnv(config);
+  switch (action) {
+    case "request": {
+      const { service, input } = params;
+      const walletDir = config?.walletDir || path4.join(os2.homedir(), ".openclaw", "bsv-wallet");
+      const discoverOutput = await cmdDiscover(["--service", service]);
+      const providers = discoverOutput.data.services;
+      if (!providers || providers.length === 0) throw new Error(`No providers found for ${service}`);
+      providers.sort((a, b) => (a.pricing?.amountSats || 0) - (b.pricing?.amountSats || 0));
+      const best = providers[0];
+      const price = best.pricing?.amountSats || 0;
+      const budget = checkBudget(walletDir, price, config.dailyBudgetSats || 5e3);
+      if (!budget.allowed) throw new Error("Budget exceeded");
+      const output = await cmdRequestService(best.identityKey, service, price.toString(), input ? JSON.stringify(input) : void 0);
+      recordSpend(walletDir, price, service, best.name);
+      return { status: "sent", requestId: output.data?.messageId, message: `Request sent to ${best.name} for ${price} sats.` };
+    }
+    case "discover":
+      return (await cmdDiscover(params.service ? ["--service", params.service] : [])).data;
+    case "balance":
+      return (await cmdBalance()).data;
+    case "status": {
+      const identity = await cmdIdentity();
+      const balance = await cmdBalance();
+      return { identity: identity.data, balance: balance.data };
+    }
+    case "onboard": {
+      await cmdSetup();
+      const addr = (await cmdAddress()).data.address;
+      const bal = (await cmdBalance()).data.walletBalance;
+      if (bal < 1e3) return { funded: false, address: addr, message: "Please fund 1000 sats." };
+      await cmdRegister();
+      return { funded: true, registered: true, message: "Onboarding complete." };
+    }
+    case "pending-requests":
+      return (await cmdServiceQueue()).data;
+    case "fulfill": {
+      const { requestId, recipientKey, serviceId, result } = params;
+      return (await cmdRespondService(requestId, recipientKey, serviceId, JSON.stringify(result))).data;
+    }
+    case "unregister":
+      return (await cmdUnregister()).data;
+    default:
+      throw new Error(`Unknown action: ${action}`);
+  }
 }
-export const plugin = {
-    id: "openclaw-overlay-plugin",
-    name: "BSV Overlay Network",
-    description: "OpenClaw Overlay — decentralized agent marketplace with BSV micropayments",
-    activate: register,
-    register: register
+var plugin = {
+  id: "openclaw-overlay-plugin",
+  name: "BSV Overlay Network",
+  description: "OpenClaw Overlay \u2014 decentralized agent marketplace with BSV micropayments",
+  activate: register,
+  register
+};
+var index_default = register;
+export {
+  index_default as default,
+  plugin,
+  register
 };
-export default register;
+//# sourceMappingURL=index.js.map