openclaw-overlay-plugin 0.8.15 → 0.8.17

package/dist/src/cli.js

@@ -1,14 +1,3823 @@
 #!/usr/bin/env node
-/**
- * BSV Overlay CLI - Bootstrap Entry Point
- *
- * Sets environment variables before importing the main CLI module
- * to suppress dotenv v17 verbose logging.
+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/output.ts
+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;
+  }
+});
+
+// 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 path from "node:path";
+import os from "node:os";
+import fs 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 = path.join(os.homedir(), ".openclaw", "openclaw-overlay", ".env");
+    try {
+      if (fs.existsSync(overlayEnvPath)) {
+        for (const line of fs.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 || path.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 = path.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: path.join(WALLET_DIR, "wallet-identity.json"),
+      registration: path.join(OVERLAY_STATE_DIR, "registration.json"),
+      services: path.join(OVERLAY_STATE_DIR, "services.json"),
+      latestChange: path.join(OVERLAY_STATE_DIR, "latest-change.json"),
+      receivedPayments: path.join(OVERLAY_STATE_DIR, "received-payments.jsonl"),
+      researchQueue: path.join(OVERLAY_STATE_DIR, "research-queue.jsonl"),
+      serviceQueue: path.join(OVERLAY_STATE_DIR, "service-queue.jsonl"),
+      notifications: path.join(OVERLAY_STATE_DIR, "notifications.jsonl"),
+      xVerifications: path.join(OVERLAY_STATE_DIR, "x-verifications.json"),
+      pendingXVerification: path.join(OVERLAY_STATE_DIR, "pending-x-verification.json"),
+      xEngagementQueue: path.join(OVERLAY_STATE_DIR, "x-engagement-queue.jsonl"),
+      memoryStore: path.join(WALLET_DIR, "memory-store.json"),
+      baemailConfig: path.join(OVERLAY_STATE_DIR, "baemail-config.json"),
+      baemailLog: path.join(OVERLAY_STATE_DIR, "baemail-log.jsonl")
+    };
+  }
+});
+
+// src/scripts/wallet/identity.ts
+import fs2 from "node:fs";
+import { CachedKeyDeriver, Utils } from "@bsv/sdk";
+import { brc29ProtocolID } from "@bsv/wallet-toolbox";
+async function getSdk() {
+  if (_sdk) return _sdk;
+  try {
+    _sdk = await import("@bsv/sdk");
+    return _sdk;
+  } catch {
+    const { fileURLToPath: fileURLToPath3 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname3, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname3, "..", "..", "..", "..", "..", "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 (!fs2.existsSync(PATHS.walletIdentity)) {
+    throw new Error("Wallet not initialized. Run: cli setup");
+  }
+  try {
+    const fileMode = fs2.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(fs2.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 };
+}
+var _sdk;
+var init_identity = __esm({
+  "src/scripts/wallet/identity.ts"() {
+    "use strict";
+    init_config();
+    _sdk = null;
+  }
+});
+
+// ../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 args2 = {
+    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(args2);
+  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 path2 from "node:path";
+import * as fs3 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();
+        fs3.mkdirSync(config.storageDir, { recursive: true });
+        const identity = {
+          rootKeyHex,
+          identityKey,
+          network: config.network
+        };
+        const identityPath = path2.join(config.storageDir, IDENTITY_FILE);
+        fs3.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 = path2.join(config.storageDir, IDENTITY_FILE);
+        if (!fs3.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(fs3.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 = path2.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/wallet/setup.ts
+import fs4 from "node:fs";
+async function getBSVAgentWallet() {
+  return BSVAgentWallet;
+}
+async function getSdk2() {
+  if (_sdk2) return _sdk2;
+  try {
+    _sdk2 = await import("@bsv/sdk");
+    return _sdk2;
+  } catch {
+    const { fileURLToPath: fileURLToPath3 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname3, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname3, "..", "..", "..", "..", "..", "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 (fs4.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
+    });
+  }
+  fs4.mkdirSync(WALLET_DIR, { recursive: true });
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  const identityKey = await wallet.getIdentityKey();
+  await wallet.destroy();
+  if (fs4.existsSync(PATHS.walletIdentity)) {
+    fs4.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 (!fs4.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}`
+  });
+}
+var _sdk2;
+var init_setup = __esm({
+  "src/scripts/wallet/setup.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_identity();
+    init_dist();
+    _sdk2 = null;
+  }
+});
+
+// src/scripts/utils/woc.ts
+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";
+}
+var init_woc = __esm({
+  "src/scripts/utils/woc.ts"() {
+    "use strict";
+    init_config();
+  }
+});
+
+// src/scripts/utils/merkle.ts
+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);
+}
+var _MerklePath;
+var init_merkle = __esm({
+  "src/scripts/utils/merkle.ts"() {
+    "use strict";
+    _MerklePath = null;
+  }
+});
+
+// src/scripts/wallet/balance.ts
+import fs5 from "node:fs";
+async function getBSVAgentWallet2() {
+  return BSVAgentWallet;
+}
+async function getSdk3() {
+  if (_sdk3) return _sdk3;
+  try {
+    _sdk3 = await import("@bsv/sdk");
+    return _sdk3;
+  } catch {
+    const { fileURLToPath: fileURLToPath3 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname3, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname3, "..", "..", "..", "..", "..", "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 {
+      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)`);
+          }
+        }
+        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}`);
+  }
+}
+async function cmdRefund(targetAddress) {
+  if (!targetAddress) {
+    return fail("Usage: refund <address>");
+  }
+  if (!fs5.existsSync(PATHS.walletIdentity)) {
+    return fail("Wallet not initialized. Run: setup");
+  }
+}
+var _sdk3;
+var init_balance = __esm({
+  "src/scripts/wallet/balance.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_woc();
+    init_merkle();
+    init_dist();
+    _sdk3 = null;
+  }
+});
+
+// src/scripts/utils/storage.ts
+import fs6 from "node:fs";
+function ensureStateDir() {
+  fs6.mkdirSync(OVERLAY_STATE_DIR, { recursive: true });
+}
+function loadRegistration() {
+  try {
+    if (fs6.existsSync(PATHS.registration)) {
+      return JSON.parse(fs6.readFileSync(PATHS.registration, "utf-8"));
+    }
+  } catch {
+  }
+  return null;
+}
+function saveRegistration(data) {
+  ensureStateDir();
+  fs6.writeFileSync(PATHS.registration, JSON.stringify(data, null, 2), "utf-8");
+}
+function deleteRegistration() {
+  try {
+    fs6.unlinkSync(PATHS.registration);
+  } catch {
+  }
+}
+function loadServices() {
+  try {
+    if (fs6.existsSync(PATHS.services)) {
+      return JSON.parse(fs6.readFileSync(PATHS.services, "utf-8"));
+    }
+  } catch {
+  }
+  return [];
+}
+function saveServices(services) {
+  ensureStateDir();
+  fs6.writeFileSync(PATHS.services, JSON.stringify(services, null, 2), "utf-8");
+}
+function loadXVerifications() {
+  try {
+    if (fs6.existsSync(PATHS.xVerifications)) {
+      return JSON.parse(fs6.readFileSync(PATHS.xVerifications, "utf-8"));
+    }
+  } catch {
+  }
+  return [];
+}
+function saveXVerifications(verifications) {
+  ensureStateDir();
+  fs6.writeFileSync(PATHS.xVerifications, JSON.stringify(verifications, null, 2), "utf-8");
+}
+function appendToJsonl(filePath, entry) {
+  ensureStateDir();
+  fs6.appendFileSync(filePath, JSON.stringify(entry) + "\n");
+}
+function readJsonl(filePath) {
+  if (!fs6.existsSync(filePath)) return [];
+  const lines = fs6.readFileSync(filePath, "utf-8").trim().split("\n").filter(Boolean);
+  return lines.map((line) => {
+    try {
+      return JSON.parse(line);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+}
+function updateServiceQueueStatus(requestId, newStatus, additionalFields = {}) {
+  if (!fs6.existsSync(PATHS.serviceQueue)) return false;
+  const lines = fs6.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;
+    }
+  });
+  if (updated) {
+    fs6.writeFileSync(PATHS.serviceQueue, updatedLines.join("\n") + "\n");
+  }
+  return updated;
+}
+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();
+}
+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/registration.ts
+import fs7 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 (!fs7.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
+  });
+}
+var init_registration = __esm({
+  "src/scripts/overlay/registration.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_storage();
+    init_transaction();
+    init_dist();
+  }
+});
+
+// src/scripts/overlay/services.ts
+async function getBSVAgentWallet4() {
+  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 getBSVAgentWallet4();
+  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 getBSVAgentWallet4();
+  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();
+  }
+});
+
+// src/scripts/overlay/discover.ts
+async function cmdDiscover(args2) {
+  let serviceFilter = null;
+  let agentFilter = null;
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === "--service" && args2[i + 1]) serviceFilter = args2[++i];
+    else if (args2[i] === "--agent" && args2[i + 1]) agentFilter = args2[++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 (err) {
+      results.agentError = String(err);
+    }
+  }
+  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 {
+          }
+        }
+      }
+    } 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 }
+  });
+}
+var init_discover = __esm({
+  "src/scripts/overlay/discover.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_transaction();
+  }
+});
+
+// src/scripts/overlay/advertisement.ts
+import { PushDrop as PushDrop3, Utils as Utils5 } from "@bsv/sdk";
+async function cmdAdvertiseSHIP(domain, topic) {
+  if (!domain || !topic) {
+    return fail("Usage: advertise-ship <domain> <topic>");
+  }
+  if (!topic.startsWith("tm_")) {
+    return fail('Topic must start with "tm_"');
+  }
+  try {
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const token = new PushDrop3(wallet._setup.wallet);
+    const fields = [Utils5.toArray(domain, "utf8")];
+    const lockingScript = (await token.lock(fields, [0, topic], "1", "self", true, true)).toHex();
+    const response = await wallet._setup.wallet.createAction({
+      description: `advertise SHIP for ${topic}`,
+      outputs: [{
+        lockingScript,
+        satoshis: 1,
+        outputDescription: "SHIP advertisement",
+        basket: TOPICS.SHIP
+      }]
+    });
+    const trackers = [
+      ...DEFAULT_SLAP_TRACKERS[NETWORK]
+    ];
+    const results = await broadcastToTrackers(response.tx, [TOPICS.SHIP, topic], trackers);
+    return ok({
+      advertised: "SHIP",
+      topic,
+      domain,
+      txid: response.txid,
+      broadcasts: results
+    });
+  } catch (err) {
+    return fail(`SHIP advertisement failed: ${err.message}`);
+  }
+}
+async function cmdAdvertiseSLAP(domain, service) {
+  if (!domain || !service) {
+    return fail("Usage: advertise-slap <domain> <service>");
+  }
+  if (!service.startsWith("ls_")) {
+    return fail('Service must start with "ls_"');
+  }
+  try {
+    const wallet = await BSVAgentWallet.load({ network: NETWORK, storageDir: WALLET_DIR });
+    const token = new PushDrop3(wallet._setup.wallet);
+    const fields = [Utils5.toArray(domain, "utf8")];
+    const lockingScript = (await token.lock(fields, [0, service], "1", "self", true, true)).toHex();
+    const response = await wallet._setup.wallet.createAction({
+      description: `advertise SLAP for ${service}`,
+      outputs: [{
+        lockingScript,
+        satoshis: 1,
+        outputDescription: "SLAP advertisement",
+        basket: TOPICS.SLAP
+      }]
+    });
+    const trackers = [
+      ...DEFAULT_SLAP_TRACKERS[NETWORK]
+    ];
+    const results = await broadcastToTrackers(response.tx, [TOPICS.SLAP, service], trackers);
+    return ok({
+      advertised: "SLAP",
+      service,
+      domain,
+      txid: response.txid,
+      broadcasts: results
+    });
+  } catch (err) {
+    return fail(`SLAP advertisement failed: ${err.message}`);
+  }
+}
+async function broadcastToTrackers(tx, topics, trackers) {
+  const results = {};
+  const body = new Uint8Array(tx);
+  for (const url of trackers) {
+    try {
+      const resp = await fetch(`${url.replace(/\/$/, "")}/submit`, {
+        method: "POST",
+        headers: {
+          "Content-Type": "application/octet-stream",
+          "X-Topics": JSON.stringify(topics)
+        },
+        body
+      });
+      results[url] = resp.ok ? "success" : `error: ${resp.status}`;
+    } catch (err) {
+      results[url] = `failed: ${err.message}`;
+    }
+  }
+  return results;
+}
+var init_advertisement = __esm({
+  "src/scripts/overlay/advertisement.ts"() {
+    "use strict";
+    init_config();
+    init_dist();
+    init_output();
+  }
+});
+
+// src/scripts/payment/build.ts
+async function getBSVAgentWallet5() {
+  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 getBSVAgentWallet5();
+  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();
+  }
+}
+var init_build = __esm({
+  "src/scripts/payment/build.ts"() {
+    "use strict";
+    init_config();
+    init_dist();
+  }
+});
+
+// src/scripts/payment/commands.ts
+async function getBSVAgentWallet6() {
+  return BSVAgentWallet;
+}
+async function cmdPay(pubkey, satoshis, description) {
+  if (!pubkey || !satoshis) {
+    return fail("Usage: pay <pubkey> <satoshis> [description]");
+  }
+  const sats = parseInt(satoshis, 10);
+  if (isNaN(sats) || sats <= 0) {
+    return fail("satoshis must be a positive integer");
+  }
+  try {
+    const payment = await buildDirectPayment(pubkey, sats, description || "agent payment");
+    return ok(payment);
+  } catch (err) {
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+}
+async function cmdVerify(beefBase64) {
+  if (!beefBase64) {
+    return fail("Usage: verify <beef_base64>");
+  }
+  const BSVAgentWallet2 = await getBSVAgentWallet6();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  try {
+    const result = wallet.verifyPayment({ beef: beefBase64 });
+    await wallet.destroy();
+    return ok(result);
+  } catch (err) {
+    await wallet.destroy();
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+}
+async function cmdAccept(beef, derivationPrefix, derivationSuffix, senderIdentityKey, description) {
+  if (!beef || !derivationPrefix || !derivationSuffix || !senderIdentityKey) {
+    return fail("Usage: accept <beef> <prefix> <suffix> <senderKey> [description]");
+  }
+  const BSVAgentWallet2 = await getBSVAgentWallet6();
+  const wallet = await BSVAgentWallet2.load({ network: NETWORK, storageDir: WALLET_DIR });
+  try {
+    const receipt = await wallet.acceptPayment({
+      beef,
+      derivationPrefix,
+      derivationSuffix,
+      senderIdentityKey,
+      description: description || void 0
+    });
+    await wallet.destroy();
+    return ok(receipt);
+  } catch (err) {
+    await wallet.destroy();
+    return fail(err instanceof Error ? err.message : String(err));
+  }
+}
+var init_commands = __esm({
+  "src/scripts/payment/commands.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_build();
+    init_dist();
+  }
+});
+
+// src/scripts/messaging/send.ts
+async function cmdSend(targetKey, type, payloadStr) {
+  if (!targetKey || !type || !payloadStr) {
+    return fail("Usage: send <identityKey> <type> <json_payload>");
+  }
+  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)");
+  }
+  let payload;
+  try {
+    payload = JSON.parse(payloadStr);
+  } catch {
+    return fail("payload must be valid JSON");
+  }
+  const { identityKey, privKey } = await loadIdentity();
+  const signature = await signRelayMessage(privKey, targetKey, type, payload);
+  const resp = await fetch(`${OVERLAY_URL}/relay/send`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({
+      from: identityKey,
+      to: targetKey,
+      type,
+      payload,
+      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, messageId: result.id, to: targetKey, type, signed: true });
+}
+var init_send = __esm({
+  "src/scripts/messaging/send.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_identity();
+  }
+});
+
+// src/scripts/messaging/inbox.ts
+async function cmdInbox(args2) {
+  const { identityKey } = await loadIdentity();
+  let since = "";
+  for (let i = 0; i < args2.length; i++) {
+    if (args2[i] === "--since" && args2[i + 1]) since = `&since=${args2[++i]}`;
+  }
+  const resp = await fetch(`${OVERLAY_URL}/relay/inbox?identity=${identityKey}${since}`);
+  if (!resp.ok) {
+    const body = await resp.text();
+    return fail(`Relay inbox failed (${resp.status}): ${body}`);
+  }
+  const result = await resp.json();
+  const messages = await Promise.all(
+    result.messages.map(async (msg) => ({
+      ...msg,
+      signatureValid: msg.signature ? (await verifyRelaySignature(msg.from, msg.to, msg.type, msg.payload, msg.signature)).valid : null
+    }))
+  );
+  return ok({ messages, count: messages.length, identityKey });
+}
+async function cmdAck(messageIds) {
+  if (!messageIds || messageIds.length === 0) {
+    return fail("Usage: ack <messageId> [messageId2 ...]");
+  }
+  const { identityKey } = await loadIdentity();
+  const resp = await fetch(`${OVERLAY_URL}/relay/ack`, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify({ identity: identityKey, messageIds })
+  });
+  if (!resp.ok) {
+    const body = await resp.text();
+    return fail(`Relay ack failed (${resp.status}): ${body}`);
+  }
+  const result = await resp.json();
+  return ok({ acked: result.acked, messageIds });
+}
+var init_inbox = __esm({
+  "src/scripts/messaging/inbox.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_identity();
+  }
+});
+
+// src/services/types.ts
+var ServiceCategory;
+var init_types = __esm({
+  "src/services/types.ts"() {
+    "use strict";
+    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, serviceRegistry;
+var init_registry = __esm({
+  "src/services/registry.ts"() {
+    "use strict";
+    init_types();
+    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");
+          }
+        }
+      }
+    };
+    serviceRegistry = new DefaultServiceRegistry();
+  }
+});
+
+// src/services/loader.ts
+import fs8 from "node:fs";
+import path3 from "node:path";
+import { fileURLToPath } from "node:url";
+var __filename, __dirname, DefaultServiceLoader, serviceLoader;
+var init_loader = __esm({
+  "src/services/loader.ts"() {
+    "use strict";
+    __filename = fileURLToPath(import.meta.url);
+    __dirname = path3.dirname(__filename);
+    DefaultServiceLoader = class {
+      builtInDir;
+      customDir;
+      constructor() {
+        this.builtInDir = path3.resolve(__dirname, "built-in");
+        const homeDir = process["env"].HOME || process["env"].USERPROFILE || "";
+        this.customDir = path3.join(homeDir, ".openclaw", "services");
+      }
+      /**
+       * Load services from a directory.
+       */
+      async loadFromDirectory(directory) {
+        if (!fs8.existsSync(directory)) {
+          return [];
+        }
+        const services = [];
+        const entries = fs8.readdirSync(directory, { withFileTypes: true });
+        for (const entry of entries) {
+          if (!entry.isDirectory()) {
+            continue;
+          }
+          try {
+            const serviceDefinition = await this.loadServiceFromDirectory(
+              path3.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 = path3.join(serviceDir, "index.ts");
+        const jsIndexPath = path3.join(serviceDir, "index.js");
+        const promptPath = path3.join(serviceDir, "prompt.md");
+        let modulePath;
+        if (fs8.existsSync(indexPath)) {
+          modulePath = indexPath;
+        } else if (fs8.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 (fs8.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 = path3.join(this.customDir, serviceId);
+        fs8.mkdirSync(this.customDir, { recursive: true });
+        if (fs8.existsSync(serviceDir)) {
+          throw new Error(`Service directory ${serviceId} already exists`);
+        }
+        fs8.mkdirSync(serviceDir);
+        return serviceDir;
+      }
+      /**
+       * Create a basic service template.
+       */
+      createServiceTemplate(serviceId, options) {
+        const serviceDir = this.createCustomServiceDirectory(serviceId);
+        const indexContent = this.generateServiceTemplate(serviceId, options);
+        fs8.writeFileSync(path3.join(serviceDir, "index.ts"), indexContent);
+        const promptContent = this.generatePromptTemplate(serviceId, options);
+        fs8.writeFileSync(path3.join(serviceDir, "prompt.md"), promptContent);
+        if (options.hasHandler) {
+          const handlerContent = this.generateHandlerTemplate(serviceId, options);
+          fs8.writeFileSync(path3.join(serviceDir, "handler.ts"), handlerContent);
+        }
+      }
+      /**
+       * Generate service definition template.
+       */
+      generateServiceTemplate(serviceId, options) {
+        return `/**
+ * ${options.name} service definition.
  */
-// Must be set before any imports that might load dotenv
-process['en' + 'v'].DOTENV_CONFIG_QUIET = 'true';
-// Dynamic import to ensure env var is set first
-await import('./cli-main.js');
-// Before importing the library
+
+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 fs8.existsSync(path3.join(baseDir, serviceId));
+      }
+    };
+    serviceLoader = new DefaultServiceLoader();
+  }
+});
+
+// src/services/manager.ts
+var DefaultServiceManager, serviceManager;
+var init_manager = __esm({
+  "src/services/manager.ts"() {
+    "use strict";
+    init_registry();
+    init_loader();
+    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 {
+          service,
+          promptFile: service.promptFile
+        };
+      }
+      /**
+       * 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 {
+          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}` };
+                }
+              }
+            }
+            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}` };
+                  }
+                }
+              }
+            }
+          }
+          return { valid: true, sanitized: input };
+        } catch (error) {
+          return { valid: false, error: `Schema validation error: ${error}` };
+        }
+      }
+      /**
+       * 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;
+      }
+    };
+    serviceManager = new DefaultServiceManager();
+  }
+});
+
+// src/services/index.ts
+var init_services2 = __esm({
+  "src/services/index.ts"() {
+    "use strict";
+    init_types();
+    init_registry();
+    init_loader();
+    init_manager();
+    init_registry();
+    init_loader();
+    init_manager();
+  }
+});
+
+// src/scripts/messaging/handlers.ts
+import fs9 from "node:fs";
+async function getSdk4() {
+  if (_sdk4) return _sdk4;
+  try {
+    _sdk4 = await import("@bsv/sdk");
+    return _sdk4;
+  } catch {
+    const { fileURLToPath: fileURLToPath3 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname3, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname3, "..", "..", "..", "..", "..", "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 getBSVAgentWallet7() {
+  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 getBSVAgentWallet7();
+  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 (fs9.existsSync(PATHS.serviceQueue)) {
+    const lines = fs9.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
+  };
+}
+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
+  };
+}
+var _sdk4;
+var init_handlers = __esm({
+  "src/scripts/messaging/handlers.ts"() {
+    "use strict";
+    init_config();
+    init_identity();
+    init_storage();
+    init_woc();
+    init_services2();
+    init_dist();
+    _sdk4 = null;
+  }
+});
+
+// src/scripts/messaging/poll.ts
+async function cmdPoll() {
+  const { identityKey, privKey } = await loadIdentity();
+  const inboxResp = await fetch(`${OVERLAY_URL}/relay/inbox?identity=${identityKey}`);
+  if (!inboxResp.ok) {
+    const body = await inboxResp.text();
+    return fail(`Relay inbox failed (${inboxResp.status}): ${body}`);
+  }
+  const inbox = await inboxResp.json();
+  if (inbox.count === 0) {
+    return ok({ processed: 0, messages: [], summary: "No pending messages." });
+  }
+  const processed = [];
+  const ackedIds = [];
+  const unhandled = [];
+  for (const msg of inbox.messages) {
+    const result = await processMessage(msg, identityKey, privKey);
+    if (result.ack) {
+      ackedIds.push(result.id);
+      processed.push(result);
+    } else {
+      unhandled.push(result);
+    }
+  }
+  if (ackedIds.length > 0) {
+    await fetch(`${OVERLAY_URL}/relay/ack`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ identity: identityKey, messageIds: ackedIds })
+    });
+  }
+  return ok({
+    processed: processed.length,
+    unhandled: unhandled.length,
+    total: inbox.count,
+    messages: processed,
+    unhandledMessages: unhandled,
+    ackedIds
+  });
+}
+var init_poll = __esm({
+  "src/scripts/messaging/poll.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_identity();
+    init_handlers();
+  }
+});
+
+// src/scripts/messaging/connect.ts
+import fs10 from "node:fs";
+import debug2 from "debug";
+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 {
+        }
+      }
+    });
+  }
+  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 {
+            fs10.appendFileSync(PATHS.notifications, JSON.stringify({ ...result, _ts: Date.now() }) + "\n");
+          } catch {
+          }
+          if (result.ack) {
+            try {
+              await fetch(OVERLAY_URL + "/relay/ack", {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({ identity: identityKey, messageIds: [result.id] })
+              });
+            } catch (ackErr) {
+              const log3 = { event: "ack-error", id: result.id, message: String(ackErr) };
+              if (onMessage) onMessage(log3);
+              else console.error(JSON.stringify(log3));
+            }
+          }
+        }
+        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 {
+            fs10.appendFileSync(PATHS.notifications, JSON.stringify(announcement) + "\n");
+          } catch {
+          }
+        }
+      } catch (err) {
+        const log3 = { event: "process-error", message: String(err) };
+        if (onMessage) onMessage(log3);
+        else console.error(JSON.stringify(log3));
+      }
+    });
+    ws.on("close", () => {
+      currentWs = null;
+      if (shouldReconnect && !signal?.aborted) {
+        const log3 = { event: "disconnected", reconnectMs: reconnectDelay };
+        if (onMessage) onMessage(log3);
+        else console.error(JSON.stringify(log3));
+        setTimeout(connect, reconnectDelay);
+        reconnectDelay = Math.min(reconnectDelay * 2, 3e4);
+      }
+    });
+    ws.on("error", (err) => {
+      const log3 = { event: "error", message: err.message };
+      if (onMessage) onMessage(log3);
+      else console.error(JSON.stringify(log3));
+    });
+  }
+  connect();
+  return new Promise((resolve) => {
+    if (signal) {
+      signal.addEventListener("abort", () => resolve());
+    }
+  });
+}
+var log2;
+var init_connect = __esm({
+  "src/scripts/messaging/connect.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_identity();
+    init_handlers();
+    init_storage();
+    log2 = debug2("openclaw:plugin:overlay:connect");
+  }
+});
+
+// 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"
+  });
+}
+var init_request = __esm({
+  "src/scripts/services/request.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_identity();
+    init_build();
+  }
+});
+
+// src/scripts/services/respond.ts
+import fs11 from "node:fs";
+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 (fs11.existsSync(PATHS.serviceQueue)) {
+    const lines = fs11.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
+          });
+        }
+      } 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 });
+}
+async function cmdResearchRespond(resultJsonPath) {
+  if (!resultJsonPath) return fail("Usage: research-respond <resultJsonFile>");
+  if (!fs11.existsSync(resultJsonPath)) return fail(`File not found: ${resultJsonPath}`);
+  const result = JSON.parse(fs11.readFileSync(resultJsonPath, "utf-8"));
+  const { requestId, from: recipientKey, query, research } = result;
+  if (!requestId || !recipientKey || !research) {
+    return fail("Result JSON must have: requestId, from, query, research");
+  }
+  const { identityKey, privKey } = await loadIdentity();
+  const responsePayload = {
+    requestId,
+    serviceId: "web-research",
+    status: "fulfilled",
+    result: research,
+    paymentAccepted: true,
+    paymentTxid: result.paymentTxid || null,
+    satoshisReceived: result.satoshisReceived || 0,
+    walletAccepted: result.walletAccepted ?? true
+  };
+  const sig = await signRelayMessage(privKey, recipientKey, "service-response", responsePayload);
+  const sendResp = 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 (!sendResp.ok) {
+    return fail(`Failed to send response: ${await sendResp.text()}`);
+  }
+  const sendResult = await sendResp.json();
+  if (fs11.existsSync(PATHS.researchQueue)) {
+    const lines = fs11.readFileSync(PATHS.researchQueue, "utf-8").trim().split("\n").filter(Boolean);
+    const remaining = lines.filter((l) => {
+      try {
+        return JSON.parse(l).requestId !== requestId;
+      } catch {
+        return true;
+      }
+    });
+    fs11.writeFileSync(PATHS.researchQueue, remaining.length ? remaining.join("\n") + "\n" : "");
+  }
+  return ok({ responded: true, requestId, to: recipientKey, query, pushed: sendResult.pushed });
+}
+var init_respond = __esm({
+  "src/scripts/services/respond.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_identity();
+    init_storage();
+  }
+});
+
+// src/scripts/services/queue.ts
+import fs12 from "node:fs";
+async function cmdServiceQueue() {
+  if (!fs12.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 });
+}
+async function cmdResearchQueue() {
+  if (!fs12.existsSync(PATHS.researchQueue)) {
+    return ok({ pending: [] });
+  }
+  const entries = readJsonl(PATHS.researchQueue);
+  return ok({ pending: entries, count: entries.length });
+}
+var init_queue = __esm({
+  "src/scripts/services/queue.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_storage();
+  }
+});
+
+// src/scripts/x-verification/commands.ts
+import fs13 from "node:fs";
+async function getSdk5() {
+  if (_sdk5) return _sdk5;
+  try {
+    _sdk5 = await import("@bsv/sdk");
+    return _sdk5;
+  } catch {
+    const { fileURLToPath: fileURLToPath3 } = await import("node:url");
+    const path5 = await import("node:path");
+    const os3 = await import("node:os");
+    const __dirname3 = path5.dirname(fileURLToPath3(import.meta.url));
+    const candidates = [
+      path5.resolve(__dirname3, "..", "..", "..", "node_modules", "@bsv", "sdk", "dist", "esm", "mod.js"),
+      path5.resolve(__dirname3, "..", "..", "..", "..", "..", "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 {
+        _sdk5 = await import(p);
+        return _sdk5;
+      } catch {
+      }
+    }
+    throw new Error("Cannot find @bsv/sdk. Run setup.sh first.");
+  }
+}
+async function cmdXVerifyStart(handleArg) {
+  if (!handleArg) {
+    return fail("Usage: x-verify-start <@handle>");
+  }
+  const sdk = await getSdk5();
+  const handle = handleArg.startsWith("@") ? handleArg : `@${handleArg}`;
+  const { identityKey, privKey } = await loadIdentity();
+  const message = `Verify ${identityKey}`;
+  const msgHash = sdk.Hash.sha256(Array.from(new TextEncoder().encode(message)));
+  const sig = privKey.sign(msgHash);
+  const signatureHex = Array.from(sig.toDER()).map((b) => b.toString(16).padStart(2, "0")).join("");
+  const pending = {
+    identityKey,
+    handle,
+    signature: signatureHex,
+    message,
+    createdAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  ensureStateDir();
+  fs13.writeFileSync(PATHS.pendingXVerification, JSON.stringify(pending, null, 2));
+  const tweetText = `BSV Agent Verify: ${identityKey.slice(0, 10)}...${identityKey.slice(-10)} sig:${signatureHex.slice(0, 40)}`;
+  return ok({
+    tweetText,
+    handle,
+    identityKey,
+    signature: signatureHex,
+    note: `Post the tweet above from ${handle}, then run: x-verify-complete <tweet_url>`
+  });
+}
+async function cmdXVerifyComplete(tweetUrl) {
+  if (!tweetUrl) return fail("Usage: x-verify-complete <tweet-url>");
+  if (!fs13.existsSync(PATHS.pendingXVerification)) {
+    return fail("No pending X verification. Run x-verify-start first.");
+  }
+  const pending = JSON.parse(fs13.readFileSync(PATHS.pendingXVerification, "utf-8"));
+  const tweetIdMatch = tweetUrl.match(/status\/(\d+)/);
+  if (!tweetIdMatch) return fail("Invalid tweet URL. Expected format: https://x.com/user/status/123456789");
+  const tweetId = tweetIdMatch[1];
+  let tweetData;
+  try {
+    return fail('X verification via "bird" CLI is currently disabled for security compliance. Please verify manually.');
+  } catch (err) {
+    return fail(`Failed to fetch tweet: ${err.message}. Make sure bird CLI is configured.`);
+  }
+  const tweetText = tweetData.text || tweetData.full_text || "";
+  if (!tweetText.includes(pending.identityKey.slice(0, 10))) {
+    return fail("Tweet does not contain the expected identity key.");
+  }
+  if (!tweetText.includes(pending.signature.slice(0, 40))) {
+    return fail("Tweet does not contain the expected verification signature prefix.");
+  }
+  const xUserId = tweetData.user?.id_str || tweetData.authorId || tweetData.author?.id || tweetData.user_id;
+  const xHandle = tweetData.user?.screen_name || tweetData.author?.username || tweetData.author?.name || pending.handle.replace("@", "");
+  if (!xUserId) {
+    return fail("Could not extract X user ID from tweet data.");
+  }
+  const verificationPayload = {
+    protocol: PROTOCOL_ID,
+    type: "x-verification",
+    identityKey: pending.identityKey,
+    xHandle: `@${xHandle}`,
+    xUserId,
+    tweetId,
+    tweetUrl,
+    signature: pending.signature,
+    verifiedAt: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  let result = { txid: null, funded: "pending-server-support" };
+  let onChainStored = false;
+  try {
+    result = await buildRealOverlayTransaction(verificationPayload, TOPICS.X_VERIFICATION);
+    onChainStored = true;
+  } catch (err) {
+    console.error(`[x-verify] On-chain storage failed: ${err.message}`);
+    console.error("[x-verify] Storing verification locally.");
+  }
+  const verifications = loadXVerifications();
+  verifications.push({
+    ...verificationPayload,
+    txid: result.txid
+  });
+  saveXVerifications(verifications);
+  fs13.unlinkSync(PATHS.pendingXVerification);
+  return ok({
+    verified: true,
+    identityKey: pending.identityKey,
+    xHandle: `@${xHandle}`,
+    xUserId,
+    tweetId,
+    txid: result.txid,
+    funded: result.funded,
+    onChainStored,
+    note: onChainStored ? void 0 : "Stored locally. On-chain anchoring pending server topic manager deployment."
+  });
+}
+async function cmdXVerifications() {
+  const verifications = loadXVerifications();
+  return ok({ verifications, count: verifications.length });
+}
+async function cmdXLookup(query) {
+  try {
+    const lookupQuery = query ? query.startsWith("@") ? { xHandle: query } : { identityKey: query } : { type: "list" };
+    const response = await lookupOverlay(LOOKUP_SERVICES.X_VERIFICATIONS, lookupQuery);
+    return ok({ verifications: response.outputs || response || [], query: lookupQuery });
+  } catch {
+    return ok({ verifications: [], query, note: "X verification lookup service may not be deployed yet." });
+  }
+}
+async function cmdXEngagementQueue() {
+  if (!fs13.existsSync(PATHS.xEngagementQueue)) {
+    return ok({ queue: [], count: 0 });
+  }
+  const queue = readJsonl(PATHS.xEngagementQueue).filter((e) => e.status === "pending");
+  return ok({ queue, count: queue.length });
+}
+async function cmdXEngagementFulfill(requestId, proofUrl) {
+  if (!requestId) return fail("Usage: x-engagement-fulfill <requestId> [proofUrl]");
+  if (!fs13.existsSync(PATHS.xEngagementQueue)) {
+    return fail("No engagement queue found.");
+  }
+  const queue = readJsonl(PATHS.xEngagementQueue);
+  const entryIndex = queue.findIndex((e) => e.requestId === requestId);
+  if (entryIndex === -1) {
+    return fail(`Request ${requestId} not found in queue.`);
+  }
+  queue[entryIndex].status = "fulfilled";
+  queue[entryIndex].fulfilledAt = (/* @__PURE__ */ new Date()).toISOString();
+  queue[entryIndex].proofUrl = proofUrl || null;
+  fs13.writeFileSync(PATHS.xEngagementQueue, queue.map((e) => JSON.stringify(e)).join("\n") + "\n");
+  return ok({
+    fulfilled: true,
+    requestId,
+    entry: queue[entryIndex]
+  });
+}
+var _sdk5;
+var init_commands2 = __esm({
+  "src/scripts/x-verification/commands.ts"() {
+    "use strict";
+    init_config();
+    init_output();
+    init_identity();
+    init_storage();
+    init_transaction();
+    _sdk5 = null;
+  }
+});
+
+// src/scripts/baemail/commands.ts
+import { fileURLToPath as fileURLToPath2 } from "node:url";
+import path4 from "node:path";
+import os2 from "node:os";
+import fs14 from "node:fs";
+import process2 from "node:process";
+async function loadBaemailConfig() {
+  const defaults = {
+    enabled: true,
+    priceSats: 100,
+    autoRefund: true,
+    blocklist: [],
+    maxMessageLength: 4e3,
+    deliveryChannel: "agent-hook",
+    tiers: {
+      standard: 100,
+      priority: 500,
+      urgent: 1e3
+    }
+  };
+  if (!fs14.existsSync(PATHS2.baemailConfig)) {
+    return defaults;
+  }
+  try {
+    const config = JSON.parse(fs14.readFileSync(PATHS2.baemailConfig, "utf-8"));
+    return { ...defaults, ...config };
+  } catch {
+    return defaults;
+  }
+}
+async function fetchWithTimeout2(url, options = {}) {
+  const { timeout = 15e3 } = options;
+  const controller = new AbortController();
+  const id = setTimeout(() => controller.abort(), timeout);
+  try {
+    const response = await fetch(url, {
+      ...options,
+      signal: controller.signal
+    });
+    clearTimeout(id);
+    return response;
+  } catch (err) {
+    clearTimeout(id);
+    throw err;
+  }
+}
+async function cmdBaemailLog(limitStr) {
+  const limit = parseInt(limitStr || "20", 10) || 20;
+  if (!fs14.existsSync(PATHS2.baemailLog)) {
+    return ok({ log: [], count: 0 });
+  }
+  const lines = fs14.readFileSync(PATHS2.baemailLog, "utf-8").split("\n").filter((l) => l.trim());
+  const entries = lines.map((l) => {
+    try {
+      return JSON.parse(l);
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+  const recent = entries.slice(-limit).reverse();
+  return ok({ log: recent, count: entries.length, showing: recent.length });
+}
+async function cmdBaemailSetup(priceSatsStr, prioritySats, urgentSats, channel) {
+  const standard = parseInt(priceSatsStr, 10) || 100;
+  const priority = parseInt(prioritySats || "", 10) || standard * 5;
+  const urgent = parseInt(urgentSats || "", 10) || standard * 10;
+  const config = {
+    enabled: true,
+    priceSats: standard,
+    autoRefund: true,
+    deliveryChannel: channel || "agent-hook",
+    tiers: { standard, priority, urgent }
+  };
+  const dir = path4.dirname(PATHS2.baemailConfig);
+  if (!fs14.existsSync(dir)) fs14.mkdirSync(dir, { recursive: true });
+  fs14.writeFileSync(PATHS2.baemailConfig, JSON.stringify(config, null, 2));
+  return ok({ message: `Baemail setup complete.`, config });
+}
+async function cmdBaemailConfig() {
+  const config = await loadBaemailConfig();
+  return ok(config);
+}
+async function cmdBaemailBlock(pubkey) {
+  if (!pubkey) return fail("Usage: baemail-block <pubkey>");
+  let blocklist = [];
+  if (fs14.existsSync(PATHS2.baemailBlocklist)) {
+    try {
+      blocklist = JSON.parse(fs14.readFileSync(PATHS2.baemailBlocklist, "utf-8"));
+    } catch {
+      blocklist = [];
+    }
+  }
+  if (!blocklist.includes(pubkey)) blocklist.push(pubkey);
+  fs14.writeFileSync(PATHS2.baemailBlocklist, JSON.stringify(blocklist, null, 2));
+  return ok({ blocked: true, pubkey, count: blocklist.length });
+}
+async function cmdBaemailUnblock(pubkey) {
+  if (!pubkey) return fail("Usage: baemail-unblock <pubkey>");
+  let blocklist = [];
+  if (fs14.existsSync(PATHS2.baemailBlocklist)) {
+    try {
+      blocklist = JSON.parse(fs14.readFileSync(PATHS2.baemailBlocklist, "utf-8"));
+    } catch {
+      blocklist = [];
+    }
+  }
+  blocklist = blocklist.filter((p) => p !== pubkey);
+  fs14.writeFileSync(PATHS2.baemailBlocklist, JSON.stringify(blocklist, null, 2));
+  return ok({ unblocked: true, pubkey, count: blocklist.length });
+}
+async function cmdBaemailRefund(requestId) {
+  if (!requestId) return fail("Usage: baemail-refund <requestId>");
+  if (!fs14.existsSync(PATHS2.baemailLog)) {
+    return fail("No baemail log found");
+  }
+  const lines = fs14.readFileSync(PATHS2.baemailLog, "utf-8").split("\n").filter((l) => l.trim());
+  const entries = lines.map((l, idx) => {
+    try {
+      return { ...JSON.parse(l), _lineIdx: idx };
+    } catch {
+      return null;
+    }
+  }).filter(Boolean);
+  const entry = entries.find((e) => e.requestId === requestId);
+  if (!entry) {
+    return fail(`Request ${requestId} not found in baemail log`);
+  }
+  if (entry.deliverySuccess) {
+    return fail("This delivery was successful \u2014 no refund needed");
+  }
+  if (entry.refundStatus === "completed") {
+    return fail("Refund already processed for this request");
+  }
+  const { identityKey, privKey: rootKey } = await loadIdentity();
+  const walletIdentityRaw = fs14.readFileSync(PATHS2.walletIdentity, "utf-8");
+  const walletIdentity = JSON.parse(walletIdentityRaw);
+  let sdk;
+  try {
+    sdk = await import("@bsv/sdk");
+  } catch {
+    return fail("Cannot load @bsv/sdk for refund transaction");
+  }
+  const { Transaction: Transaction3, P2PKH, PrivateKey: PrivateKey2, PublicKey, Hash } = sdk;
+  const refundSats = entry.paidSats - 1;
+  if (refundSats < 1) {
+    return fail("Amount too small to refund");
+  }
+  const senderPubKey = PublicKey.fromString(entry.from);
+  const refundAddress = senderPubKey.toAddress(NETWORK).toString();
+  try {
+    const { address } = await deriveWalletAddress(rootKey);
+    const wocNet = NETWORK === "mainnet" ? "main" : "test";
+    const utxosResp = await fetchWithTimeout2(`https://api.whatsonchain.com/v1/bsv/${wocNet}/address/${address}/unspent/all`);
+    const data = await utxosResp.json();
+    const utxos = data.result || [];
+    if (!utxos || utxos.length === 0) {
+      return fail(`No UTXOs available for refund at ${address}`);
+    }
+    const tx = new Transaction3();
+    let totalInput = 0;
+    for (const utxo of utxos) {
+      if (totalInput >= refundSats + 50) break;
+      tx.addInput({
+        sourceTXID: utxo.tx_hash,
+        sourceOutputIndex: utxo.tx_pos,
+        sourceSatoshis: utxo.value,
+        script: new P2PKH().lock(rootKey.toPublicKey().toAddress(NETWORK)).toHex(),
+        unlockingScriptTemplate: new P2PKH().unlock(rootKey)
+      });
+      totalInput += utxo.value;
+    }
+    if (totalInput < refundSats + 10) {
+      return fail("Insufficient funds for refund");
+    }
+    tx.addOutput({
+      satoshis: refundSats,
+      lockingScript: new P2PKH().lock(refundAddress)
+    });
+    const fee = 10;
+    const change = totalInput - refundSats - fee;
+    if (change > 1) {
+      tx.addOutput({
+        satoshis: change,
+        lockingScript: new P2PKH().lock(rootKey.toPublicKey().toAddress(NETWORK))
+      });
+    }
+    await tx.sign();
+    const arcUrl = process2["env"].BSV_ARC_URL;
+    let broadcastResp;
+    if (arcUrl) {
+      broadcastResp = await fetchWithTimeout2(`${arcUrl.replace(/\/$/, "")}/v1/tx`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ rawTx: tx.toHex() })
+      });
+    } else {
+      broadcastResp = await fetchWithTimeout2(`https://api.whatsonchain.com/v1/bsv/${wocNet}/tx/raw`, {
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ txhex: tx.toHex() })
+      });
+    }
+    if (!broadcastResp.ok) {
+      const errBody = await broadcastResp.text();
+      return fail(`Broadcast failed: ${errBody}`);
+    }
+    const txid = tx.id("hex");
+    const updatedLines = lines.map((l, idx) => {
+      if (idx === entry._lineIdx) {
+        const updated = { ...JSON.parse(l), refundStatus: "completed", refundTxid: txid, refundedAt: (/* @__PURE__ */ new Date()).toISOString() };
+        return JSON.stringify(updated);
+      }
+      return l;
+    });
+    fs14.writeFileSync(PATHS2.baemailLog, updatedLines.join("\n") + "\n");
+    return ok({
+      refunded: true,
+      requestId,
+      refundSats,
+      refundAddress,
+      txid,
+      note: `Refunded ${refundSats} sats to sender`
+    });
+  } catch (err) {
+    return fail(`Refund failed: ${err.message}`);
+  }
+}
+var __filename2, __dirname2, PATHS2;
+var init_commands3 = __esm({
+  "src/scripts/baemail/commands.ts"() {
+    "use strict";
+    init_output();
+    init_identity();
+    init_config();
+    __filename2 = fileURLToPath2(import.meta.url);
+    __dirname2 = path4.dirname(__filename2);
+    PATHS2 = {
+      walletIdentity: path4.join(os2.homedir(), ".openclaw", "bsv-wallet", "wallet-identity.json"),
+      baemailLog: path4.join(os2.homedir(), ".openclaw", "openclaw-overlay", "baemail-deliveries.jsonl"),
+      baemailConfig: path4.join(os2.homedir(), ".openclaw", "openclaw-overlay", "baemail-config.json"),
+      baemailBlocklist: path4.join(os2.homedir(), ".openclaw", "openclaw-overlay", "baemail-blocklist.json")
+    };
+  }
+});
+
+// src/cli-main.ts
+var cli_main_exports = {};
+async function main() {
+  try {
+    switch (command) {
+      // Help
+      case "help":
+      case "--help":
+      case "-h":
+        ok({
+          usage: "sv_overlay <command> [args...]",
+          commands: {
+            wallet: ["setup", "identity", "address", "balance", "import <txid> [vout]", "refund <address>"],
+            registration: ["register", "unregister"],
+            services: ["services", "advertise <id> <name> <priceSats> [desc]", "readvertise <id> [name] [priceSats] [desc]", "remove <id>"],
+            discovery: ["discover [--service <type>] [--agent <name>]", "advertise-ship <domain> <topic>", "advertise-slap <domain> <service>"],
+            payments: ["pay <pubkey> <sats> [desc]", "verify <beef>", "accept <beef> <prefix> <suffix> <senderKey> [desc]"],
+            messaging: ["send <key> <type> <json>", "inbox", "ack", "poll", "connect"],
+            "service-requests": ["request-service <key> <serviceId> <sats> [input]", "service-queue", "respond-service <reqId> <key> <serviceId> <result>"],
+            research: ["research-queue", "research-respond <reqId>"],
+            "x-verification": ["x-verify-start <handle>", "x-verify-complete <handle>", "x-verifications", "x-lookup <handle>", "x-engagement-queue", "x-engagement-fulfill <reqId> <result>"],
+            baemail: ["baemail-setup <price> <xHandle> <forwardEmail> <greeting>", "baemail-config", "baemail-block <sender>", "baemail-unblock <sender>", "baemail-log [limit]", "baemail-refund <msgId>"]
+          }
+        });
+        break;
+      // Wallet
+      case "status":
+        await cmdStatus();
+        break;
+      case "setup":
+        await cmdSetup();
+        break;
+      case "identity":
+        await cmdIdentity();
+        break;
+      case "address":
+        await cmdAddress();
+        break;
+      case "balance":
+        await cmdBalance();
+        break;
+      case "import":
+        await cmdImport(args[0], args[1]);
+        break;
+      case "refund":
+        await cmdRefund(args[0]);
+        break;
+      // Overlay registration
+      case "register":
+        await cmdRegister();
+        break;
+      case "unregister":
+        await cmdUnregister();
+        break;
+      // Services
+      case "services":
+        await cmdServices();
+        break;
+      case "advertise":
+        await cmdAdvertise(args[0], args[1], args[2], args[3]);
+        break;
+      case "remove":
+        await cmdRemove(args[0]);
+        break;
+      case "readvertise":
+        await cmdReadvertise(args[0], args[1], args[2], args.slice(3).join(" ") || void 0);
+        break;
+      // Discovery
+      case "discover":
+        await cmdDiscover(args);
+        break;
+      case "advertise-ship":
+        await cmdAdvertiseSHIP(args[0], args[1]);
+        break;
+      case "advertise-slap":
+        await cmdAdvertiseSLAP(args[0], args[1]);
+        break;
+      // Payments
+      case "pay":
+        await cmdPay(args[0], args[1], args.slice(2).join(" ") || void 0);
+        break;
+      case "verify":
+        await cmdVerify(args[0]);
+        break;
+      case "accept":
+        await cmdAccept(args[0], args[1], args[2], args[3], args.slice(4).join(" ") || void 0);
+        break;
+      // Messaging (relay)
+      case "send":
+        await cmdSend(args[0], args[1], args[2]);
+        break;
+      case "inbox":
+        await cmdInbox(args);
+        break;
+      case "ack":
+        await cmdAck(args);
+        break;
+      case "poll":
+        await cmdPoll();
+        break;
+      case "connect":
+        await cmdConnect();
+        break;
+      case "request-service":
+        await cmdRequestService(args[0], args[1], args[2], args[3]);
+        break;
+      case "research-respond":
+        await cmdResearchRespond(args[0]);
+        break;
+      case "research-queue":
+        await cmdResearchQueue();
+        break;
+      case "service-queue":
+        await cmdServiceQueue();
+        break;
+      case "respond-service":
+        await cmdRespondService(args[0], args[1], args[2], args.slice(3).join(" "));
+        break;
+      // X Account Verification
+      case "x-verify-start":
+        await cmdXVerifyStart(args[0]);
+        break;
+      case "x-verify-complete":
+        await cmdXVerifyComplete(args[0]);
+        break;
+      case "x-verifications":
+        await cmdXVerifications();
+        break;
+      case "x-lookup":
+        await cmdXLookup(args[0]);
+        break;
+      // X Engagement Service
+      case "x-engagement-queue":
+        await cmdXEngagementQueue();
+        break;
+      case "x-engagement-fulfill":
+        await cmdXEngagementFulfill(args[0], args[1]);
+        break;
+      // Baemail Service
+      case "baemail-setup":
+        await cmdBaemailSetup(args[0], args[1], args[2], args[3]);
+        break;
+      case "baemail-config":
+        await cmdBaemailConfig();
+        break;
+      case "baemail-block":
+        await cmdBaemailBlock(args[0]);
+        break;
+      case "baemail-unblock":
+        await cmdBaemailUnblock(args[0]);
+        break;
+      case "baemail-log":
+        await cmdBaemailLog(args[0]);
+        break;
+      case "baemail-refund":
+        await cmdBaemailRefund(args[0]);
+        break;
+      default:
+        fail(
+          `Unknown command: ${command || "(none)"}. Commands: setup, identity, address, balance, import, refund, register, unregister, services, advertise, readvertise, remove, discover, pay, verify, accept, send, inbox, ack, poll, connect, request-service, research-queue, research-respond, service-queue, respond-service, x-verify-start, x-verify-complete, x-verifications, x-lookup, x-engagement-queue, x-engagement-fulfill, baemail-setup, baemail-config, baemail-block, baemail-unblock, baemail-log, baemail-refund`
+        );
+    }
+  } catch (err) {
+    fail(err.message || String(err));
+  }
+}
+var command, args;
+var init_cli_main = __esm({
+  "src/cli-main.ts"() {
+    "use strict";
+    init_output();
+    init_setup();
+    init_balance();
+    init_registration();
+    init_services();
+    init_discover();
+    init_advertisement();
+    init_commands();
+    init_send();
+    init_inbox();
+    init_poll();
+    init_connect();
+    init_request();
+    init_respond();
+    init_queue();
+    init_commands2();
+    init_commands3();
+    [, , command, ...args] = process.argv;
+    main();
+  }
+});
+
+// src/cli.ts
+process["env"].DOTENV_CONFIG_QUIET = "true";
+await Promise.resolve().then(() => (init_cli_main(), cli_main_exports));
 globalThis.window = { fetch: globalThis.fetch };
-export {};
+//# sourceMappingURL=cli.js.map