@vapi-network/core 0.7.0 → 0.8.0

package/dist/cloud-backup.js

@@ -3947,7 +3947,7 @@ function weierstrass(curveDef) {
   function prepSig(msgHash, privateKey, opts = defaultSigOpts) {
     if (["recovered", "canonical"].some((k) => k in opts))
       throw new Error("sign() legacy options not supported");
-    const { hash: hash2, randomBytes: randomBytes4 } = CURVE;
+    const { hash: hash2, randomBytes: randomBytes7 } = CURVE;
     let { lowS, prehash, extraEntropy: ent } = opts;
     if (lowS == null)
       lowS = true;
@@ -3959,7 +3959,7 @@ function weierstrass(curveDef) {
     const d = normPrivateKeyToScalar(privateKey);
     const seedArgs = [int2octets(d), int2octets(h1int)];
     if (ent != null && ent !== false) {
-      const e = ent === true ? randomBytes4(Fp.BYTES) : ent;
+      const e = ent === true ? randomBytes7(Fp.BYTES) : ent;
       seedArgs.push(ensureBytes("extraEntropy", e));
     }
     const seed = concatBytes3(...seedArgs);
@@ -4273,13 +4273,14 @@ var init_secp256k1 = __esm({
 });
 
 // src/cloud-backup.ts
-import { join as join3 } from "node:path";
+import { join as join9 } from "node:path";
 
 // src/backup.ts
 import {
   createCipheriv as createCipheriv2,
   createDecipheriv as createDecipheriv2,
-  createHash,
+  createHash as createHash2,
+  createHmac,
   createPrivateKey,
   createPublicKey,
   diffieHellman,
@@ -4288,8 +4289,18 @@ import {
   scrypt as scrypt2,
   timingSafeEqual
 } from "node:crypto";
-import { link, lstat, mkdir as mkdir2, mkdtemp, open as openFile, rm as rm2 } from "node:fs/promises";
-import { join as join2 } from "node:path";
+import {
+  chmod as chmod2,
+  link as link2,
+  lstat,
+  mkdir as mkdir8,
+  mkdtemp,
+  open as openFile,
+  readFile as readFile9,
+  readdir as readdir5,
+  rm as rm2
+} from "node:fs/promises";
+import { dirname as dirname5, join as join8 } from "node:path";
 
 // ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/accounts/utils/publicKeyToAddress.js
 init_getAddress();
@@ -5332,6 +5343,7 @@ function serializeSignature({ r, s, to = "hex", v, yParity }) {
 
 // ../../node_modules/.pnpm/viem@2.56.1_typescript@6.0.3_zod@4.5.4/node_modules/viem/_esm/index.js
 init_getAddress();
+init_isAddress();
 
 // ../../node_modules/.pnpm/@scure+bip32@1.7.0/node_modules/@scure/bip32/lib/esm/index.js
 init_modular();
@@ -45490,6 +45502,263 @@ function date4(params) {
   return _coercedDate(ZodDate, params);
 }
 
+// src/agent-profile.ts
+import { mkdir as mkdir3, readFile as readFile3, readdir as readdir2, rename as rename3, unlink as unlink2, writeFile as writeFile2 } from "node:fs/promises";
+import { join as join4 } from "node:path";
+
+// src/config.ts
+import { constants } from "node:fs";
+import { copyFile, mkdir as mkdir2, readFile as readFile2, rename as rename2, stat as stat2, writeFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname as dirname2, join as join3 } from "node:path";
+
+// src/atomic-file.ts
+import { randomBytes as randomBytes2 } from "node:crypto";
+import { link, mkdir, open as open2, readdir, readFile, rename, stat, unlink } from "node:fs/promises";
+import { basename, dirname, join as join2 } from "node:path";
+var DEFAULT_LOCK_TIMEOUT_MS = 2e3;
+var LOCK_RETRY_MS = 20;
+var LOCK_STALE_AFTER_MS = 12e4;
+var LOCK_HEARTBEAT_MS = 3e4;
+var atomicFileTestHooks;
+var FileLockedError = class extends Error {
+  constructor(message = "Timed out waiting for the file lock.") {
+    super(message);
+    this.name = "FileLockedError";
+  }
+};
+async function writeJsonAtomic(path, value, options = {}) {
+  const directory = dirname(path);
+  await mkdir(directory, { recursive: true, mode: 448 });
+  const temporaryPath = join2(
+    directory,
+    `.${basename(path)}.${process.pid}.${randomBytes2(6).toString("hex")}.tmp`
+  );
+  let handle;
+  try {
+    handle = await open2(temporaryPath, "wx", options.mode ?? 384);
+    await handle.writeFile(`${JSON.stringify(value, null, 2)}
+`, "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await rename(temporaryPath, path);
+    const directoryHandle = await open2(directory, "r");
+    try {
+      await directoryHandle.sync();
+    } finally {
+      await directoryHandle.close();
+    }
+  } catch (error61) {
+    await handle?.close().catch(() => void 0);
+    await unlink(temporaryPath).catch(() => void 0);
+    throw error61;
+  }
+}
+async function withFileLock(lockPath, fn, options = {}) {
+  await mkdir(dirname(lockPath), { recursive: true, mode: 448 });
+  const deadline = Date.now() + (options.timeoutMs ?? DEFAULT_LOCK_TIMEOUT_MS);
+  const ownerRecord = {
+    pid: process.pid,
+    token: randomBytes2(16).toString("hex")
+  };
+  const owner = JSON.stringify(ownerRecord);
+  const releasedOwner = JSON.stringify({ ...ownerRecord, released: true });
+  let handle;
+  while (handle === void 0) {
+    await atomicFileTestHooks?.beforeLockAttempt?.(lockPath);
+    try {
+      const candidate = await open2(lockPath, "wx", 384);
+      try {
+        await candidate.writeFile(owner, "utf8");
+        await candidate.sync();
+        await atomicFileTestHooks?.afterLockCreate?.(lockPath);
+        if (await lockTakeoverInProgress(lockPath)) {
+          await candidate.close();
+          await removeOwnedLock(lockPath, [owner]);
+          await removeAbandonedLockTombs(lockPath);
+          if (Date.now() >= deadline) {
+            throw new FileLockedError(options.lockedMessage);
+          }
+          await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+          continue;
+        }
+        handle = candidate;
+      } catch (error61) {
+        await candidate.close().catch(() => void 0);
+        await removeOwnedLock(lockPath, [owner]).catch(() => void 0);
+        throw error61;
+      }
+    } catch (error61) {
+      if (!hasCode(error61, "EEXIST")) throw error61;
+      await removeStaleLock(lockPath);
+      if (Date.now() >= deadline) {
+        throw new FileLockedError(options.lockedMessage);
+      }
+      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+    }
+  }
+  const ownedHandle = handle;
+  const heartbeat = setInterval(() => {
+    const time3 = /* @__PURE__ */ new Date();
+    void ownedHandle.utimes(time3, time3).catch(() => void 0);
+  }, LOCK_HEARTBEAT_MS);
+  heartbeat.unref();
+  try {
+    return await fn();
+  } finally {
+    clearInterval(heartbeat);
+    try {
+      await markLockReleased(ownedHandle, releasedOwner);
+    } finally {
+      try {
+        await ownedHandle.close();
+      } finally {
+        await removeOwnedLock(lockPath, [owner, releasedOwner]);
+      }
+    }
+  }
+}
+async function removeStaleLock(path) {
+  try {
+    const owner = await readFile(path, "utf8");
+    if (lockOwnerReleased(owner)) {
+      await removeOwnedLock(path, [owner]);
+      return;
+    }
+    const metadata = await stat(path);
+    if (Date.now() - metadata.mtimeMs <= LOCK_STALE_AFTER_MS) return;
+    const pid = lockOwnerPid(owner);
+    if (pid !== void 0 && processIsAlive(pid)) return;
+    await atomicFileTestHooks?.beforeStaleLockBreak?.(path);
+    await removeOwnedLock(path, [owner]);
+  } catch (error61) {
+    if (!hasCode(error61, "ENOENT")) throw error61;
+  }
+}
+async function removeOwnedLock(path, owners) {
+  const tombPath = `${path}.stale.${randomBytes2(16).toString("hex")}`;
+  try {
+    await rename(path, tombPath);
+  } catch (error61) {
+    if (hasCode(error61, "ENOENT")) {
+      await removeOwnedTombs(path, owners);
+      const currentOwner = await readFile(path, "utf8").catch(() => void 0);
+      if (currentOwner !== void 0 && owners.includes(currentOwner)) {
+        await removeOwnedLock(path, owners);
+      }
+      return;
+    }
+    throw error61;
+  }
+  let pendingError;
+  try {
+    const renamedOwner = await readFile(tombPath, "utf8");
+    if (!owners.includes(renamedOwner) && !lockOwnerReleased(renamedOwner)) {
+      await atomicFileTestHooks?.afterMismatchedLockRename?.(path);
+      const currentOwner = await readFile(tombPath, "utf8");
+      if (!lockOwnerReleased(currentOwner)) await restoreRenamedLock(path, tombPath);
+      await atomicFileTestHooks?.afterMismatchedLockRestore?.(path);
+    }
+  } catch (error61) {
+    pendingError = error61;
+  }
+  try {
+    await unlink(tombPath);
+  } catch (error61) {
+    if (!hasCode(error61, "ENOENT") && pendingError === void 0) {
+      pendingError = error61;
+    }
+  }
+  if (pendingError !== void 0) throw pendingError;
+}
+async function lockTakeoverInProgress(path) {
+  const prefix = `${basename(path)}.stale.`;
+  return (await readdir(dirname(path))).some((entry) => entry.startsWith(prefix));
+}
+async function removeAbandonedLockTombs(path) {
+  const directory = dirname(path);
+  const prefix = `${basename(path)}.stale.`;
+  for (const entry of await readdir(directory)) {
+    if (!entry.startsWith(prefix)) continue;
+    const tombPath = join2(directory, entry);
+    const [metadata, owner] = await Promise.all([
+      stat(tombPath).catch(() => void 0),
+      readFile(tombPath, "utf8").catch(() => void 0)
+    ]);
+    if (metadata === void 0 || owner === void 0) continue;
+    const pid = lockOwnerPid(owner);
+    const abandoned = lockOwnerReleased(owner) || Date.now() - metadata.mtimeMs > LOCK_STALE_AFTER_MS && (pid === void 0 || !processIsAlive(pid));
+    if (!abandoned) continue;
+    await unlink(tombPath).catch((error61) => {
+      if (!hasCode(error61, "ENOENT")) throw error61;
+    });
+  }
+}
+async function removeOwnedTombs(path, owners) {
+  const directory = dirname(path);
+  const prefix = `${basename(path)}.stale.`;
+  for (const entry of await readdir(directory)) {
+    if (!entry.startsWith(prefix)) continue;
+    const tombPath = join2(directory, entry);
+    const owner = await readFile(tombPath, "utf8").catch(() => void 0);
+    if (owner === void 0 || !owners.includes(owner)) continue;
+    await unlink(tombPath).catch((error61) => {
+      if (!hasCode(error61, "ENOENT")) throw error61;
+    });
+  }
+}
+async function restoreRenamedLock(path, tombPath) {
+  while (true) {
+    try {
+      await link(tombPath, path);
+      return;
+    } catch (error61) {
+      if (hasCode(error61, "ENOENT")) return;
+      if (!hasCode(error61, "EEXIST")) throw error61;
+      await new Promise((resolve) => setTimeout(resolve, LOCK_RETRY_MS));
+    }
+  }
+}
+async function markLockReleased(handle, owner) {
+  const contents = Buffer.from(owner, "utf8");
+  await handle.write(contents, 0, contents.length, 0);
+  await handle.truncate(contents.length);
+  await handle.sync();
+}
+function lockOwnerPid(owner) {
+  try {
+    const value = JSON.parse(owner);
+    if (typeof value !== "object" || value === null) return void 0;
+    const pid = Reflect.get(value, "pid");
+    return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function lockOwnerReleased(owner) {
+  try {
+    const value = JSON.parse(owner);
+    return typeof value === "object" && value !== null && Reflect.get(value, "released") === true;
+  } catch {
+    return false;
+  }
+}
+function processIsAlive(pid) {
+  if (atomicFileTestHooks?.isProcessAlive !== void 0) {
+    return atomicFileTestHooks.isProcessAlive(pid);
+  }
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error61) {
+    return hasCode(error61, "EPERM");
+  }
+}
+function hasCode(error61, code) {
+  return error61 instanceof Error && "code" in error61 && error61.code === code;
+}
+
 // src/x402-networks.ts
 var BASE_MAINNET_CAIP2 = "eip155:8453";
 var ARC_MAINNET_CAIP2 = "eip155:5042";
@@ -45793,6 +46062,14 @@ function parseEip155ChainId(network) {
 function isSolanaNetwork(network) {
   return network === SOLANA_MAINNET_CAIP2 || network === X402_SOLANA_MAINNET_CAIP2;
 }
+function explorerTransactionUrl(network, hash2) {
+  try {
+    const explorerUrl = getNetworkDefinition(network).explorerUrl;
+    return explorerUrl ? `${explorerUrl}/tx/${hash2}` : void 0;
+  } catch {
+    return void 0;
+  }
+}
 function isSupportedPaymentNetwork(network) {
   if (isSolanaNetwork(network)) return true;
   try {
@@ -45802,15 +46079,37 @@ function isSupportedPaymentNetwork(network) {
     return false;
   }
 }
+function getNetworkDefinition(network) {
+  const known = NETWORKS[network];
+  if (known) {
+    return known;
+  }
+  const chainId = parseEip155ChainId(network);
+  return {
+    family: "evm",
+    chainId,
+    name: network,
+    usdc: getAddress("0x0000000000000000000000000000000000000000"),
+    gasToken: "ETH",
+    rpcEnv: ""
+  };
+}
 
 // src/config.ts
 var DEFAULT_REGISTRY_URL = "https://api.vapinetwork.ai";
 var DEFAULT_DISCOVERY_URL = `${DEFAULT_REGISTRY_URL}/api/call/services`;
 var DEFAULT_MARKETPLACE_DISCOVERY_URL = `${DEFAULT_REGISTRY_URL}/api/call/discovery`;
+var DEFAULT_REGISTRY_FALLBACKS = [
+  {
+    discoveryUrl: DEFAULT_DISCOVERY_URL,
+    marketplaceDiscoveryUrl: DEFAULT_MARKETPLACE_DISCOVERY_URL
+  }
+];
 var DEFAULT_SPEND_CAPS = {
   perCallAtomic: "100000",
   perDayAtomic: "1000000"
 };
+var DEFAULT_CEILING_ATOMIC = 5000000n;
 var atomicString = external_exports.string().regex(/^\d+$/, "Expected non-negative atomic units.");
 var spendCapsSchema = external_exports.object({
   perCallAtomic: atomicString,
@@ -45873,9 +46172,339 @@ var configSchema = external_exports.object({
     }
   }
 });
+function getVapiPaths(directory = process.env.VAPI_HOME?.trim() || join3(homedir(), ".vapi")) {
+  return {
+    directory,
+    agentsDir: join3(directory, "agents"),
+    config: join3(directory, "config.json"),
+    keystore: join3(directory, "keystore.json"),
+    receipts: join3(directory, "receipts.jsonl"),
+    searches: join3(directory, "searches.jsonl"),
+    ledger: join3(directory, "spend-ledger.json")
+  };
+}
+async function migrateLegacyVapiHome(options = {}) {
+  const target = getVapiPaths(options.targetDirectory);
+  const legacyDirectory = options.legacyDirectory ?? join3(homedir(), ".vapi", "agent-cash");
+  if (legacyDirectory === target.directory || !await pathExists(legacyDirectory)) return [];
+  await mkdir2(target.directory, { recursive: true, mode: 448 });
+  const copied = [];
+  for (const filename of [
+    "config.json",
+    "keystore.json",
+    "receipts.jsonl",
+    "searches.jsonl",
+    "spend-ledger.json"
+  ]) {
+    const source = join3(legacyDirectory, filename);
+    const destination = join3(target.directory, filename);
+    try {
+      const copy = async () => await copyFile(source, destination, constants.COPYFILE_EXCL);
+      if (filename === "receipts.jsonl") {
+        await withFileLock(`${destination}.lock`, copy, {
+          lockedMessage: "The receipt journal is busy. Wait for the other vapi command to finish, then retry."
+        });
+      } else {
+        await copy();
+      }
+      copied.push(destination);
+    } catch (error61) {
+      if (isMissingFile(error61) || isAlreadyExists(error61)) continue;
+      throw error61;
+    }
+  }
+  if (copied.length > 0) {
+    const message = `Migrated legacy vAPI wallet files from ${legacyDirectory} to ${target.directory}; originals were kept.`;
+    (options.notice ?? ((value) => process.stderr.write(`${value}
+`)))(message);
+  }
+  return copied;
+}
+var LEGACY_REGISTRY_HOSTS = /* @__PURE__ */ new Map([
+  ["console.vapinetwork.ai", "api.vapinetwork.ai"],
+  ["console-staging.vapinetwork.ai", "api-staging.vapinetwork.ai"]
+]);
+var LEGACY_REGISTRY_PATHS = /* @__PURE__ */ new Map([
+  ["/api/network/services", "/api/call/services"],
+  ["/api/marketplace/discovery", "/api/call/discovery"]
+]);
+var REGISTRY_DOMAIN = "vapinetwork.ai";
+function rewriteLegacyRegistryUrl(value) {
+  let url2;
+  try {
+    url2 = new URL(value);
+  } catch {
+    return value;
+  }
+  let rewritten = false;
+  const host = LEGACY_REGISTRY_HOSTS.get(url2.hostname.toLowerCase());
+  if (host) {
+    url2.hostname = host;
+    rewritten = true;
+  }
+  const hostname3 = url2.hostname.toLowerCase();
+  if (hostname3 === REGISTRY_DOMAIN || hostname3.endsWith(`.${REGISTRY_DOMAIN}`)) {
+    const path = LEGACY_REGISTRY_PATHS.get(url2.pathname.replace(/\/+$/, ""));
+    if (path) {
+      url2.pathname = path;
+      rewritten = true;
+    }
+  }
+  return rewritten ? url2.href : value;
+}
+function rewriteLegacyRegistryUrls(config2) {
+  const changes = [];
+  const rewrite = (field, from) => {
+    const to = rewriteLegacyRegistryUrl(from);
+    if (to !== from) changes.push({ field, from, to });
+    return to;
+  };
+  const next = {
+    ...config2,
+    discoveryUrl: rewrite("discoveryUrl", config2.discoveryUrl),
+    marketplaceDiscoveryUrl: rewrite("marketplaceDiscoveryUrl", config2.marketplaceDiscoveryUrl),
+    ...config2.registryFallbacks ? {
+      registryFallbacks: config2.registryFallbacks.map((fallback, index) => ({
+        discoveryUrl: rewrite(
+          `registryFallbacks[${index}].discoveryUrl`,
+          fallback.discoveryUrl
+        ),
+        marketplaceDiscoveryUrl: rewrite(
+          `registryFallbacks[${index}].marketplaceDiscoveryUrl`,
+          fallback.marketplaceDiscoveryUrl
+        )
+      }))
+    } : {}
+  };
+  return changes.length === 0 ? { config: config2, changes } : { config: next, changes };
+}
+function formatLegacyRegistryRewrites(changes) {
+  return [
+    "Rewrote retired vAPI registry URLs in the local config:",
+    ...changes.map((change) => `  ${change.field}: ${change.from} -> ${change.to}`)
+  ].join("\n");
+}
+function getDefaultConfig(source = process.env, options = {}) {
+  const registry2 = registryEndpoints(source.VAPI_REGISTRY_URL?.trim() || DEFAULT_REGISTRY_URL);
+  const requested = new Set(options.networks ?? ["base"]);
+  const networks = {};
+  if (requested.has("base") || requested.has(BASE_MAINNET_CAIP2)) {
+    networks[BASE_MAINNET_CAIP2] = {
+      rpcUrl: source.BASE_RPC_URL?.trim() || NETWORKS[BASE_MAINNET_CAIP2].publicRpcUrl,
+      usdc: NETWORKS[BASE_MAINNET_CAIP2].usdc
+    };
+  }
+  const arcMainnetRpcUrl = source.ARC_RPC_URL?.trim();
+  if (arcMainnetRpcUrl || requested.has("arc") || requested.has(ARC_MAINNET_CAIP2)) {
+    networks[ARC_MAINNET_CAIP2] = {
+      rpcUrl: arcMainnetRpcUrl || NETWORKS[ARC_MAINNET_CAIP2].publicRpcUrl,
+      usdc: NETWORKS[ARC_MAINNET_CAIP2].usdc
+    };
+  }
+  const arcTestnetRpcUrl = source.ARC_TESTNET_RPC_URL?.trim();
+  if (arcTestnetRpcUrl || requested.has("arc-testnet") || requested.has(ARC_TESTNET_CAIP2)) {
+    if (!arcTestnetRpcUrl) {
+      throw new Error(
+        "Arc testnet RPC is required. Set ARC_TESTNET_RPC_URL before enabling Arc testnet."
+      );
+    }
+    networks[ARC_TESTNET_CAIP2] = {
+      rpcUrl: arcTestnetRpcUrl,
+      usdc: NETWORKS[ARC_TESTNET_CAIP2].usdc
+    };
+  }
+  const solanaRpcUrl = source.SOLANA_RPC_URL?.trim();
+  if (solanaRpcUrl || requested.has("solana") || requested.has(SOLANA_MAINNET_CAIP2)) {
+    networks[SOLANA_MAINNET_CAIP2] = {
+      rpcUrl: solanaRpcUrl || NETWORKS[SOLANA_MAINNET_CAIP2].publicRpcUrl,
+      usdc: NETWORKS[SOLANA_MAINNET_CAIP2].usdc
+    };
+  }
+  return {
+    discoveryUrl: source.VAPI_DISCOVERY_URL?.trim() || registry2.discoveryUrl,
+    marketplaceDiscoveryUrl: source.VAPI_MARKETPLACE_DISCOVERY_URL?.trim() || registry2.marketplaceDiscoveryUrl,
+    registryFallbacks: DEFAULT_REGISTRY_FALLBACKS.map((fallback) => ({ ...fallback })),
+    allowPrivateNetwork: false,
+    networks,
+    spendCaps: { ...DEFAULT_SPEND_CAPS }
+  };
+}
+async function loadConfig(path = getVapiPaths().config, source = process.env, options = {}) {
+  if (!process.env.VAPI_HOME?.trim() && path === getVapiPaths(join3(homedir(), ".vapi")).config) {
+    await migrateLegacyVapiHome({ targetDirectory: join3(homedir(), ".vapi") });
+  }
+  let raw;
+  try {
+    raw = await readFile2(path, "utf8");
+  } catch (error61) {
+    if (isMissingFile(error61)) return getDefaultConfig(source);
+    throw error61;
+  }
+  const parsed = configSchema.parse(JSON.parse(raw));
+  parsed.registryFallbacks ??= DEFAULT_REGISTRY_FALLBACKS.map((fallback) => ({ ...fallback }));
+  const migrated = rewriteLegacyRegistryUrls(parsed);
+  const config2 = migrated.config;
+  if (migrated.changes.length > 0 && options.notice) {
+    options.notice(
+      `${formatLegacyRegistryRewrites(migrated.changes)}
+Run vapi init to write the new URLs to ${path}.`
+    );
+  }
+  const baseRpcUrl = source.BASE_RPC_URL?.trim();
+  const arcMainnetRpcUrl = source.ARC_RPC_URL?.trim();
+  const arcTestnetRpcUrl = source.ARC_TESTNET_RPC_URL?.trim();
+  const solanaRpcUrl = source.SOLANA_RPC_URL?.trim();
+  const discoveryUrl = source.VAPI_DISCOVERY_URL?.trim();
+  const marketplaceDiscoveryUrl = source.VAPI_MARKETPLACE_DISCOVERY_URL?.trim();
+  const registryUrl = source.VAPI_REGISTRY_URL?.trim();
+  if (config2.networks[BASE_MAINNET_CAIP2] && baseRpcUrl) {
+    config2.networks[BASE_MAINNET_CAIP2].rpcUrl = baseRpcUrl;
+  }
+  if (arcMainnetRpcUrl) {
+    const existing = config2.networks[ARC_MAINNET_CAIP2];
+    config2.networks[ARC_MAINNET_CAIP2] = {
+      ...existing ?? { usdc: NETWORKS[ARC_MAINNET_CAIP2].usdc },
+      rpcUrl: arcMainnetRpcUrl
+    };
+  }
+  if (arcTestnetRpcUrl) {
+    const existing = config2.networks[ARC_TESTNET_CAIP2];
+    config2.networks[ARC_TESTNET_CAIP2] = {
+      ...existing ?? { usdc: NETWORKS[ARC_TESTNET_CAIP2].usdc },
+      rpcUrl: arcTestnetRpcUrl
+    };
+  }
+  if (solanaRpcUrl) {
+    config2.networks[SOLANA_MAINNET_CAIP2] = {
+      rpcUrl: solanaRpcUrl,
+      usdc: config2.networks[SOLANA_MAINNET_CAIP2]?.usdc ?? NETWORKS[SOLANA_MAINNET_CAIP2].usdc
+    };
+  }
+  if (registryUrl) {
+    const registry2 = registryEndpoints(registryUrl);
+    config2.discoveryUrl = registry2.discoveryUrl;
+    config2.marketplaceDiscoveryUrl = registry2.marketplaceDiscoveryUrl;
+  }
+  if (discoveryUrl) config2.discoveryUrl = discoveryUrl;
+  if (marketplaceDiscoveryUrl) config2.marketplaceDiscoveryUrl = marketplaceDiscoveryUrl;
+  for (const [network, configured] of Object.entries(config2.networks)) {
+    configured.rpcUrl = configured.rpcUrl.trim();
+    configured.usdc = configured.usdc.trim();
+    if (isSolanaNetwork(network) && configured.usdc !== NETWORKS[SOLANA_MAINNET_CAIP2].usdc) {
+      throw new Error(`Network ${network} must use canonical Solana mainnet USDC.`);
+    }
+    if (!configured.rpcUrl) delete config2.networks[network];
+  }
+  return config2;
+}
+function registryEndpoints(baseUrl) {
+  const base = new URL(baseUrl);
+  base.search = "";
+  base.hash = "";
+  const prefix = base.pathname === "/" ? "" : base.pathname.replace(/\/+$/, "");
+  const discovery = new URL(base);
+  discovery.pathname = `${prefix}/api/call/services`;
+  const marketplace = new URL(base);
+  marketplace.pathname = `${prefix}/api/call/discovery`;
+  return { discoveryUrl: discovery.href, marketplaceDiscoveryUrl: marketplace.href };
+}
+async function pathExists(path) {
+  try {
+    await stat2(path);
+    return true;
+  } catch (error61) {
+    if (isMissingFile(error61)) return false;
+    throw error61;
+  }
+}
+function isMissingFile(error61) {
+  return error61 instanceof Error && "code" in error61 && error61.code === "ENOENT";
+}
+function isAlreadyExists(error61) {
+  return error61 instanceof Error && "code" in error61 && error61.code === "EEXIST";
+}
+
+// src/wallet-name.ts
+var DEFAULT_WALLET_NAME = "main";
+var WALLET_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+var walletNameSchema = external_exports.string().regex(
+  WALLET_NAME_PATTERN,
+  "A wallet name is 1 to 32 characters of lowercase letters, digits and dashes, starting with a letter or digit."
+);
+
+// src/agent-profile.ts
+var DEFAULT_AGENT_TOOLS = ["call.search", "call.inspect", "call.pay"];
+var AGENT_GRANTS = ["read", "delegate", "allocate"];
+var agentProfileShape = {
+  version: external_exports.literal(1),
+  name: walletNameSchema,
+  wallet: external_exports.string(),
+  model: external_exports.string().min(1),
+  instructions: external_exports.string().max(2e4),
+  verifiedOnly: external_exports.boolean().default(true),
+  approveAboveUsd: external_exports.number().min(0).default(0.5),
+  maxSteps: external_exports.number().int().min(1).max(50).default(12),
+  paused: external_exports.boolean().default(false),
+  grants: external_exports.array(external_exports.enum(AGENT_GRANTS)).default([]),
+  createdAt: external_exports.string()
+};
+function createAgentProfileSchema(toolNames) {
+  if (toolNames.length === 0) {
+    throw new Error("Agent profiles require at least one registered tool.");
+  }
+  const tools = [...toolNames];
+  return external_exports.object({ ...agentProfileShape, tools: external_exports.array(external_exports.enum(tools)).default(tools) });
+}
+var agentProfileSchema = createAgentProfileSchema(DEFAULT_AGENT_TOOLS);
+async function listAgentProfiles(home, options = {}) {
+  const directory = getVapiPaths(home).agentsDir;
+  let files;
+  try {
+    files = await readdir2(directory);
+  } catch (error61) {
+    if (isMissingFile(error61)) return [];
+    throw error61;
+  }
+  const warn = options.warn ?? ((message) => console.warn(message));
+  const profiles = [];
+  for (const file2 of files) {
+    if (!file2.endsWith(".json")) continue;
+    try {
+      profiles.push(
+        (options.schema ?? agentProfileSchema).parse(
+          JSON.parse(await readFile3(join4(directory, file2), "utf8"))
+        )
+      );
+    } catch {
+      options.onInvalid?.(file2);
+      warn(`Skipping invalid agent profile ${file2}.`);
+    }
+  }
+  profiles.sort((left, right) => left.name < right.name ? -1 : left.name > right.name ? 1 : 0);
+  return profiles;
+}
+
+// src/device.ts
+import { hostname as operatingSystemHostname } from "node:os";
+var DEVICE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
+function normalizedDeviceName(value) {
+  return value.toLowerCase().replace(/[^a-z0-9-]/gu, "-").replace(/-+/gu, "-").replace(/^-+|-+$/gu, "").slice(0, 32).replace(/-+$/gu, "");
+}
+function slugifyDeviceName(value) {
+  return normalizedDeviceName(value) || "device";
+}
+function deviceName(args = {}) {
+  const environmentValue = args.env === void 0 ? process.env.VAPI_DEVICE : args.env.VAPI_DEVICE;
+  for (const value of [environmentValue?.trim(), args.config?.device]) {
+    if (value === void 0 || value.length === 0) continue;
+    const normalized = normalizedDeviceName(value);
+    if (normalized.length > 0) return normalized;
+  }
+  return slugifyDeviceName(args.hostname ?? operatingSystemHostname());
+}
 
 // src/keystore.ts
-import { createCipheriv, createDecipheriv, randomBytes as randomBytes2, scrypt } from "node:crypto";
+import { createCipheriv, createDecipheriv, randomBytes as randomBytes3, scrypt } from "node:crypto";
 var SCRYPT_N = 2 ** 15;
 var SCRYPT_R = 8;
 var SCRYPT_P = 1;
@@ -45950,7 +46579,7 @@ function encryptWithKey(key, plaintext) {
   if (key.byteLength !== KEY_LENGTH) {
     throw new Error(`Expected a ${KEY_LENGTH}-byte AES-256-GCM key.`);
   }
-  const nonce = randomBytes2(12);
+  const nonce = randomBytes3(12);
   const cipher = createCipheriv("aes-256-gcm", key, nonce, {
     authTagLength: AUTH_TAG_LENGTH
   });
@@ -46038,20 +46667,517 @@ function deriveEvmPrivateKey(seed, path = EVM_DERIVATION_PATH) {
   return `0x${Buffer.from(privateKey).toString("hex")}`;
 }
 
-// src/wallet-name.ts
-var WALLET_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
-var walletNameSchema = external_exports.string().regex(
-  WALLET_NAME_PATTERN,
-  "A wallet name is 1 to 32 characters of lowercase letters, digits and dashes, starting with a letter or digit."
-);
+// src/movement.ts
+import { randomBytes as randomBytes6 } from "node:crypto";
+import { chmod, mkdir as mkdir7, open as open6, readFile as readFile7, readdir as readdir3, rename as rename5, unlink as unlink6 } from "node:fs/promises";
+import { join as join6 } from "node:path";
+
+// src/account-movement-lock.ts
+import { randomBytes as randomBytes4 } from "node:crypto";
+import { mkdir as mkdir4, open as open3, readFile as readFile4, stat as stat3, unlink as unlink3 } from "node:fs/promises";
+import { join as join5 } from "node:path";
+var AccountMovementLockedError = class extends Error {
+  constructor(account) {
+    super(`Another capital movement is already running for account ${account}.`);
+    this.account = account;
+    this.name = "AccountMovementLockedError";
+  }
+  account;
+  code = "account_movement_locked";
+};
+async function withAccountMovementLock(home, account, timeoutMs, operation, signal) {
+  const directory = join5(home, "movements");
+  await mkdir4(directory, { recursive: true, mode: 448 });
+  const path = join5(directory, `.${account}.lock`);
+  const deadline = Date.now() + (timeoutMs ?? 2e3);
+  const owner = JSON.stringify({ pid: process.pid, token: randomBytes4(16).toString("hex") });
+  let handle;
+  while (handle === void 0) {
+    signal?.throwIfAborted();
+    try {
+      handle = await open3(path, "wx", 384);
+      await handle.writeFile(owner, "utf8");
+      await handle.sync();
+    } catch (error61) {
+      if (!(error61 instanceof Error && "code" in error61 && error61.code === "EEXIST")) throw error61;
+      await removeStaleLock2(path);
+      if (Date.now() >= deadline) throw new AccountMovementLockedError(account);
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+  const ownedHandle = handle;
+  const heartbeat = setInterval(() => {
+    const time3 = /* @__PURE__ */ new Date();
+    void ownedHandle.utimes(time3, time3).catch(() => void 0);
+  }, 3e4);
+  heartbeat.unref();
+  try {
+    return await operation();
+  } finally {
+    clearInterval(heartbeat);
+    await ownedHandle.close();
+    await unlinkOwnedLock(path, owner);
+  }
+}
+async function withAccountMovementLocks(home, accounts, timeoutMs, operation) {
+  return await acquireAccountMovementLocks(
+    home,
+    [...new Set(accounts)].sort(),
+    timeoutMs,
+    operation
+  );
+}
+async function acquireAccountMovementLocks(home, accounts, timeoutMs, operation) {
+  const [account, ...remaining] = accounts;
+  if (account === void 0) return await operation();
+  return await withAccountMovementLock(
+    home,
+    account,
+    timeoutMs,
+    async () => acquireAccountMovementLocks(home, remaining, timeoutMs, operation)
+  );
+}
+async function removeStaleLock2(path) {
+  try {
+    const metadata = await stat3(path);
+    if (Date.now() - metadata.mtimeMs <= 12e4) return;
+    const owner = await readFile4(path, "utf8").catch(() => "");
+    const pid = lockOwnerPid2(owner);
+    if (pid !== void 0 && processIsAlive2(pid)) return;
+    await unlinkOwnedLock(path, owner);
+  } catch (error61) {
+    if (!isMissingFile(error61)) throw error61;
+  }
+}
+async function unlinkOwnedLock(path, owner) {
+  try {
+    if (await readFile4(path, "utf8") === owner) await unlink3(path);
+  } catch (error61) {
+    if (!isMissingFile(error61)) throw error61;
+  }
+}
+function lockOwnerPid2(owner) {
+  try {
+    const value = JSON.parse(owner);
+    if (typeof value !== "object" || value === null) return void 0;
+    const pid = Reflect.get(value, "pid");
+    return typeof pid === "number" && Number.isSafeInteger(pid) && pid > 0 ? pid : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function processIsAlive2(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch (error61) {
+    return error61 instanceof Error && "code" in error61 && error61.code === "EPERM";
+  }
+}
+
+// src/agent-run.ts
+var RUN_ID_PATTERN = /^run_[0-9a-f]{24}$/;
+var runRefSchema = external_exports.strictObject({
+  id: external_exports.string().regex(RUN_ID_PATTERN),
+  swarm: external_exports.string().optional(),
+  member: external_exports.string().optional(),
+  parentRunId: external_exports.string().optional()
+});
+
+// src/receipts.ts
+var RECEIPT_JOURNAL_BUSY_MESSAGE = "The receipt journal is busy. Wait for the other vapi command to finish, then retry.";
+async function withReceiptJournalLock(path, operation) {
+  return await withFileLock(`${path}.lock`, operation, {
+    lockedMessage: RECEIPT_JOURNAL_BUSY_MESSAGE
+  });
+}
+var durationSchema = external_exports.number().nonnegative().finite();
+var receiptSchema = external_exports.strictObject({
+  id: external_exports.string().min(1),
+  timestamp: external_exports.iso.datetime(),
+  run: runRefSchema.optional(),
+  kind: external_exports.literal("transfer").optional(),
+  wallet: walletNameSchema.optional(),
+  resourceUrl: external_exports.url(),
+  method: external_exports.string().min(1).optional(),
+  source: external_exports.string().min(1).optional(),
+  provenance: external_exports.array(
+    external_exports.strictObject({
+      source: external_exports.string().min(1),
+      sourceUrl: external_exports.string().optional(),
+      ref: external_exports.string().optional()
+    })
+  ).optional(),
+  quote: external_exports.strictObject({
+    network: external_exports.string(),
+    asset: external_exports.string().optional(),
+    amountAtomic: external_exports.string().regex(/^\d+$/),
+    payTo: external_exports.string().optional()
+  }).optional(),
+  payer: external_exports.string().optional(),
+  paymentId: external_exports.string().regex(/^[A-Za-z0-9_-]{16,128}$/).optional(),
+  authorization: external_exports.strictObject({
+    from: external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/),
+    nonce: external_exports.string().regex(/^0x[0-9a-fA-F]{64}$/),
+    validBefore: external_exports.string().regex(/^\d+$/)
+  }).optional(),
+  transfer: external_exports.strictObject({
+    to: external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/),
+    toName: external_exports.string().min(1),
+    toKind: external_exports.enum(["owner", "account"]),
+    amountAtomic: external_exports.string().regex(/^\d+$/),
+    network: external_exports.string().min(1),
+    nonce: external_exports.string().regex(/^0x[0-9a-fA-F]{64}$/),
+    status: external_exports.enum(["sent", "unknown", "failed"]),
+    txHash: external_exports.string().regex(/^0x[0-9a-fA-F]+$/).nullable(),
+    replayed: external_exports.boolean(),
+    reservedOn: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/).optional(),
+    request: external_exports.strictObject({
+      authorization: external_exports.strictObject({
+        from: external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/),
+        to: external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/),
+        value: external_exports.string().regex(/^\d+$/),
+        validAfter: external_exports.string().regex(/^\d+$/),
+        validBefore: external_exports.string().regex(/^\d+$/),
+        nonce: external_exports.string().regex(/^0x[0-9a-fA-F]{64}$/)
+      }),
+      signature: external_exports.string().regex(/^0x[0-9a-fA-F]+$/)
+    }).optional()
+  }).optional(),
+  settlement: external_exports.strictObject({
+    outcome: external_exports.enum(["succeeded", "rejected", "unknown"]),
+    transaction: external_exports.string().optional(),
+    explorerUrl: external_exports.url().optional(),
+    evidence: external_exports.unknown().optional()
+  }).optional(),
+  latencyMs: external_exports.number().nonnegative().finite().optional(),
+  status: external_exports.number().int().min(100).max(599).optional(),
+  error: external_exports.strictObject({ code: external_exports.string(), message: external_exports.string() }).optional(),
+  phases: external_exports.strictObject({
+    discoverMs: durationSchema.optional(),
+    quoteMs: durationSchema.optional(),
+    signMs: durationSchema.optional(),
+    requestMs: durationSchema.optional(),
+    settleMs: durationSchema.optional()
+  }).optional(),
+  listing: external_exports.strictObject({
+    name: external_exports.string().min(1).optional(),
+    providerHost: external_exports.string().min(1).optional(),
+    source: external_exports.string().min(1)
+  }).optional(),
+  retry: external_exports.number().int().nonnegative().optional(),
+  policy: external_exports.strictObject({
+    maxPriceUsd: external_exports.string().regex(/^\d+(?:\.\d{1,6})?$/).optional(),
+    capsApplied: external_exports.boolean()
+  }).optional(),
+  client: external_exports.strictObject({ name: external_exports.literal("vapi-network"), version: external_exports.string().min(1) }).optional(),
+  outcome: external_exports.enum([
+    "paid",
+    "signed_in",
+    "declined_policy",
+    "failed_request",
+    "settlement_rejected",
+    "settlement_unknown"
+  ]).optional()
+});
+function parseReceipt(value) {
+  const receipt = receiptSchema.parse(value);
+  const transaction = receipt.settlement?.transaction;
+  const network = receipt.quote?.network;
+  const explorerUrl = transaction === void 0 || network === void 0 ? void 0 : explorerTransactionUrl(network, transaction);
+  if (explorerUrl === void 0 || receipt.settlement?.explorerUrl === explorerUrl) {
+    return receipt;
+  }
+  return {
+    ...receipt,
+    settlement: {
+      outcome: receipt.settlement.outcome,
+      ...receipt.settlement.transaction ? { transaction: receipt.settlement.transaction } : {},
+      explorerUrl,
+      ...receipt.settlement.evidence === void 0 ? {} : { evidence: receipt.settlement.evidence }
+    }
+  };
+}
+function receiptWallet(receipt) {
+  return receipt.wallet ?? DEFAULT_WALLET_NAME;
+}
+
+// src/agent-link.ts
+import { createHash } from "node:crypto";
+import { mkdir as mkdir5, open as open4, stat as stat4, unlink as unlink4 } from "node:fs/promises";
+import { dirname as dirname3 } from "node:path";
+var AGENT_LINK_REVOKED_MESSAGE = "This agent's link was revoked or has expired. Run vapi login to link it again.";
+var REMOTE_AGENT_TOKEN_EXPIRED_MESSAGE = "The Railway run's short-lived vAPI access token expired. Start a new Railway run from the owner machine.";
+var AgentLinkError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "AgentLinkError";
+  }
+  code;
+};
+var DEFAULT_AGENT_SCOPES = ["mcp:call", "router.use"];
+var ALLOWED_AGENT_SCOPES = /* @__PURE__ */ new Set([...DEFAULT_AGENT_SCOPES, "call.publish"]);
+var publicFetch = createPublicFetch({ allowPrivateNetwork: false });
+var agentSecretAccounts = (wallet) => ({
+  tokens: `vapi.agent.${wallet}.tokens`,
+  routerStake: `vapi.agent.${wallet}.router.stake`,
+  routerBalance: `vapi.agent.${wallet}.router.balance`
+});
+async function agentFetch(args, url2, init) {
+  const fetchImpl = args.fetchImpl ?? publicFetch;
+  const accessToken = await resolveAgentAccessToken(args, {});
+  const response = await safeAgentFetch(fetchImpl, url2, withBearer(init, accessToken));
+  if (response.status !== 401) return response;
+  const refreshedToken = await resolveAgentAccessToken(args, { rejectedAccessToken: accessToken });
+  const refreshedResponse = await safeAgentFetch(fetchImpl, url2, withBearer(init, refreshedToken));
+  if (refreshedResponse.status === 401) {
+    throw new AgentLinkError("not_linked", AGENT_LINK_REVOKED_MESSAGE);
+  }
+  return refreshedResponse;
+}
+async function resolveAgentAccessToken(args, options) {
+  await args.wallets.reload();
+  const link3 = args.wallets.entry(args.wallet)?.link;
+  if (link3 === void 0 || !args.secrets.available) throw notLinkedError();
+  const accounts = agentSecretAccounts(args.wallet);
+  const tokens = parseTokens(await safeGetSecret(args.secrets, accounts.tokens));
+  if (tokens === void 0) throw notLinkedError();
+  const now = args.now ?? Date.now;
+  if (options.rejectedAccessToken === void 0 && tokens.expiresAt - 6e4 > now()) {
+    return tokens.accessToken;
+  }
+  return await withAgentCredentialLock(args.wallets, link3.clientId, async () => {
+    await args.wallets.reload();
+    const currentLink = args.wallets.entry(args.wallet)?.link;
+    if (currentLink === void 0) throw notLinkedError();
+    const currentAccounts = agentSecretAccounts(args.wallet);
+    const current = parseTokens(await safeGetSecret(args.secrets, currentAccounts.tokens));
+    if (current === void 0) throw notLinkedError();
+    if (options.rejectedAccessToken !== void 0 && current.accessToken !== options.rejectedAccessToken) {
+      return current.accessToken;
+    }
+    if (options.rejectedAccessToken === void 0 && current.expiresAt - 6e4 > now()) {
+      return current.accessToken;
+    }
+    if (current.refreshToken === void 0) {
+      throw new AgentLinkError("not_linked", REMOTE_AGENT_TOKEN_EXPIRED_MESSAGE);
+    }
+    const response = await safeFetch(
+      args.fetchImpl ?? publicFetch,
+      apiEndpoint(currentLink.apiBase, "/oauth/token"),
+      {
+        method: "POST",
+        headers: { "content-type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+          grant_type: "refresh_token",
+          refresh_token: current.refreshToken,
+          client_id: currentLink.clientId
+        })
+      }
+    );
+    const payload = await responseRecord(response);
+    if (!response.ok) {
+      if (response.status === 400 && stringField(payload, "error") === "invalid_grant") {
+        throw new AgentLinkError("not_linked", AGENT_LINK_REVOKED_MESSAGE);
+      }
+      throw httpError("The vAPI agent token refresh failed.");
+    }
+    const refreshed = {
+      accessToken: requiredString(payload, "access_token"),
+      refreshToken: stringField(payload, "refresh_token") ?? current.refreshToken,
+      expiresAt: now() + requiredNumber(payload, "expires_in") * 1e3,
+      scopes: stringField(payload, "scope") === void 0 ? [...current.scopes] : splitScopes(requiredString(payload, "scope"))
+    };
+    await safeSetSecret(args.secrets, currentAccounts.tokens, JSON.stringify(refreshed));
+    return refreshed.accessToken;
+  });
+}
+async function withAgentCredentialLock(wallets, clientId, operation) {
+  const digest = createHash("sha256").update(clientId).digest("hex").slice(0, 24);
+  const lockPath = `${wallets.registryPath}.${digest}.agent-link.lock`;
+  await mkdir5(dirname3(lockPath), { recursive: true, mode: 448 });
+  const deadline = Date.now() + 3e4;
+  let handle;
+  while (!handle) {
+    try {
+      handle = await open4(lockPath, "wx", 384);
+    } catch (error61) {
+      if (!(error61 instanceof Error && "code" in error61 && error61.code === "EEXIST")) throw error61;
+      await removeStaleCredentialLock(lockPath);
+      if (Date.now() >= deadline) {
+        throw httpError("Timed out waiting to update the agent credentials.");
+      }
+      await new Promise((resolve) => setTimeout(resolve, 20));
+    }
+  }
+  try {
+    return await operation();
+  } finally {
+    await handle.close();
+    await unlink4(lockPath).catch(() => void 0);
+  }
+}
+async function removeStaleCredentialLock(path) {
+  try {
+    const metadata = await stat4(path);
+    if (Date.now() - metadata.mtimeMs > 5 * 6e4) await unlink4(path);
+  } catch {
+  }
+}
+async function safeGetSecret(secrets, account) {
+  try {
+    return await secrets.get(account);
+  } catch {
+    throw httpError("The agent tokens could not be read from the OS secret store.");
+  }
+}
+async function safeSetSecret(secrets, account, value) {
+  try {
+    await secrets.set(account, value);
+  } catch {
+    throw httpError("The agent credentials could not be stored in the OS secret store.");
+  }
+}
+function parseTokens(value) {
+  if (value === void 0) return void 0;
+  let parsed;
+  try {
+    parsed = JSON.parse(value);
+  } catch {
+    return void 0;
+  }
+  if (!isRecord(parsed)) return void 0;
+  const accessToken = stringField(parsed, "accessToken");
+  const refreshToken = stringField(parsed, "refreshToken");
+  const refreshable = parsed.refreshable;
+  const expiresAt = numberField(parsed, "expiresAt");
+  const scopes = parsed.scopes;
+  if (accessToken === void 0 || expiresAt === void 0 || !Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string") || (refreshToken === void 0 ? refreshable !== false : refreshable === false)) {
+    return void 0;
+  }
+  return {
+    accessToken,
+    ...refreshToken === void 0 ? {} : { refreshToken },
+    expiresAt,
+    scopes
+  };
+}
+function withBearer(init, accessToken) {
+  const headers = new Headers(init?.headers);
+  headers.set("authorization", `Bearer ${accessToken}`);
+  return { ...init, headers };
+}
+async function safeFetch(fetchImpl, input2, init) {
+  try {
+    return await fetchImpl(input2, init);
+  } catch {
+    throw httpError("The vAPI agent link request failed.");
+  }
+}
+async function safeAgentFetch(fetchImpl, input2, init) {
+  try {
+    return await fetchImpl(input2, init);
+  } catch {
+    throw httpError("The vAPI agent request failed.");
+  }
+}
+function notLinkedError() {
+  return new AgentLinkError("not_linked", "Run vapi login first.");
+}
+function httpError(message) {
+  return new AgentLinkError("http", message);
+}
+function apiEndpoint(apiBase, path) {
+  return new URL(path, new URL(apiBase).origin).toString();
+}
+async function responseRecord(response) {
+  let payload;
+  try {
+    payload = await response.json();
+  } catch {
+    throw httpError("The vAPI agent link response was invalid.");
+  }
+  if (!isRecord(payload)) throw httpError("The vAPI agent link response was invalid.");
+  return payload;
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function stringField(record2, key) {
+  const value = record2[key];
+  return typeof value === "string" ? value : void 0;
+}
+function numberField(record2, key) {
+  const value = record2[key];
+  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function requiredString(record2, key) {
+  const value = stringField(record2, key);
+  if (value === void 0) throw httpError("The vAPI agent link response was invalid.");
+  return value;
+}
+function requiredNumber(record2, key) {
+  const value = numberField(record2, key);
+  if (value === void 0) throw httpError("The vAPI agent link response was invalid.");
+  return value;
+}
+function splitScopes(scope) {
+  return scope.split(/\s+/u).filter(Boolean);
+}
+
+// src/movement-open.ts
+function isOpenMovementLeg(leg, journalEvidence) {
+  if (leg.status === "sent" || leg.status === "cancelled") return false;
+  if (leg.restored === true) return true;
+  if (leg.status === "planned" || leg.status === "unknown") return true;
+  if (leg.status !== "failed") return false;
+  if (leg.retryable === true) return true;
+  return journalEvidence === "signed";
+}
+
+// src/transfer-journal.ts
+import { readFile as readFile5 } from "node:fs/promises";
+async function readTransferJournal(home, from, nonce) {
+  let raw;
+  try {
+    raw = await readFile5(getVapiPaths(home).receipts, "utf8");
+  } catch (error61) {
+    if (isMissingFile(error61)) return { signed: false };
+    throw error61;
+  }
+  let latest;
+  let request;
+  for (const [index, line] of raw.split("\n").entries()) {
+    if (!line.trim()) continue;
+    let receipt;
+    try {
+      receipt = parseReceipt(JSON.parse(line));
+    } catch (error61) {
+      throw new Error(`Invalid receipt on JSONL line ${index + 1}.`, { cause: error61 });
+    }
+    if (receiptWallet(receipt) !== from || receipt.transfer?.nonce.toLowerCase() !== nonce.toLowerCase()) {
+      continue;
+    }
+    latest = receipt;
+    if (receipt.transfer.request !== void 0) request = receipt;
+  }
+  return {
+    signed: latest !== void 0,
+    ...latest === void 0 ? {} : { latest },
+    ...request === void 0 ? {} : { request },
+    ...request?.transfer?.request?.authorization.validBefore === void 0 ? {} : { validBefore: request.transfer.request.authorization.validBefore },
+    ...(latest?.transfer?.reservedOn ?? request?.transfer?.reservedOn) === void 0 ? {} : { reservedOn: latest?.transfer?.reservedOn ?? request?.transfer?.reservedOn }
+  };
+}
 
 // src/vault-key.ts
 import { randomBytes as cryptoRandomBytes } from "node:crypto";
 
 // src/vault.ts
-import { randomBytes as randomBytes3 } from "node:crypto";
-import { mkdir, open as open2, readFile, rename, rm, stat, unlink, writeFile } from "node:fs/promises";
-import { dirname } from "node:path";
+import { randomBytes as randomBytes5 } from "node:crypto";
+import { mkdir as mkdir6, open as open5, readFile as readFile6, rename as rename4, rm, stat as stat5, unlink as unlink5, writeFile as writeFile3 } from "node:fs/promises";
+import { dirname as dirname4 } from "node:path";
 var VaultError = class extends Error {
   code;
   constructor(code, message, options) {
@@ -46596,9 +47722,9 @@ async function readVaultFile(path, key) {
 async function readVaultFileUnlocked(path) {
   let raw;
   try {
-    raw = await readFile(path, "utf8");
+    raw = await readFile6(path, "utf8");
   } catch (error61) {
-    if (isMissingFile(error61)) {
+    if (isMissingFile2(error61)) {
       throw new VaultError("not_found", "No vault file was found at the requested path.", {
         cause: error61
       });
@@ -46609,9 +47735,9 @@ async function readVaultFileUnlocked(path) {
 }
 async function refuseExistingVault(path) {
   try {
-    await stat(path);
+    await stat5(path);
   } catch (error61) {
-    if (isMissingFile(error61)) return;
+    if (isMissingFile2(error61)) return;
     throw new VaultError("corrupt", "Unable to check whether the vault already exists.", {
       cause: error61
     });
@@ -46619,29 +47745,29 @@ async function refuseExistingVault(path) {
   throw new VaultError("corrupt", "A vault already exists at the requested path.");
 }
 async function writeVaultFile(path, file2) {
-  await mkdir(dirname(path), { recursive: true, mode: 448 });
-  const temporaryPath = `${path}.${process.pid}.${randomBytes3(6).toString("hex")}.tmp`;
+  await mkdir6(dirname4(path), { recursive: true, mode: 448 });
+  const temporaryPath = `${path}.${process.pid}.${randomBytes5(6).toString("hex")}.tmp`;
   try {
-    await writeFile(temporaryPath, `${JSON.stringify(file2, null, 2)}
+    await writeFile3(temporaryPath, `${JSON.stringify(file2, null, 2)}
 `, {
       encoding: "utf8",
       mode: 384,
       flag: "wx"
     });
-    await rename(temporaryPath, path);
+    await rename4(temporaryPath, path);
   } catch (error61) {
     await rm(temporaryPath, { force: true }).catch(() => void 0);
     throw error61;
   }
 }
 async function withVaultLock(path, operation) {
-  await mkdir(dirname(path), { recursive: true, mode: 448 });
+  await mkdir6(dirname4(path), { recursive: true, mode: 448 });
   const lockPath = `${path}.lock`;
   const deadline = Date.now() + VAULT_LOCK_TIMEOUT_MS;
   let handle;
   while (!handle) {
     try {
-      handle = await open2(lockPath, "wx", 384);
+      handle = await open5(lockPath, "wx", 384);
     } catch (error61) {
       if (!isExistingFile(error61)) throw error61;
       await removeStaleVaultLock(lockPath);
@@ -46655,18 +47781,18 @@ async function withVaultLock(path, operation) {
     return await operation();
   } finally {
     await handle.close();
-    await unlink(lockPath).catch(() => void 0);
+    await unlink5(lockPath).catch(() => void 0);
   }
 }
 async function removeStaleVaultLock(path) {
   try {
-    const metadata = await stat(path);
-    if (Date.now() - metadata.mtimeMs > STALE_VAULT_LOCK_MS) await unlink(path);
+    const metadata = await stat5(path);
+    if (Date.now() - metadata.mtimeMs > STALE_VAULT_LOCK_MS) await unlink5(path);
   } catch (error61) {
-    if (!isMissingFile(error61)) throw error61;
+    if (!isMissingFile2(error61)) throw error61;
   }
 }
-function isMissingFile(error61) {
+function isMissingFile2(error61) {
   return typeof error61 === "object" && error61 !== null && "code" in error61 && Reflect.get(error61, "code") === "ENOENT";
 }
 function isExistingFile(error61) {
@@ -46810,8 +47936,8 @@ function passwordRequiredError() {
     "A vault password is needed. Pass it or set VAPI_VAULT_PASSWORD."
   );
 }
-function randomKeyBytes(randomBytes4) {
-  const key = Buffer.from((randomBytes4 ?? cryptoRandomBytes)(DEVICE_KEY_LENGTH));
+function randomKeyBytes(randomBytes7) {
+  const key = Buffer.from((randomBytes7 ?? cryptoRandomBytes)(DEVICE_KEY_LENGTH));
   if (key.byteLength !== DEVICE_KEY_LENGTH) {
     key.fill(0);
     throw new VaultError("corrupt", "A generated device vault key has the wrong length.");
@@ -46879,6 +48005,7 @@ var routerRefillSchema = external_exports.object({
 });
 var ceilingSweepPendingSchema = external_exports.strictObject({
   owner: external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/),
+  target: external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/).optional(),
   amountAtomic: external_exports.string().regex(/^\d+$/),
   nonce: external_exports.string().regex(/^0x[0-9a-fA-F]{64}$/),
   createdAt: external_exports.iso.datetime(),
@@ -46902,6 +48029,426 @@ var walletRegistrySchema = external_exports.object({
   wallets: external_exports.record(walletNameSchema, walletEntrySchema)
 });
 
+// src/movement.ts
+var movementIdSchema = external_exports.string().regex(/^mv_[A-Za-z0-9_-]{8,128}$/);
+var nonceSchema = external_exports.string().regex(/^0x[0-9a-fA-F]{64}$/);
+var amountSchema = external_exports.string().regex(/^\d+\.\d{2}$/);
+var movementReasonSchema = external_exports.enum([
+  "distribute",
+  "allocate",
+  "rebalance",
+  "delegate",
+  "sweep",
+  "send"
+]);
+var movementPurposeSchema = external_exports.enum(["send", "sweep"]);
+var movementAddressSchema = external_exports.string().refine((value) => isAddress(value, { strict: false }));
+var movementLegSchema = external_exports.strictObject({
+  from: walletNameSchema,
+  to: external_exports.string().trim().min(1),
+  fromAddress: movementAddressSchema.optional(),
+  toAddress: movementAddressSchema.optional(),
+  amountUsd: amountSchema,
+  purpose: movementPurposeSchema,
+  nonce: nonceSchema,
+  status: external_exports.enum(["planned", "sent", "failed", "unknown", "cancelled"]),
+  txHash: external_exports.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
+  reason: external_exports.string().min(1).optional(),
+  retryable: external_exports.boolean().optional(),
+  restored: external_exports.literal(true).optional(),
+  addressBindingSource: external_exports.enum(["journal", "terminal-review"]).optional()
+});
+var movementSchema = external_exports.strictObject({
+  v: external_exports.literal(2),
+  id: movementIdSchema,
+  reason: movementReasonSchema,
+  from: walletNameSchema,
+  // The only account a `sweep` leg may name besides the owner. Sweeps skip the
+  // spend caps, so the parent comes from the plan, never from a leg's `to`.
+  treasury: walletNameSchema.optional(),
+  network: external_exports.enum([BASE_MAINNET_CAIP2, ARC_MAINNET_CAIP2]),
+  createdAt: external_exports.iso.datetime(),
+  legs: external_exports.array(movementLegSchema).min(1)
+});
+var legacyMovementSchema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  id: movementIdSchema,
+  reason: external_exports.literal("distribute"),
+  from: walletNameSchema,
+  network: external_exports.enum([BASE_MAINNET_CAIP2, ARC_MAINNET_CAIP2]),
+  createdAt: external_exports.iso.datetime(),
+  legs: external_exports.array(
+    external_exports.strictObject({
+      to: external_exports.string().trim().min(1),
+      amountUsd: amountSchema,
+      nonce: nonceSchema,
+      status: external_exports.enum(["planned", "sent", "failed", "unknown"]),
+      txHash: external_exports.string().regex(/^0x[0-9a-fA-F]+$/).optional(),
+      reason: external_exports.string().min(1).optional(),
+      retryable: external_exports.boolean().optional()
+    })
+  ).min(1)
+});
+var MovementError = class extends Error {
+  constructor(code, message, movementId) {
+    super(message);
+    this.code = code;
+    this.movementId = movementId;
+    this.name = "MovementError";
+  }
+  code;
+  movementId;
+};
+async function listUnfinishedMovementSnapshots(options) {
+  const directory = movementsDirectory(options.home);
+  let names;
+  try {
+    names = await readdir3(directory);
+  } catch (error61) {
+    if (isMissingFile(error61)) return [];
+    throw error61;
+  }
+  const snapshots = [];
+  for (const name of names.filter((candidate) => candidate.endsWith(".json")).sort()) {
+    const movement = parseMovement(JSON.parse(await readFile7(join6(directory, name), "utf8")));
+    if (options.from !== void 0 && !movement.legs.some((leg) => leg.from === options.from)) {
+      continue;
+    }
+    const pendingLegs = movement.legs.filter((leg) => leg.status === "planned").length;
+    const unknownLegs = movement.legs.filter((leg) => leg.status === "unknown").length;
+    const evidence = await movementOpenEvidence(options.home, movement, options.from);
+    if (!evidence.open) continue;
+    snapshots.push({
+      movement,
+      summary: {
+        id: movement.id,
+        from: movement.from,
+        network: movement.network,
+        createdAt: movement.createdAt,
+        pendingLegs,
+        unknownLegs
+      },
+      signedFailedLegKeys: evidence.signedFailedLegKeys
+    });
+  }
+  return snapshots.sort(
+    (left, right) => left.summary.createdAt.localeCompare(right.summary.createdAt) || left.summary.id.localeCompare(right.summary.id)
+  );
+}
+async function movementOpenEvidence(home, movement, from) {
+  let open7 = false;
+  const signedFailedLegKeys = [];
+  for (const leg of movement.legs) {
+    if (from !== void 0 && leg.from !== from) continue;
+    if (isOpenMovementLeg(leg, "unsigned")) open7 = true;
+    if (leg.status !== "failed") continue;
+    const journal = await readTransferJournal(home, leg.from, leg.nonce);
+    if (journal.signed) signedFailedLegKeys.push(movementTransferKey(leg.from, leg.nonce));
+    if (isOpenMovementLeg(leg, journal.signed ? "signed" : "unsigned")) open7 = true;
+  }
+  return { open: open7, signedFailedLegKeys };
+}
+async function readMovement(home, id) {
+  const safeId = parseMovementId(id);
+  try {
+    return parseMovement(
+      JSON.parse(await readFile7(join6(movementsDirectory(home), `${safeId}.json`), "utf8"))
+    );
+  } catch (error61) {
+    if (isMissingFile(error61)) {
+      throw new MovementError(
+        "movement_not_found",
+        `No movement named ${safeId} was found.`,
+        safeId
+      );
+    }
+    throw error61;
+  }
+}
+function movementTransferKey(from, nonce) {
+  return `${from}\0${nonce.toLowerCase()}`;
+}
+async function reconcileSignedLegs(home, id, signedKeys) {
+  const initial = await readMovement(home, id);
+  return await withMovementLocks(home, movementSenders(initial), void 0, async () => {
+    const movement = await readMovement(home, id);
+    const reconciled = movementWithSignedLegsUnknown(movement, signedKeys);
+    if (reconciled !== movement) await writeMovement(home, reconciled);
+    return reconciled;
+  });
+}
+async function markOpenLegsRestored(home, id) {
+  let initial;
+  try {
+    initial = await readMovement(home, id);
+  } catch (error61) {
+    if (error61 instanceof MovementError && error61.code === "movement_not_found" || error61 instanceof SyntaxError || error61 instanceof external_exports.ZodError) {
+      return void 0;
+    }
+    throw error61;
+  }
+  return await withMovementLocks(home, movementSenders(initial), void 0, async () => {
+    const movement = await readMovement(home, id);
+    let changed = false;
+    const legs = movement.legs.map((leg) => {
+      if (leg.status === "sent" || leg.status === "cancelled" || leg.restored === true) return leg;
+      changed = true;
+      return { ...leg, restored: true };
+    });
+    if (!changed) return movement;
+    const restored = movementSchema.parse({ ...movement, legs });
+    await writeMovement(home, restored);
+    return restored;
+  });
+}
+function unknownLeg(leg) {
+  return {
+    from: leg.from,
+    to: leg.to,
+    ...legAddressBinding(leg),
+    amountUsd: leg.amountUsd,
+    purpose: leg.purpose,
+    nonce: leg.nonce,
+    status: "unknown",
+    ...restoredMarker(leg)
+  };
+}
+function restoredMarker(leg) {
+  return leg.restored === true ? { restored: true } : {};
+}
+function legAddressBinding(leg) {
+  return {
+    ...leg.fromAddress === void 0 ? {} : { fromAddress: leg.fromAddress },
+    ...leg.toAddress === void 0 ? {} : { toAddress: leg.toAddress },
+    ...leg.addressBindingSource === void 0 ? {} : { addressBindingSource: leg.addressBindingSource }
+  };
+}
+function isExpiredRestoredReview(leg) {
+  return leg.restored === true && leg.reason === "restored_nonce_expired";
+}
+function movementWithSignedLegsUnknown(movement, signedKeys) {
+  let changed = false;
+  const legs = movement.legs.map((leg) => {
+    if (isExpiredRestoredReview(leg)) return leg;
+    if (leg.status === "sent" || leg.status === "cancelled" || !signedKeys.has(movementTransferKey(leg.from, leg.nonce)) || leg.status === "unknown" && leg.txHash === void 0 && leg.reason === void 0 && leg.retryable === void 0) {
+      return leg;
+    }
+    changed = true;
+    return unknownLeg(leg);
+  });
+  return changed ? movementSchema.parse({ ...movement, legs }) : movement;
+}
+function parseMovement(value) {
+  const current = movementSchema.safeParse(value);
+  if (current.success) return current.data;
+  const legacy = legacyMovementSchema.parse(value);
+  return movementSchema.parse({
+    ...legacy,
+    v: 2,
+    legs: legacy.legs.map((leg) => ({
+      ...leg,
+      from: legacy.from,
+      purpose: "send"
+    }))
+  });
+}
+function movementSenders(movement) {
+  return sortedUniqueSenders(movement.legs.map((leg) => leg.from));
+}
+function sortedUniqueSenders(senders) {
+  return [...new Set(senders)].sort();
+}
+function parseMovementId(value) {
+  const parsed = movementIdSchema.safeParse(value);
+  if (!parsed.success) throw new MovementError("invalid_movement", "The movement id is invalid.");
+  return parsed.data;
+}
+function movementsDirectory(home) {
+  return join6(home, "movements");
+}
+async function writeMovement(home, movement) {
+  const parsed = movementSchema.parse(movement);
+  const directory = movementsDirectory(home);
+  await mkdir7(directory, { recursive: true, mode: 448 });
+  await chmod(directory, 448);
+  const path = join6(directory, `${parsed.id}.json`);
+  const temporary = join6(
+    directory,
+    `.${parsed.id}.${process.pid}.${randomBytes6(6).toString("hex")}.tmp`
+  );
+  let handle;
+  try {
+    handle = await open6(temporary, "wx", 384);
+    await handle.writeFile(serializeMovement(parsed), "utf8");
+    await handle.sync();
+    await handle.close();
+    handle = void 0;
+    await rename5(temporary, path);
+    const directoryHandle = await open6(directory, "r");
+    try {
+      await directoryHandle.sync();
+    } finally {
+      await directoryHandle.close();
+    }
+  } catch (error61) {
+    await handle?.close().catch(() => void 0);
+    await unlink6(temporary).catch(() => void 0);
+    throw error61;
+  }
+}
+function serializeMovement(movement) {
+  return `${JSON.stringify(movementSchema.parse(movement), null, 2)}
+`;
+}
+async function withMovementLock(home, from, timeoutMs, operation) {
+  try {
+    return await withAccountMovementLocks(home, [from], timeoutMs, operation);
+  } catch (error61) {
+    if (error61 instanceof AccountMovementLockedError) {
+      throw new MovementError(
+        "movement_locked",
+        `Another movement is already running for account ${from}.`
+      );
+    }
+    throw error61;
+  }
+}
+async function withMovementLocks(home, senders, timeoutMs, operation) {
+  const [sender, ...remaining] = senders;
+  if (sender === void 0) return await operation();
+  return await withMovementLock(
+    home,
+    sender,
+    timeoutMs,
+    async () => withMovementLocks(home, remaining, timeoutMs, operation)
+  );
+}
+
+// src/swarm.ts
+import { readdir as readdir4, readFile as readFile8, stat as stat6, unlink as unlink7 } from "node:fs/promises";
+import { join as join7 } from "node:path";
+var SWARM_NAME_PATTERN = /^[a-z][a-z0-9-]{0,15}$/;
+var SWARM_ROLE_PATTERN = /^[a-z][a-z0-9]{0,7}$/;
+var atomicSchema = external_exports.string().regex(/^\d+$/);
+var addressSchema2 = external_exports.string().regex(/^0x[0-9a-fA-F]{40}$/);
+var capsSchema = external_exports.strictObject({ perCallAtomic: atomicSchema, perDayAtomic: atomicSchema });
+var movementIdSchema2 = external_exports.string().regex(/^mv_[A-Za-z0-9_-]{8,128}$/u);
+var amountUsdSchema = external_exports.string().regex(/^\d+\.\d{2}$/u);
+var setupFundingStatusSchema = external_exports.enum(["planned", "sent", "incomplete"]);
+var blockedFundingLegSchema = external_exports.strictObject({
+  to: external_exports.string().trim().min(1),
+  amountUsd: amountUsdSchema,
+  reason: external_exports.string().trim().min(1)
+});
+var setupFundingSchema = external_exports.strictObject({
+  amountUsd: amountUsdSchema,
+  from: walletNameSchema,
+  movementId: movementIdSchema2.optional(),
+  status: setupFundingStatusSchema,
+  policy: external_exports.strictObject({
+    strategy: external_exports.enum(["targets", "even", "weights"]),
+    movementId: movementIdSchema2.optional(),
+    status: setupFundingStatusSchema,
+    blocked: external_exports.array(blockedFundingLegSchema).optional()
+  }).optional()
+});
+var accountSteps = {
+  creating: external_exports.boolean().default(false),
+  created: external_exports.boolean(),
+  capped: external_exports.boolean(),
+  linked: external_exports.boolean()
+};
+var treasurySchema = external_exports.strictObject({
+  account: walletNameSchema,
+  // A planned account has no address until its vault derivation succeeds.
+  address: addressSchema2.optional(),
+  steps: external_exports.strictObject(accountSteps)
+}).refine(
+  (value) => !value.steps.created || value.address !== void 0,
+  "Created accounts require an address."
+);
+var memberSchema = external_exports.strictObject({
+  account: walletNameSchema,
+  address: addressSchema2.optional(),
+  role: external_exports.string().regex(SWARM_ROLE_PATTERN),
+  weight: external_exports.number().int().positive(),
+  targetAtomic: atomicSchema,
+  ceilingAtomic: atomicSchema.nullable(),
+  steps: external_exports.strictObject({ ...accountSteps, profiled: external_exports.boolean() })
+}).refine(
+  (value) => !value.steps.created || value.address !== void 0,
+  "Created accounts require an address."
+);
+var swarmFileSchema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  name: external_exports.string().regex(SWARM_NAME_PATTERN),
+  device: external_exports.string().regex(DEVICE_NAME_PATTERN),
+  network: external_exports.enum([BASE_MAINNET_CAIP2, ARC_MAINNET_CAIP2]),
+  createdAt: external_exports.iso.datetime(),
+  treasury: treasurySchema,
+  members: external_exports.array(memberSchema),
+  setupFunding: setupFundingSchema.optional(),
+  policy: external_exports.strictObject({
+    strategy: external_exports.enum(["targets", "even", "weights"]),
+    treasuryCaps: capsSchema
+  })
+}).refine(
+  (value) => (/* @__PURE__ */ new Set([value.treasury.account, ...value.members.map((member) => member.account)])).size === value.members.length + 1,
+  "Swarm accounts must be unique."
+);
+var SwarmError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "SwarmError";
+  }
+  code;
+};
+function swarmsDirectory(home) {
+  return join7(home, "swarms");
+}
+function swarmFilePath(home, name) {
+  assertName(name);
+  return join7(swarmsDirectory(home), `${name}.json`);
+}
+async function readSwarm(home, name) {
+  const path = swarmFilePath(home, name);
+  try {
+    const swarm = parseSwarm(JSON.parse(await readFile8(path, "utf8")));
+    if (swarm.name !== name)
+      throw new SwarmError("invalid_swarm", "Swarm name does not match its file.");
+    return swarm;
+  } catch (error61) {
+    if (isMissingFile(error61)) throw new SwarmError("swarm_not_found", `No swarm named ${name}.`);
+    if (error61 instanceof SwarmError) throw error61;
+    throw new SwarmError("invalid_swarm", `Invalid swarm file for ${name}.`);
+  }
+}
+async function listSwarms(home) {
+  let files;
+  try {
+    files = await readdir4(swarmsDirectory(home));
+  } catch (error61) {
+    if (isMissingFile(error61)) return [];
+    throw error61;
+  }
+  return await Promise.all(
+    files.filter((file2) => file2.endsWith(".json")).sort().map((file2) => readSwarm(home, file2.slice(0, -5)))
+  );
+}
+function parseSwarm(value) {
+  const result = swarmFileSchema.safeParse(value);
+  if (!result.success) throw new SwarmError("invalid_swarm", "Invalid swarm state.");
+  return result.data;
+}
+function assertName(name) {
+  if (!SWARM_NAME_PATTERN.test(name))
+    throw new SwarmError(
+      "invalid_swarm",
+      "A swarm name must be 1 to 16 lowercase letters, digits or dashes, starting with a letter."
+    );
+}
+
 // src/backup.ts
 var ERROR_MESSAGES = {
   backup_too_large: "Backup envelope exceeds 65,536 bytes.",
@@ -46910,6 +48457,7 @@ var ERROR_MESSAGES = {
   unsupported_signature: "Unsupported signature.",
   weak_password: "Password must contain at least 12 characters.",
   backup_invalid_input: "Invalid backup input.",
+  backup_snapshot_busy: "Backup files changed while they were being captured. Retry the backup; no backup was created or uploaded.",
   relay_open_failed: "Unable to open relay payload.",
   relay_invalid_key: "Invalid relay key.",
   vault_exists: "A vault already exists."
@@ -46931,6 +48479,15 @@ var SCRYPT_N2 = 131072;
 var SCRYPT_R2 = 8;
 var SCRYPT_P2 = 1;
 var SCRYPT_MAXMEM = 256 * 1024 * 1024;
+var RESTORE_MARKER_FILE = ".backup-restore.json";
+var restoreDigestSchema = external_exports.string().regex(/^[0-9a-f]{64}$/u);
+var restoreMarkerSchema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  fingerprint: restoreDigestSchema,
+  vaultSha256: restoreDigestSchema,
+  registrySha256: restoreDigestSchema,
+  mac: restoreDigestSchema
+});
 var SECP256K1_ORDER = BigInt(
   "0xFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFFEBAAEDCE6AF48A03BBFD25E8CD0364141"
 );
@@ -46950,7 +48507,7 @@ var X25519_PRIVATE_DER_PREFIX = Buffer.from("302e020100300506032b656e04220420",
 var X25519_PUBLIC_DER_PREFIX = Buffer.from("302a300506032b656e032100", "hex");
 var CROCKFORD_BASE32 = "0123456789ABCDEFGHJKMNPQRSTVWXYZ";
 var isoUtcMillisecondsSchema = external_exports.string().refine(isIsoUtcMilliseconds);
-var addressSchema2 = external_exports.custom(
+var addressSchema3 = external_exports.custom(
   (value) => typeof value === "string" && ADDRESS_PATTERN2.test(value)
 );
 var privateKeySchema = external_exports.custom(
@@ -46959,7 +48516,7 @@ var privateKeySchema = external_exports.custom(
 var safeNonnegativeIntegerSchema = external_exports.number().int().nonnegative().refine(Number.isSafeInteger);
 var accountFields2 = {
   name: walletNameSchema,
-  address: addressSchema2,
+  address: addressSchema3,
   createdAt: isoUtcMillisecondsSchema
 };
 var backupAccountSchema = external_exports.discriminatedUnion("kind", [
@@ -46983,26 +48540,189 @@ var backupRegistryAccountSchema = external_exports.object({
   label: external_exports.string().optional(),
   spendCaps: spendCapsSchema.strict()
 }).strict();
-var backupRegistrySchema = external_exports.object({
+var backupRegistryV1Schema = external_exports.object({
   default: walletNameSchema.optional(),
   accounts: external_exports.array(backupRegistryAccountSchema),
   networks: external_exports.array(external_exports.string().regex(CAIP2_PATTERN))
 }).strict();
-var backupSourceSchema = external_exports.object({
+var routerRefillSchema2 = external_exports.strictObject({
+  belowUsd: external_exports.number().finite().min(0),
+  tierUsd: external_exports.union([external_exports.literal(1), external_exports.literal(5), external_exports.literal(20), external_exports.literal(50)])
+});
+var backupRegistryAccountV2Schema = external_exports.strictObject({
+  name: walletNameSchema,
+  label: external_exports.string().optional(),
+  spendCaps: spendCapsSchema.strict(),
+  ceilingAtomic: external_exports.string().regex(/^\d+$/u).nullable().optional(),
+  routerRefill: routerRefillSchema2.optional()
+});
+var backupRegistryV2Schema = external_exports.strictObject({
+  default: walletNameSchema.optional(),
+  accounts: external_exports.array(backupRegistryAccountV2Schema),
+  networks: external_exports.array(external_exports.string().regex(CAIP2_PATTERN))
+});
+var backupAgentProfileSchema = external_exports.strictObject({
+  version: external_exports.literal(1),
+  name: walletNameSchema,
+  wallet: external_exports.string(),
+  model: external_exports.string().min(1),
+  instructions: external_exports.string().max(2e4),
+  verifiedOnly: external_exports.boolean(),
+  approveAboveUsd: external_exports.number().min(0),
+  maxSteps: external_exports.number().int().min(1).max(50),
+  paused: external_exports.boolean(),
+  createdAt: external_exports.string(),
+  tools: external_exports.array(external_exports.string().min(1)),
+  grants: external_exports.array(external_exports.enum(["read", "delegate", "allocate"])).min(1).optional()
+});
+var movementIdSchema3 = external_exports.string().regex(/^mv_[A-Za-z0-9_-]{8,128}$/u);
+var movementNonceSchema = external_exports.string().regex(/^0x[0-9a-fA-F]{64}$/u);
+var movementAmountSchema = external_exports.string().regex(/^\d+\.\d{2}$/u);
+var movementStatusSchema = external_exports.enum(["planned", "sent", "failed", "unknown"]);
+var movementV2StatusSchema = external_exports.enum(["planned", "sent", "failed", "unknown", "cancelled"]);
+var movementOptionalFields = {
+  txHash: external_exports.string().regex(/^0x[0-9a-fA-F]+$/u).optional(),
+  reason: external_exports.string().min(1).optional(),
+  retryable: external_exports.boolean().optional()
+};
+var backupMovementV1Schema = external_exports.strictObject({
+  v: external_exports.literal(1),
+  id: movementIdSchema3,
+  reason: external_exports.literal("distribute"),
+  from: walletNameSchema,
+  network: external_exports.enum([BASE_MAINNET_CAIP2, ARC_MAINNET_CAIP2]),
+  createdAt: external_exports.iso.datetime(),
+  legs: external_exports.array(
+    external_exports.strictObject({
+      to: external_exports.string().trim().min(1),
+      amountUsd: movementAmountSchema,
+      nonce: movementNonceSchema,
+      status: movementStatusSchema,
+      ...movementOptionalFields
+    })
+  ).min(1)
+});
+var backupMovementV2Schema = external_exports.strictObject({
+  v: external_exports.literal(2),
+  id: movementIdSchema3,
+  reason: external_exports.enum(["distribute", "allocate", "rebalance", "delegate", "sweep", "send"]),
+  from: walletNameSchema,
+  treasury: walletNameSchema.optional(),
+  network: external_exports.enum([BASE_MAINNET_CAIP2, ARC_MAINNET_CAIP2]),
+  createdAt: external_exports.iso.datetime(),
+  legs: external_exports.array(
+    external_exports.strictObject({
+      from: walletNameSchema,
+      to: external_exports.string().trim().min(1),
+      amountUsd: movementAmountSchema,
+      purpose: external_exports.enum(["send", "sweep"]),
+      nonce: movementNonceSchema,
+      status: movementV2StatusSchema,
+      ...movementOptionalFields
+    })
+  ).min(1)
+});
+var backupMovementSchema = external_exports.discriminatedUnion("v", [
+  backupMovementV1Schema,
+  backupMovementV2Schema
+]);
+var backupTransferRequestSchema = external_exports.strictObject({
+  authorization: external_exports.strictObject({
+    from: addressSchema3,
+    to: addressSchema3,
+    value: external_exports.string().regex(/^\d+$/u),
+    validAfter: external_exports.string().regex(/^\d+$/u),
+    validBefore: external_exports.string().regex(/^\d+$/u),
+    nonce: movementNonceSchema
+  }),
+  signature: external_exports.string().regex(/^0x[0-9a-fA-F]+$/u)
+});
+var backupTransferSchema = external_exports.strictObject({
+  to: addressSchema3,
+  toName: external_exports.string().min(1),
+  toKind: external_exports.enum(["owner", "account"]),
+  amountAtomic: external_exports.string().regex(/^\d+$/u),
+  network: external_exports.string().min(1),
+  nonce: movementNonceSchema,
+  status: external_exports.enum(["sent", "unknown", "failed"]),
+  txHash: external_exports.string().regex(/^0x[0-9a-fA-F]+$/u).nullable(),
+  replayed: external_exports.boolean(),
+  reservedOn: external_exports.string().regex(/^\d{4}-\d{2}-\d{2}$/u).optional(),
+  request: backupTransferRequestSchema.optional()
+});
+var backupTransferReceiptSchema = external_exports.strictObject({
+  id: external_exports.string().min(1),
+  timestamp: external_exports.iso.datetime(),
+  kind: external_exports.literal("transfer"),
+  wallet: walletNameSchema,
+  resourceUrl: external_exports.url(),
+  quote: external_exports.strictObject({
+    network: external_exports.string().min(1),
+    asset: external_exports.string().min(1),
+    amountAtomic: external_exports.string().regex(/^\d+$/u)
+  }),
+  transfer: backupTransferSchema,
+  error: external_exports.strictObject({ code: external_exports.string(), message: external_exports.string() }).optional()
+}).superRefine((receipt, context) => {
+  try {
+    parseReceipt(receipt);
+  } catch {
+    context.addIssue({ code: "custom", message: "Invalid transfer receipt." });
+  }
+});
+var backupSourceV1Schema = external_exports.object({
   phrase: external_exports.string().min(1),
   nextDerivedIndex: safeNonnegativeIntegerSchema,
   accounts: external_exports.array(backupAccountSchema),
-  registry: backupRegistrySchema,
+  registry: backupRegistryV1Schema,
   protected: external_exports.boolean()
 }).strict().superRefine(validateBackupSourceRelationships);
-var backupPlaintextSchema = external_exports.object({
+var backupSourceV2Schema = external_exports.strictObject({
+  phrase: external_exports.string().min(1),
+  nextDerivedIndex: safeNonnegativeIntegerSchema,
+  accounts: external_exports.array(backupAccountSchema),
+  registry: backupRegistryV2Schema,
+  protected: external_exports.boolean(),
+  agents: external_exports.array(backupAgentProfileSchema),
+  swarms: external_exports.array(swarmFileSchema),
+  movements: external_exports.array(backupMovementSchema),
+  transferReceipts: external_exports.array(backupTransferReceiptSchema),
+  skipped: external_exports.array(
+    external_exports.strictObject({
+      kind: external_exports.literal("agent"),
+      name: external_exports.string().min(1),
+      reason: external_exports.literal("invalid_profile")
+    })
+  ).optional()
+}).superRefine((source, context) => {
+  validateBackupSourceRelationships(source, context);
+  validateBackupV2Uniqueness(source, context);
+});
+var backupSourceSchema = external_exports.union([backupSourceV1Schema, backupSourceV2Schema]);
+var backupPlaintextV1Schema = external_exports.strictObject({
   v: external_exports.literal(1),
   phrase: external_exports.string().min(1),
   nextDerivedIndex: safeNonnegativeIntegerSchema,
   accounts: external_exports.array(backupAccountSchema),
-  registry: backupRegistrySchema,
+  registry: backupRegistryV1Schema,
   protected: external_exports.boolean()
-}).strict().superRefine((plaintext, context) => validateBackupSourceRelationships(plaintext, context));
+});
+var backupPlaintextV2Schema = external_exports.strictObject({
+  v: external_exports.literal(2),
+  phrase: external_exports.string().min(1),
+  nextDerivedIndex: safeNonnegativeIntegerSchema,
+  accounts: external_exports.array(backupAccountSchema),
+  registry: backupRegistryV2Schema,
+  protected: external_exports.boolean(),
+  agents: external_exports.array(backupAgentProfileSchema).optional(),
+  swarms: external_exports.array(swarmFileSchema).optional(),
+  movements: external_exports.array(backupMovementSchema).optional(),
+  transferReceipts: external_exports.array(backupTransferReceiptSchema).optional()
+});
+var backupPlaintextSchema = external_exports.discriminatedUnion("v", [backupPlaintextV1Schema, backupPlaintextV2Schema]).superRefine((plaintext, context) => {
+  validateBackupSourceRelationships(plaintext, context);
+  if (plaintext.v === 2) validateBackupV2Uniqueness(plaintext, context);
+});
 async function createBackup(options) {
   const parsed = backupSourceSchema.safeParse(options.vault);
   if (!parsed.success) throw new BackupError("backup_invalid_input");
@@ -47010,8 +48730,8 @@ async function createBackup(options) {
   assertDevice(options.device);
   assertOwnerKey(options.ownerKey);
   const createdAt = readCreatedAt(options.now ?? (() => /* @__PURE__ */ new Date()));
-  const randomBytes4 = options.randomBytes ?? cryptoRandomBytes2;
-  const nonce = readRandomBytes(randomBytes4, 12);
+  const randomBytes7 = options.randomBytes ?? cryptoRandomBytes2;
+  const nonce = readRandomBytes(randomBytes7, 12);
   const salt = encodeBase64Url(options.ownerKey.salt);
   const kdf = options.ownerKey.kdf === "hkdf-sha256" ? { name: "hkdf-sha256", salt } : { name: "scrypt", salt, N: SCRYPT_N2, r: SCRYPT_R2, p: SCRYPT_P2 };
   const cipher = { name: CIPHER_NAME, nonce: encodeBase64Url(nonce) };
@@ -47024,30 +48744,54 @@ async function createBackup(options) {
     kdf,
     cipher
   };
-  const plaintextValue = buildPlaintext(parsed.data);
-  const plaintext = Buffer.from(JSON.stringify(plaintextValue), "utf8");
   const key = Buffer.from(options.ownerKey.key);
-  let encrypted;
   try {
-    encrypted = encryptAesGcm(key, nonce, plaintext, Buffer.from(buildBackupAad(header), "utf8"));
-    const envelope = JSON.stringify({
-      format: header.format,
-      v: header.v,
-      owner: header.owner,
-      device: header.device,
-      createdAt: header.createdAt,
-      kdf: header.kdf,
-      cipher: header.cipher,
-      ciphertext: encodeBase64Url(encrypted)
-    });
-    const bytes = Buffer.byteLength(envelope, "utf8");
-    if (bytes > MAX_BACKUP_BYTES) throw new BackupError("backup_too_large");
-    return { envelope, bytes };
+    const candidates = backupCandidates(parsed.data);
+    for (const candidate of candidates) {
+      const plaintext = Buffer.from(JSON.stringify(candidate.plaintext), "utf8");
+      let encrypted;
+      try {
+        encrypted = encryptAesGcm(
+          key,
+          nonce,
+          plaintext,
+          Buffer.from(buildBackupAad(header), "utf8")
+        );
+        const envelope = JSON.stringify({
+          format: header.format,
+          v: header.v,
+          owner: header.owner,
+          device: header.device,
+          createdAt: header.createdAt,
+          kdf: header.kdf,
+          cipher: header.cipher,
+          ciphertext: encodeBase64Url(encrypted)
+        });
+        const bytes = Buffer.byteLength(envelope, "utf8");
+        const relayPayload = buildRelayRestorePayload({
+          owner,
+          device: "d".repeat(32),
+          kdf,
+          key: Buffer.alloc(32),
+          vault: candidate.plaintext
+        });
+        const relayBytes = Buffer.byteLength(relayPayload, "utf8");
+        if (bytes <= MAX_BACKUP_BYTES && relayBytes <= RELAY_PLAINTEXT_LIMIT) {
+          return {
+            envelope,
+            bytes,
+            ...candidate.omitted.length === 0 ? {} : { omitted: candidate.omitted }
+          };
+        }
+      } finally {
+        plaintext.fill(0);
+        encrypted?.fill(0);
+      }
+    }
+    throw new BackupError("backup_too_large");
   } finally {
-    plaintext.fill(0);
     key.fill(0);
     nonce.fill(0);
-    encrypted?.fill(0);
   }
 }
 function createRelayKeyPair(options = {}) {
@@ -47070,7 +48814,7 @@ function createRelayKeyPair(options = {}) {
 }
 function relayCode(publicKey) {
   assertRelayKey(publicKey);
-  const digest = createHash("sha256").update(publicKey).digest();
+  const digest = createHash2("sha256").update(publicKey).digest();
   try {
     let bits = BigInt(`0x${digest.subarray(0, 8).toString("hex")}`) >> 4n;
     const characters = Array.from({ length: 12 }, () => "0");
@@ -47134,69 +48878,173 @@ function openSealed(options) {
     plaintext?.fill(0);
   }
 }
+function buildRelayRestorePayload(options) {
+  try {
+    const owner = normalizedOwner(options.owner);
+    assertDevice(options.device);
+    assertBytes(options.key, 32);
+    if (!isRecord2(options.kdf)) throw new Error();
+    const kdf = parseKdf(options.kdf);
+    const parsed = backupPlaintextSchema.safeParse(options.vault);
+    if (!parsed.success) throw new Error();
+    const vault = parsed.data.v === 1 ? buildPlaintextV1(parsed.data) : buildPlaintextV2(parsed.data);
+    return JSON.stringify({
+      format: "vapi-vault-relay-payload",
+      v: 1,
+      purpose: "restore",
+      owner,
+      device: options.device,
+      kdf,
+      key: encodeBase64Url(options.key),
+      vault
+    });
+  } catch {
+    throw new BackupError("backup_invalid_input");
+  }
+}
 async function exportBackupSource(options) {
   try {
     assertBytes(options.vaultKey, 32);
-    if (!isRecord(options.store) || typeof options.store.home !== "string" || typeof options.store.snapshot !== "function" || typeof options.store.reload !== "function") {
+    if (!isRecord2(options.store) || typeof options.store.home !== "string" || typeof options.store.snapshot !== "function" || typeof options.store.reload !== "function") {
       throw new BackupError("backup_invalid_input");
     }
     const networks = normalizeNetworks(options.networks ?? []);
-    const path = join2(options.store.home, "vault.json");
-    const { phrase, file: file2, accounts } = await withVaultLock(path, async () => {
-      const [phrase2, vault, file3] = await Promise.all([
-        exportVaultPhrase({ path, key: options.vaultKey }),
-        openVault({ path, key: options.vaultKey }),
-        readVaultFileUnlocked(path)
-      ]);
-      const accounts2 = [];
-      for (const account of vault.accounts()) {
-        if (account.kind === "derived") {
-          accounts2.push({ ...account });
-        } else {
-          const privateKey = await exportVaultAccountKey({
-            path,
-            key: options.vaultKey,
-            name: account.name
-          });
-          accounts2.push({ ...account, privateKey });
-        }
+    for (let attempt = 0; attempt < 3; attempt += 1) {
+      try {
+        return await exportBackupSourceAttempt(options, networks);
+      } catch (error61) {
+        if (!(error61 instanceof BackupSnapshotChangedError)) throw error61;
       }
-      return { phrase: phrase2, file: file3, accounts: accounts2 };
-    });
-    const snapshot = await options.store.reload();
-    const names = new Set(accounts.map((account) => account.name));
-    const source = {
-      phrase,
-      nextDerivedIndex: file2.nextDerivedIndex ?? accounts.reduce(
-        (next, account) => account.kind === "derived" ? Math.max(next, account.index + 1) : next,
-        0
-      ),
-      accounts,
-      registry: {
-        ...snapshot.default !== void 0 && names.has(snapshot.default) ? { default: snapshot.default } : {},
-        accounts: accounts.map((account) => {
-          const entry = snapshot.wallets[account.name];
-          return {
-            name: account.name,
-            ...entry?.label === void 0 ? {} : { label: entry.label },
-            spendCaps: {
-              perCallAtomic: entry?.spendCaps.perCallAtomic ?? DEFAULT_SPEND_CAPS.perCallAtomic,
-              perDayAtomic: entry?.spendCaps.perDayAtomic ?? DEFAULT_SPEND_CAPS.perDayAtomic
-            }
-          };
-        }),
-        networks
-      },
-      protected: file2.protected
-    };
-    if (!backupSourceSchema.safeParse(source).success) {
-      throw new BackupError("backup_invalid_input");
     }
-    return source;
-  } catch {
+    throw new BackupError("backup_snapshot_busy");
+  } catch (error61) {
+    if (error61 instanceof BackupError && error61.code === "backup_snapshot_busy") throw error61;
     throw new BackupError("backup_invalid_input");
   }
 }
+var BackupSnapshotChangedError = class extends Error {
+};
+async function exportBackupSourceAttempt(options, networks) {
+  const path = join8(options.store.home, "vault.json");
+  const { phrase, file: file2, accounts } = await withVaultLock(path, async () => {
+    const [phrase2, vault, file3] = await Promise.all([
+      exportVaultPhrase({ path, key: options.vaultKey }),
+      openVault({ path, key: options.vaultKey }),
+      readVaultFileUnlocked(path)
+    ]);
+    const accounts2 = [];
+    for (const account of vault.accounts()) {
+      if (account.kind === "derived") {
+        accounts2.push({ ...account });
+      } else {
+        const privateKey = await exportVaultAccountKey({
+          path,
+          key: options.vaultKey,
+          name: account.name
+        });
+        accounts2.push({ ...account, privateKey });
+      }
+    }
+    return { phrase: phrase2, file: file3, accounts: accounts2 };
+  });
+  const snapshot = await options.store.reload();
+  const names = new Set(accounts.map((account) => account.name));
+  const home = options.store.home;
+  const skipped = [];
+  const [agents, swarms, movementSnapshots] = await Promise.all([
+    listAgentProfiles(home, {
+      schema: options.agentProfileSchema ?? agentProfileSchema,
+      warn: () => void 0,
+      onInvalid: (profileFile) => {
+        skipped.push({
+          kind: "agent",
+          name: profileFile.endsWith(".json") ? profileFile.slice(0, -5) : profileFile,
+          reason: "invalid_profile"
+        });
+      }
+    }),
+    listSwarms(home),
+    listUnfinishedMovementSnapshots({ home })
+  ]);
+  const localMovements = await Promise.all(
+    movementSnapshots.map(async ({ summary }) => await readMovement(home, summary.id))
+  );
+  localMovements.sort(compareMovements);
+  const expectedSignedFailedLegs = movementSnapshots.flatMap(
+    ({ signedFailedLegKeys }) => signedFailedLegKeys
+  );
+  const receipts = await readReceiptJournal(getVapiPaths(home).receipts);
+  const receiptLegs = new Set(
+    receipts.flatMap(
+      (receipt) => receipt.kind === "transfer" && receipt.transfer !== void 0 ? [movementTransferKey(receiptWallet(receipt), receipt.transfer.nonce)] : []
+    )
+  );
+  const requiredReceiptLegs = /* @__PURE__ */ new Set([
+    ...expectedSignedFailedLegs,
+    ...localMovements.flatMap(
+      (movement) => movement.legs.filter((leg) => leg.status === "unknown").map((leg) => movementTransferKey(leg.from, leg.nonce))
+    )
+  ]);
+  const verifiedFile = await readVaultFileUnlocked(path);
+  const verifiedSnapshot = await options.store.reload();
+  if ([...requiredReceiptLegs].some((leg) => !receiptLegs.has(leg)) || JSON.stringify(file2) !== JSON.stringify(verifiedFile) || JSON.stringify(snapshot) !== JSON.stringify(verifiedSnapshot)) {
+    throw new BackupSnapshotChangedError();
+  }
+  const movements = localMovements.map(toBackupMovement);
+  const includedLegs = new Set(
+    localMovements.flatMap(
+      (movement) => movement.legs.map((leg) => movementTransferKey(leg.from, leg.nonce))
+    )
+  );
+  const transferReceipts = receipts.filter(
+    (receipt) => receipt.kind === "transfer" && receipt.transfer !== void 0 && includedLegs.has(movementTransferKey(receiptWallet(receipt), receipt.transfer.nonce))
+  ).map(toBackupTransferReceipt);
+  const source = {
+    phrase,
+    nextDerivedIndex: file2.nextDerivedIndex ?? accounts.reduce(
+      (next, account) => account.kind === "derived" ? Math.max(next, account.index + 1) : next,
+      0
+    ),
+    accounts,
+    registry: {
+      ...snapshot.default !== void 0 && names.has(snapshot.default) ? { default: snapshot.default } : {},
+      accounts: accounts.map((account) => {
+        const entry = snapshot.wallets[account.name];
+        const ceilingAtomic = entry?.ceilingAtomic === null ? null : entry?.ceilingAtomic ?? DEFAULT_CEILING_ATOMIC.toString();
+        return {
+          name: account.name,
+          ...entry?.label === void 0 ? {} : { label: entry.label },
+          spendCaps: {
+            perCallAtomic: entry?.spendCaps.perCallAtomic ?? DEFAULT_SPEND_CAPS.perCallAtomic,
+            perDayAtomic: entry?.spendCaps.perDayAtomic ?? DEFAULT_SPEND_CAPS.perDayAtomic
+          },
+          ...ceilingAtomic === DEFAULT_CEILING_ATOMIC.toString() ? {} : { ceilingAtomic },
+          ...entry?.routerRefill === void 0 ? {} : {
+            routerRefill: {
+              belowUsd: entry.routerRefill.belowUsd,
+              tierUsd: entry.routerRefill.tierUsd
+            }
+          }
+        };
+      }),
+      networks
+    },
+    protected: file2.protected,
+    agents: agents.map(
+      ({ grants, ...profile }) => backupAgentProfileSchema.parse(
+        grants === void 0 || grants.length === 0 ? profile : { ...profile, grants }
+      )
+    ).sort(compareNamedValues),
+    swarms: [...swarms].sort(compareNamedValues),
+    movements,
+    transferReceipts,
+    ...skipped.length === 0 ? {} : { skipped: skipped.sort(compareNamedValues) }
+  };
+  if (!backupSourceSchema.safeParse(source).success) {
+    throw new BackupError("backup_invalid_input");
+  }
+  return source;
+}
 function parseBackupPlaintext(value) {
   return validateRestorePlaintext(value);
 }
@@ -47205,20 +49053,24 @@ async function restoreBackupPlaintext(options) {
   if (typeof options.home !== "string" || options.home.length === 0) {
     throw new BackupError("backup_invalid_input");
   }
+  if (options.device !== void 0 && !DEVICE_NAME_PATTERN.test(options.device)) {
+    throw new BackupError("backup_invalid_input");
+  }
   try {
     assertBytes(options.vaultKey, 32);
   } catch {
     throw new BackupError("backup_invalid_input");
   }
-  const vaultPath = join2(options.home, "vault.json");
-  const registryPath = join2(options.home, "wallets.json");
+  const vaultPath = join8(options.home, "vault.json");
+  const registryPath = join8(options.home, "wallets.json");
   let stagingHome;
   let beforePublishError;
+  let afterPublishError;
   try {
-    await mkdir2(options.home, { recursive: true, mode: 448 });
-    stagingHome = await mkdtemp(join2(options.home, ".backup-restore-"));
-    const stagedVaultPath = join2(stagingHome, "vault.json");
-    const stagedRegistryPath = join2(stagingHome, "wallets.json");
+    await mkdir8(options.home, { recursive: true, mode: 448 });
+    stagingHome = await mkdtemp(join8(options.home, ".backup-restore-"));
+    const stagedVaultPath = join8(stagingHome, "vault.json");
+    const stagedRegistryPath = join8(stagingHome, "wallets.json");
     await createVault({
       path: stagedVaultPath,
       key: options.vaultKey,
@@ -47264,16 +49116,59 @@ async function restoreBackupPlaintext(options) {
     } finally {
       await handle.close();
     }
+    const stagedV2 = plaintext.v === 2 ? await stageV2Restore({
+      plaintext,
+      stagingHome,
+      home: options.home,
+      ...options.device === void 0 ? {} : { device: options.device }
+    }) : void 0;
     const accounts = (await openVault({ path: stagedVaultPath, key: options.vaultKey })).accounts();
-    const result = {
+    const baseResult = {
       accounts,
       ...plaintext.registry.default === void 0 ? {} : { default: plaintext.registry.default },
       protected: plaintext.protected,
       networks: [...plaintext.registry.networks]
     };
+    const markerPath = join8(options.home, RESTORE_MARKER_FILE);
+    const fingerprint = restoreFingerprint(
+      plaintext,
+      stagedV2?.restoreDevice ?? options.device,
+      options.vaultKey
+    );
     await withVaultLock(vaultPath, async () => {
-      if (await pathExists(vaultPath) || await pathExists(registryPath)) {
-        throw new BackupError("vault_exists");
+      const existingVault = await pathExists2(vaultPath);
+      const existingRegistry = await pathExists2(registryPath);
+      let marker;
+      if (existingVault || existingRegistry) {
+        if (!existingVault) throw new BackupError("vault_exists");
+        marker = await readRestoreMarker(markerPath, fingerprint, options.vaultKey);
+        if (await sha256File(vaultPath) !== marker.vaultSha256) {
+          throw new BackupError("vault_exists");
+        }
+        if (existingRegistry) {
+          if (await sha256File(registryPath) !== marker.registrySha256) {
+            throw new BackupError("vault_exists");
+          }
+        } else if (await sha256File(stagedRegistryPath) !== marker.registrySha256) {
+          throw new BackupError("vault_exists");
+        }
+      } else {
+        marker = await createRestoreMarker(
+          stagedVaultPath,
+          stagedRegistryPath,
+          fingerprint,
+          options.vaultKey
+        );
+        await writeJsonAtomic(markerPath, marker, { mode: 384 });
+        await notifyRestorePublish(options.afterPublish, { kind: "marker" }, (error61) => {
+          afterPublishError = error61;
+        });
+      }
+      if (stagedV2 !== void 0) {
+        await publishV2RestoreSafety(stagedV2, options.home);
+        await notifyRestorePublish(options.afterPublish, { kind: "safety" }, (error61) => {
+          afterPublishError = error61;
+        });
       }
       try {
         await options.beforePublish?.({ vault: stagedVaultPath, registry: stagedRegistryPath });
@@ -47281,21 +49176,66 @@ async function restoreBackupPlaintext(options) {
         beforePublishError = error61;
         throw error61;
       }
+      if (!existingVault && !existingRegistry) {
+        const refreshedMarker = await createRestoreMarker(
+          stagedVaultPath,
+          stagedRegistryPath,
+          fingerprint,
+          options.vaultKey
+        );
+        if (refreshedMarker.vaultSha256 !== marker.vaultSha256 || refreshedMarker.registrySha256 !== marker.registrySha256) {
+          marker = refreshedMarker;
+          await writeJsonAtomic(markerPath, marker, { mode: 384 });
+        }
+      }
       let publishedVault = false;
-      try {
-        await link(stagedVaultPath, vaultPath);
-        publishedVault = true;
-        await link(stagedRegistryPath, registryPath);
-      } catch (error61) {
-        if (publishedVault) await rm2(vaultPath, { force: true }).catch(() => void 0);
-        throw error61;
+      if (!existingVault) {
+        try {
+          await link2(stagedVaultPath, vaultPath);
+          publishedVault = true;
+        } catch (error61) {
+          await rm2(markerPath, { force: true }).catch(() => void 0);
+          throw error61;
+        }
+        await notifyRestorePublish(options.afterPublish, { kind: "vault" }, (error61) => {
+          afterPublishError = error61;
+        });
+      }
+      if (!existingRegistry) {
+        try {
+          await link2(stagedRegistryPath, registryPath);
+        } catch (error61) {
+          if (publishedVault) await rm2(vaultPath, { force: true }).catch(() => void 0);
+          await rm2(markerPath, { force: true }).catch(() => void 0);
+          throw error61;
+        }
+        await notifyRestorePublish(options.afterPublish, { kind: "registry" }, (error61) => {
+          afterPublishError = error61;
+        });
+      }
+      if (stagedV2 !== void 0) {
+        await publishV2Restore(stagedV2, options.home, async (step) => {
+          await notifyRestorePublish(options.afterPublish, step, (error61) => {
+            afterPublishError = error61;
+          });
+        });
       }
+      await rm2(markerPath, { force: true });
     });
-    return result;
+    if (stagedV2 === void 0) return baseResult;
+    return {
+      ...baseResult,
+      agents: stagedV2.restoredAgents,
+      swarms: stagedV2.restoredSwarms,
+      movements: stagedV2.restoredMovements,
+      skipped: stagedV2.skipped,
+      conflicts: stagedV2.conflicts
+    };
   } catch (error61) {
     if (error61 === beforePublishError) throw error61;
+    if (error61 === afterPublishError) throw error61;
     if (error61 instanceof BackupError && error61.code === "vault_exists") throw error61;
-    if (isExistingFile2(error61) || await pathExists(vaultPath).catch(() => false) || await pathExists(registryPath).catch(() => false)) {
+    if (isExistingFile2(error61) || await pathExists2(vaultPath).catch(() => false) || await pathExists2(registryPath).catch(() => false)) {
       throw new BackupError("vault_exists");
     }
     throw new BackupError("backup_invalid_input");
@@ -47305,9 +49245,400 @@ async function restoreBackupPlaintext(options) {
     }
   }
 }
+async function stageV2Restore(options) {
+  const skipped = [];
+  const conflicts = [];
+  const accounts = new Map(options.plaintext.accounts.map((account) => [account.name, account]));
+  const validAgents = (options.plaintext.agents ?? []).filter((profile) => {
+    if (accounts.has(profile.wallet)) return true;
+    skipped.push({ kind: "agent", name: profile.name, reason: "missing_account" });
+    return false;
+  });
+  const validSwarms = (options.plaintext.swarms ?? []).filter((swarm) => {
+    const treasury = accounts.get(swarm.treasury.account);
+    if (treasury === void 0) {
+      if (swarm.treasury.steps.created || swarm.treasury.steps.creating) {
+        skipped.push({ kind: "swarm", name: swarm.name, reason: "missing_account" });
+        return false;
+      }
+    } else if (swarm.treasury.address !== void 0 && swarm.treasury.address.toLowerCase() !== treasury.address.toLowerCase()) {
+      skipped.push({ kind: "swarm", name: swarm.name, reason: "address_mismatch" });
+      return false;
+    }
+    for (const member of swarm.members) {
+      const account = accounts.get(member.account);
+      if (account === void 0) {
+        if (member.steps.created || member.steps.creating) {
+          skipped.push({ kind: "swarm", name: swarm.name, reason: "missing_account" });
+          return false;
+        }
+        continue;
+      }
+      if (member.address !== void 0 && member.address.toLowerCase() !== account.address.toLowerCase()) {
+        skipped.push({ kind: "swarm", name: swarm.name, reason: "address_mismatch" });
+        return false;
+      }
+    }
+    return true;
+  });
+  const allMovementLegs = /* @__PURE__ */ new Set();
+  const backupMovementIds = [];
+  const validMovements = [];
+  for (const backupMovement of options.plaintext.movements ?? []) {
+    const movement = currentMovement(backupMovement);
+    backupMovementIds.push(movement.id);
+    const legKeys = movement.legs.map((leg) => movementTransferKey(leg.from, leg.nonce));
+    for (const key of legKeys) allMovementLegs.add(key);
+    const senders = /* @__PURE__ */ new Set([
+      movement.from,
+      ...movement.treasury === void 0 ? [] : [movement.treasury],
+      ...movement.legs.map((leg) => leg.from)
+    ]);
+    if ([...senders].some((sender) => !accounts.has(sender))) {
+      skipped.push({ kind: "movement", name: movement.id, reason: "missing_account" });
+      continue;
+    }
+    validMovements.push(movement);
+  }
+  const validReceipts = [];
+  for (const receipt of options.plaintext.transferReceipts ?? []) {
+    const key = movementTransferKey(receipt.wallet, receipt.transfer.nonce);
+    if (!accounts.has(receipt.wallet)) {
+      skipped.push({ kind: "receipt", name: receipt.id, reason: "missing_account" });
+    } else if (!allMovementLegs.has(key)) {
+      skipped.push({ kind: "receipt", name: receipt.id, reason: "missing_movement" });
+    } else {
+      validReceipts.push({
+        name: receipt.id,
+        line: JSON.stringify(parseReceipt(receipt)),
+        legKey: key
+      });
+    }
+  }
+  let receiptsPath;
+  let stagedReceipts = validReceipts;
+  if (validReceipts.length > 0) {
+    receiptsPath = getVapiPaths(options.stagingHome).receipts;
+    const staged = await stageRestoreBytes(
+      receiptsPath,
+      `${validReceipts.map((receipt) => receipt.line).join("\n")}
+`
+    );
+    if (!staged) {
+      for (const receipt of validReceipts) {
+        skipped.push({ kind: "receipt", name: receipt.name, reason: "write_failed" });
+      }
+      stagedReceipts = [];
+      receiptsPath = void 0;
+    }
+  }
+  const assumedReceiptKeys = new Set(validReceipts.map((receipt) => receipt.legKey));
+  try {
+    const existingJournal = await readRestoreReceiptJournal(getVapiPaths(options.home).receipts);
+    for (const key of existingJournal.signedKeys) assumedReceiptKeys.add(key);
+  } catch {
+  }
+  const agents = [];
+  for (const profile of validAgents) {
+    const stagedPath = join8(options.stagingHome, "agents", `${profile.name}.json`);
+    if (await stageRestoreBytes(stagedPath, prettyJson(profile))) {
+      agents.push({
+        kind: "agent",
+        name: profile.name,
+        stagedPath,
+        targetPath: join8(options.home, "agents", `${profile.name}.json`)
+      });
+    } else {
+      skipped.push({ kind: "agent", name: profile.name, reason: "write_failed" });
+    }
+  }
+  let restoreDevice = options.device;
+  if (validSwarms.length > 0 && restoreDevice === void 0) {
+    try {
+      restoreDevice = deviceName({ config: await loadConfig(getVapiPaths(options.home).config) });
+    } catch {
+      for (const swarm of validSwarms) {
+        skipped.push({ kind: "swarm", name: swarm.name, reason: "write_failed" });
+      }
+    }
+  }
+  const swarms = [];
+  if (restoreDevice !== void 0) {
+    for (const value of validSwarms) {
+      const swarm = swarmFileSchema.parse({ ...value, device: restoreDevice });
+      const stagedPath = join8(options.stagingHome, "swarms", `${swarm.name}.json`);
+      if (await stageRestoreBytes(stagedPath, prettyJson(swarm))) {
+        swarms.push({
+          kind: "swarm",
+          name: swarm.name,
+          stagedPath,
+          targetPath: join8(options.home, "swarms", `${swarm.name}.json`)
+        });
+      } else {
+        skipped.push({ kind: "swarm", name: swarm.name, reason: "write_failed" });
+      }
+    }
+  }
+  const movements = [];
+  for (const movement of validMovements) {
+    const restored = reconcileRestoredMovement(movement, assumedReceiptKeys);
+    const stagedPath = join8(options.stagingHome, "movements", `${restored.id}.json`);
+    if (await stageRestoreBytes(stagedPath, serializeMovement(restored))) {
+      movements.push({
+        kind: "movement",
+        name: restored.id,
+        stagedPath,
+        targetPath: join8(options.home, "movements", `${restored.id}.json`),
+        movement: restored
+      });
+    } else {
+      skipped.push({ kind: "movement", name: restored.id, reason: "write_failed" });
+    }
+  }
+  return {
+    agents,
+    swarms,
+    movements,
+    backupMovementIds,
+    receipts: stagedReceipts,
+    signedReceiptKeys: assumedReceiptKeys,
+    ...receiptsPath === void 0 ? {} : { receiptsPath },
+    restoredAgents: [],
+    restoredSwarms: [],
+    restoredMovements: [],
+    skipped,
+    conflicts,
+    ...restoreDevice === void 0 ? {} : { restoreDevice }
+  };
+}
+async function publishV2Restore(staged, home, afterPublish) {
+  for (const file2 of staged.agents) {
+    const outcome = await publishRestoreFile(file2, staged);
+    if (outcome === "restored") staged.restoredAgents.push(file2.name);
+    if (outcome === "restored") await afterPublish?.({ kind: "agent", name: file2.name });
+  }
+  for (const file2 of staged.swarms) {
+    const outcome = await publishRestoreFile(file2, staged);
+    if (outcome === "restored") staged.restoredSwarms.push(file2.name);
+    if (outcome === "restored") await afterPublish?.({ kind: "swarm", name: file2.name });
+  }
+  const restoredMovementIds = [];
+  for (const file2 of staged.movements) {
+    const outcome = await publishRestoreFile(file2, staged);
+    if (outcome === "restored") restoredMovementIds.push(file2.movement.id);
+    if (outcome === "restored") await afterPublish?.({ kind: "movement", name: file2.name });
+  }
+  await reconcilePublishedMovements(staged, home);
+  for (const id of restoredMovementIds) {
+    try {
+      staged.restoredMovements.push(movementSummary(await readMovement(home, id)));
+    } catch {
+      staged.skipped.push({ kind: "movement", name: id, reason: "write_failed" });
+    }
+  }
+}
+async function publishV2RestoreSafety(staged, home) {
+  for (const id of staged.backupMovementIds) {
+    await markOpenLegsRestored(home, id);
+  }
+  await publishRestoreReceipts(staged, getVapiPaths(home).receipts);
+  await reconcilePublishedMovements(staged, home, true);
+}
+async function publishRestoreFile(file2, staged) {
+  try {
+    const directory = dirname5(file2.targetPath);
+    await mkdir8(directory, { recursive: true, mode: 448 });
+    await chmod2(directory, 448);
+    try {
+      await link2(file2.stagedPath, file2.targetPath);
+      await chmod2(file2.targetPath, 384);
+      return "restored";
+    } catch (error61) {
+      if (!isExistingFile2(error61)) throw error61;
+    }
+    let identical = false;
+    try {
+      const [source, target] = await Promise.all([
+        readFile9(file2.stagedPath),
+        readFile9(file2.targetPath)
+      ]);
+      identical = source.equals(target);
+    } catch {
+    }
+    if (identical) {
+      await chmod2(file2.targetPath, 384);
+      return "restored";
+    }
+    staged.conflicts.push({
+      kind: file2.kind,
+      name: file2.name,
+      path: file2.targetPath
+    });
+    return "conflict";
+  } catch {
+    staged.skipped.push({ kind: file2.kind, name: file2.name, reason: "write_failed" });
+    return "failed";
+  }
+}
+async function publishRestoreReceipts(staged, targetPath) {
+  return await withReceiptJournalLock(
+    targetPath,
+    async () => publishRestoreReceiptsLocked(staged, targetPath)
+  );
+}
+async function publishRestoreReceiptsLocked(staged, targetPath) {
+  const restored = /* @__PURE__ */ new Set();
+  if (staged.receipts.length === 0 || staged.receiptsPath === void 0) return restored;
+  let existing = "";
+  let existingLines = /* @__PURE__ */ new Set();
+  try {
+    await readFile9(staged.receiptsPath, "utf8");
+    await mkdir8(dirname5(targetPath), { recursive: true, mode: 448 });
+    try {
+      const journal = await readRestoreReceiptJournal(targetPath);
+      existing = journal.raw;
+      existingLines = journal.lines;
+      await chmod2(targetPath, 384);
+    } catch (error61) {
+      if (!isMissingFile3(error61)) throw error61;
+    }
+  } catch {
+    for (const receipt of staged.receipts) {
+      staged.skipped.push({ kind: "receipt", name: receipt.name, reason: "write_failed" });
+    }
+    return restored;
+  }
+  let needsLeadingNewline = existing.length > 0 && !existing.endsWith("\n");
+  for (const receipt of staged.receipts) {
+    if (existingLines.has(receipt.line)) {
+      restored.add(receipt.legKey);
+      continue;
+    }
+    let handle;
+    try {
+      handle = await openFile(targetPath, "a", 384);
+      await handle.chmod(384);
+      await handle.writeFile(`${needsLeadingNewline ? "\n" : ""}${receipt.line}
+`, "utf8");
+      await handle.close();
+      handle = void 0;
+      needsLeadingNewline = false;
+      existingLines.add(receipt.line);
+      restored.add(receipt.legKey);
+    } catch {
+      await handle?.close().catch(() => void 0);
+      staged.skipped.push({ kind: "receipt", name: receipt.name, reason: "write_failed" });
+    }
+  }
+  return restored;
+}
+async function reconcilePublishedMovements(staged, home, requireDurableSafety = false) {
+  const signedKeys = new Set(staged.signedReceiptKeys);
+  const journaledKeys = /* @__PURE__ */ new Set();
+  try {
+    const journal = await readRestoreReceiptJournal(getVapiPaths(home).receipts);
+    for (const key of journal.signedKeys) {
+      signedKeys.add(key);
+      journaledKeys.add(key);
+    }
+  } catch {
+  }
+  if (signedKeys.size === 0) return;
+  const unjournaledKeys = new Set([...signedKeys].filter((key) => !journaledKeys.has(key)));
+  let files;
+  try {
+    files = await readdir5(join8(home, "movements"));
+  } catch (error61) {
+    if (isMissingFile3(error61)) return;
+    if (requireDurableSafety && unjournaledKeys.size > 0) throw error61;
+    return;
+  }
+  for (const file2 of files) {
+    if (!file2.endsWith(".json")) continue;
+    const id = file2.slice(0, -5);
+    let movement;
+    try {
+      movement = await readMovement(home, id);
+    } catch (error61) {
+      if (requireDurableSafety && unjournaledKeys.size > 0) throw error61;
+      continue;
+    }
+    if (!movement.legs.some(
+      (leg) => leg.status !== "sent" && leg.status !== "cancelled" && signedKeys.has(movementTransferKey(leg.from, leg.nonce))
+    )) {
+      continue;
+    }
+    try {
+      await reconcileSignedLegs(home, id, signedKeys);
+    } catch (error61) {
+      staged.skipped.push({ kind: "movement", name: id, reason: "write_failed" });
+      if (requireDurableSafety && movement.legs.some(
+        (leg) => leg.status !== "sent" && leg.status !== "cancelled" && unjournaledKeys.has(movementTransferKey(leg.from, leg.nonce))
+      )) {
+        throw error61;
+      }
+    }
+  }
+}
+async function stageRestoreBytes(path, bytes) {
+  let handle;
+  try {
+    await mkdir8(dirname5(path), { recursive: true, mode: 448 });
+    handle = await openFile(path, "wx", 384);
+    await handle.writeFile(bytes, "utf8");
+    await handle.close();
+    return true;
+  } catch {
+    await handle?.close().catch(() => void 0);
+    return false;
+  }
+}
+function currentMovement(movement) {
+  if (movement.v === 2) return movement;
+  return {
+    ...movement,
+    v: 2,
+    legs: movement.legs.map((leg) => ({
+      ...leg,
+      from: movement.from,
+      purpose: "send"
+    }))
+  };
+}
+function reconcileRestoredMovement(movement, receiptKeys) {
+  return {
+    ...movement,
+    legs: movement.legs.map((leg) => {
+      if (leg.status === "cancelled") return leg;
+      return leg.status !== "sent" && receiptKeys.has(movementTransferKey(leg.from, leg.nonce)) ? {
+        from: leg.from,
+        to: leg.to,
+        amountUsd: leg.amountUsd,
+        purpose: leg.purpose,
+        nonce: leg.nonce,
+        status: "unknown",
+        restored: true
+      } : { ...leg, restored: true };
+    })
+  };
+}
+function movementSummary(movement) {
+  return {
+    id: movement.id,
+    from: movement.from,
+    network: movement.network,
+    createdAt: movement.createdAt,
+    pendingLegs: movement.legs.filter((leg) => leg.status === "planned").length,
+    unknownLegs: movement.legs.filter((leg) => leg.status === "unknown").length
+  };
+}
+function prettyJson(value) {
+  return `${JSON.stringify(value, null, 2)}
+`;
+}
 function parseSealed(sealed) {
   const value = JSON.parse(sealed);
-  if (!isRecord(value) || !hasExactKeys(value, RELAY_KEYS) || value.format !== RELAY_FORMAT || value.v !== RELAY_VERSION || typeof value.epk !== "string" || typeof value.nonce !== "string" || typeof value.ciphertext !== "string" || decodeBase64Url(value.epk)?.byteLength !== 32 || decodeBase64Url(value.nonce)?.byteLength !== 12 || (decodeBase64Url(value.ciphertext)?.byteLength ?? 0) < 16) {
+  if (!isRecord2(value) || !hasExactKeys(value, RELAY_KEYS) || value.format !== RELAY_FORMAT || value.v !== RELAY_VERSION || typeof value.epk !== "string" || typeof value.nonce !== "string" || typeof value.ciphertext !== "string" || decodeBase64Url(value.epk)?.byteLength !== 32 || decodeBase64Url(value.nonce)?.byteLength !== 12 || (decodeBase64Url(value.ciphertext)?.byteLength ?? 0) < 16) {
     throw new Error();
   }
   return { epk: value.epk, nonce: value.nonce, ciphertext: value.ciphertext };
@@ -47317,9 +49648,9 @@ function assertRelayKey(value) {
     throw new BackupError("relay_invalid_key");
   }
 }
-function readRelayRandomBytes(randomBytes4, length) {
+function readRelayRandomBytes(randomBytes7, length) {
   try {
-    const value = randomBytes4(length);
+    const value = randomBytes7(length);
     if (!(value instanceof Uint8Array) || value.byteLength !== length) throw new Error();
     return Buffer.from(value);
   } catch {
@@ -47375,7 +49706,7 @@ function validateRestorePlaintext(value) {
   try {
     const parsed = backupPlaintextSchema.safeParse(value);
     if (!parsed.success) throw new Error();
-    const plaintext = buildPlaintext(parsed.data);
+    const plaintext = parsed.data.v === 1 ? buildPlaintextV1(parsed.data) : buildPlaintextV2(parsed.data);
     const phrase = validateRecoveryPhrase(plaintext.phrase);
     let seed;
     try {
@@ -47398,12 +49729,22 @@ function buildRestoredRegistry(plaintext) {
   for (let index = 0; index < plaintext.accounts.length; index += 1) {
     const account = plaintext.accounts[index];
     const metadata = plaintext.registry.accounts[index];
+    const metadataV2 = plaintext.v === 2 ? plaintext.registry.accounts[index] : void 0;
     wallets[account.name] = {
       createdAt: account.createdAt,
       ...metadata.label === void 0 ? {} : { label: metadata.label },
       spendCaps: {
         perCallAtomic: metadata.spendCaps.perCallAtomic,
         perDayAtomic: metadata.spendCaps.perDayAtomic
+      },
+      ...metadataV2 === void 0 ? {} : {
+        ceilingAtomic: metadataV2.ceilingAtomic === void 0 ? DEFAULT_CEILING_ATOMIC.toString() : metadataV2.ceilingAtomic,
+        ...metadataV2.routerRefill === void 0 ? {} : {
+          routerRefill: {
+            belowUsd: metadataV2.routerRefill.belowUsd,
+            tierUsd: metadataV2.routerRefill.tierUsd
+          }
+        }
       }
     };
   }
@@ -47413,7 +49754,48 @@ function buildRestoredRegistry(plaintext) {
     wallets
   });
 }
-async function pathExists(path) {
+function restoreFingerprint(plaintext, device, vaultKey) {
+  return createHmac("sha256", vaultKey).update("vapi-backup-restore/v1\n", "utf8").update(JSON.stringify({ device: device ?? null, plaintext }), "utf8").digest("hex");
+}
+async function createRestoreMarker(vaultPath, registryPath, fingerprint, vaultKey) {
+  const marker = {
+    v: 1,
+    fingerprint,
+    vaultSha256: await sha256File(vaultPath),
+    registrySha256: await sha256File(registryPath)
+  };
+  return { ...marker, mac: restoreMarkerMac(marker, vaultKey) };
+}
+async function readRestoreMarker(path, fingerprint, vaultKey) {
+  try {
+    const marker = restoreMarkerSchema.parse(JSON.parse(await readFile9(path, "utf8")));
+    const expectedMac = restoreMarkerMac(marker, vaultKey);
+    if (marker.fingerprint !== fingerprint || !timingSafeEqual(Buffer.from(marker.mac, "hex"), Buffer.from(expectedMac, "hex"))) {
+      throw new Error();
+    }
+    return marker;
+  } catch {
+    throw new BackupError("vault_exists");
+  }
+}
+function restoreMarkerMac(marker, vaultKey) {
+  return createHmac("sha256", vaultKey).update(
+    `vapi-backup-restore-marker/v1|${marker.fingerprint}|${marker.vaultSha256}|${marker.registrySha256}`,
+    "utf8"
+  ).digest("hex");
+}
+async function sha256File(path) {
+  return createHash2("sha256").update(await readFile9(path)).digest("hex");
+}
+async function notifyRestorePublish(hook, step, rememberError) {
+  try {
+    await hook?.(step);
+  } catch (error61) {
+    rememberError(error61);
+    throw error61;
+  }
+}
+async function pathExists2(path) {
   try {
     await lstat(path);
     return true;
@@ -47429,7 +49811,7 @@ function isExistingFile2(error61) {
   return isErrorCode(error61, "EEXIST");
 }
 function isErrorCode(error61, code) {
-  return isRecord(error61) && Reflect.get(error61, "code") === code;
+  return isRecord2(error61) && Reflect.get(error61, "code") === code;
 }
 function validateBackupSourceRelationships(source, context) {
   const names = /* @__PURE__ */ new Set();
@@ -47463,7 +49845,23 @@ function validateBackupSourceRelationships(source, context) {
     }
   }
 }
-function buildPlaintext(source) {
+function validateBackupV2Uniqueness(source, context) {
+  validateUniqueValues(source.agents, (agent) => agent.name, "agent name", context);
+  validateUniqueValues(source.swarms, (swarm) => swarm.name, "swarm name", context);
+  validateUniqueValues(source.movements, (movement) => movement.id, "movement id", context);
+}
+function validateUniqueValues(values, key, label, context) {
+  if (values === void 0) return;
+  const seen = /* @__PURE__ */ new Set();
+  for (const value of values) {
+    const current = key(value);
+    if (seen.has(current)) {
+      context.addIssue({ code: "custom", message: `Duplicate ${label}.` });
+    }
+    seen.add(current);
+  }
+}
+function buildPlaintextV1(source) {
   const accounts = source.accounts.map(
     (account) => account.kind === "derived" ? {
       name: account.name,
@@ -47501,7 +49899,245 @@ function buildPlaintext(source) {
     protected: source.protected
   };
 }
+function buildPlaintextV2(source, included = { agents: true, swarms: true, movements: true }) {
+  const accounts = buildPlaintextV1({
+    phrase: source.phrase,
+    nextDerivedIndex: source.nextDerivedIndex,
+    accounts: source.accounts,
+    registry: {
+      ...source.registry.default === void 0 ? {} : { default: source.registry.default },
+      accounts: source.registry.accounts,
+      networks: source.registry.networks
+    },
+    protected: source.protected
+  }).accounts;
+  const registry2 = {
+    ...source.registry.default === void 0 ? {} : { default: source.registry.default },
+    accounts: source.registry.accounts.map((account) => ({
+      name: account.name,
+      ...account.label === void 0 ? {} : { label: account.label },
+      spendCaps: {
+        perCallAtomic: account.spendCaps.perCallAtomic,
+        perDayAtomic: account.spendCaps.perDayAtomic
+      },
+      ...account.ceilingAtomic === void 0 || account.ceilingAtomic === DEFAULT_CEILING_ATOMIC.toString() ? {} : { ceilingAtomic: account.ceilingAtomic },
+      ...account.routerRefill === void 0 ? {} : {
+        routerRefill: {
+          belowUsd: account.routerRefill.belowUsd,
+          tierUsd: account.routerRefill.tierUsd
+        }
+      }
+    })),
+    networks: [...source.registry.networks]
+  };
+  const agents = source.agents;
+  const swarms = source.swarms;
+  const movements = source.movements;
+  const transferReceipts = source.transferReceipts;
+  return {
+    v: 2,
+    phrase: source.phrase,
+    nextDerivedIndex: source.nextDerivedIndex,
+    accounts,
+    registry: registry2,
+    protected: source.protected,
+    ...included.agents !== false && agents !== void 0 && agents.length > 0 ? { agents: [...agents].sort(compareNamedValues).map(copyAgentProfile) } : {},
+    ...included.swarms !== false && swarms !== void 0 && swarms.length > 0 ? { swarms: [...swarms].sort(compareNamedValues).map(copySwarm) } : {},
+    ...included.movements !== false && movements !== void 0 && movements.length > 0 ? { movements: [...movements].sort(compareMovements).map(copyMovement) } : {},
+    ...included.movements !== false && transferReceipts !== void 0 && transferReceipts.length > 0 ? { transferReceipts: transferReceipts.map(copyTransferReceipt) } : {}
+  };
+}
+function backupCandidates(source) {
+  if (!isBackupSourceV2(source)) {
+    return [{ plaintext: buildPlaintextV1(source), omitted: [] }];
+  }
+  const candidates = [];
+  const included = { agents: true, swarms: true, movements: true };
+  const omitted = [];
+  const addCandidate = () => {
+    candidates.push({
+      plaintext: hasV2OnlyData(source, included) ? buildPlaintextV2(source, included) : buildPlaintextV1(source),
+      omitted: [...omitted]
+    });
+  };
+  addCandidate();
+  if (source.agents.length > 0) {
+    included.agents = false;
+    omitted.push("agents");
+    addCandidate();
+  }
+  if (source.swarms.length > 0) {
+    included.swarms = false;
+    omitted.push("swarms");
+    addCandidate();
+  }
+  if (source.movements.length > 0 || source.transferReceipts.length > 0) {
+    included.movements = false;
+    omitted.push("movements");
+    addCandidate();
+  }
+  return candidates;
+}
+function hasV2OnlyData(source, included) {
+  return source.registry.accounts.some(
+    (account) => account.ceilingAtomic !== void 0 && account.ceilingAtomic !== DEFAULT_CEILING_ATOMIC.toString() || account.routerRefill !== void 0
+  ) || included.agents !== false && source.agents.length > 0 || included.swarms !== false && source.swarms.length > 0 || included.movements !== false && (source.movements.length > 0 || source.transferReceipts.length > 0);
+}
+function isBackupSourceV2(source) {
+  return "agents" in source;
+}
+function copyAgentProfile(profile) {
+  return {
+    version: profile.version,
+    name: profile.name,
+    wallet: profile.wallet,
+    model: profile.model,
+    instructions: profile.instructions,
+    verifiedOnly: profile.verifiedOnly,
+    approveAboveUsd: profile.approveAboveUsd,
+    maxSteps: profile.maxSteps,
+    paused: profile.paused,
+    createdAt: profile.createdAt,
+    tools: [...profile.tools],
+    ...profile.grants === void 0 ? {} : { grants: [...profile.grants] }
+  };
+}
+function copySwarm(swarm) {
+  return swarmFileSchema.parse(swarm);
+}
+function copyMovement(movement) {
+  return toBackupMovement(movement);
+}
+function toBackupMovement(movement) {
+  if (movement.v === 1) return backupMovementSchema.parse(movement);
+  return backupMovementSchema.parse({
+    ...movement,
+    legs: movement.legs.map(
+      ({
+        restored: _restored,
+        fromAddress: _fromAddress,
+        toAddress: _toAddress,
+        addressBindingSource: _addressBindingSource,
+        ...leg
+      }) => leg
+    )
+  });
+}
+function toBackupTransferReceipt(receipt) {
+  if (receipt.quote?.asset === void 0) throw new BackupError("backup_invalid_input");
+  return copyTransferReceipt({
+    id: receipt.id,
+    timestamp: receipt.timestamp,
+    kind: "transfer",
+    wallet: receiptWallet(receipt),
+    resourceUrl: receipt.resourceUrl,
+    quote: {
+      network: receipt.quote.network,
+      asset: receipt.quote.asset,
+      amountAtomic: receipt.quote.amountAtomic
+    },
+    transfer: receipt.transfer,
+    ...receipt.error === void 0 ? {} : { error: receipt.error }
+  });
+}
+function copyTransferReceipt(receipt) {
+  const transfer = receipt.transfer;
+  const request = transfer.request;
+  return backupTransferReceiptSchema.parse({
+    id: receipt.id,
+    timestamp: receipt.timestamp,
+    kind: "transfer",
+    wallet: receipt.wallet,
+    resourceUrl: receipt.resourceUrl,
+    quote: {
+      network: receipt.quote.network,
+      asset: receipt.quote.asset,
+      amountAtomic: receipt.quote.amountAtomic
+    },
+    transfer: {
+      to: transfer.to,
+      toName: transfer.toName,
+      toKind: transfer.toKind,
+      amountAtomic: transfer.amountAtomic,
+      network: transfer.network,
+      nonce: transfer.nonce,
+      status: transfer.status,
+      txHash: transfer.txHash,
+      replayed: transfer.replayed,
+      ...transfer.reservedOn === void 0 ? {} : { reservedOn: transfer.reservedOn },
+      ...request === void 0 ? {} : {
+        request: {
+          authorization: {
+            from: request.authorization.from,
+            to: request.authorization.to,
+            value: request.authorization.value,
+            validAfter: request.authorization.validAfter,
+            validBefore: request.authorization.validBefore,
+            nonce: request.authorization.nonce
+          },
+          signature: request.signature
+        }
+      }
+    },
+    ...receipt.error === void 0 ? {} : { error: { code: receipt.error.code, message: receipt.error.message } }
+  });
+}
+async function readReceiptJournal(path) {
+  let raw;
+  try {
+    raw = await readFile9(path, "utf8");
+  } catch (error61) {
+    if (isMissingFile3(error61)) return [];
+    throw error61;
+  }
+  return raw.split("\n").filter((line) => line.trim().length > 0).map((line) => parseReceipt(JSON.parse(line)));
+}
+async function readRestoreReceiptJournal(path) {
+  let raw;
+  try {
+    raw = await readFile9(path, "utf8");
+  } catch (error61) {
+    if (isMissingFile3(error61)) return { raw: "", lines: /* @__PURE__ */ new Set(), signedKeys: /* @__PURE__ */ new Set() };
+    throw error61;
+  }
+  const lines = new Set(raw.split("\n"));
+  const signedKeys = /* @__PURE__ */ new Set();
+  for (const line of lines) {
+    if (line.trim().length === 0) continue;
+    try {
+      const receipt = parseReceipt(JSON.parse(line));
+      if (receipt.transfer !== void 0) {
+        signedKeys.add(movementTransferKey(receiptWallet(receipt), receipt.transfer.nonce));
+      }
+    } catch {
+    }
+  }
+  return { raw, lines, signedKeys };
+}
+function compareNamedValues(left, right) {
+  return left.name < right.name ? -1 : left.name > right.name ? 1 : 0;
+}
+function compareMovements(left, right) {
+  return left.createdAt.localeCompare(right.createdAt) || left.id.localeCompare(right.id);
+}
 var RELAY_KEYS = ["format", "v", "epk", "nonce", "ciphertext"];
+var HKDF_KEYS = ["name", "salt"];
+var SCRYPT_KEYS = ["name", "salt", "N", "r", "p"];
+function parseKdf(value) {
+  if (value.name === "hkdf-sha256" && hasExactKeys(value, HKDF_KEYS)) {
+    if (typeof value.salt !== "string" || decodeBase64Url(value.salt)?.byteLength !== 32) {
+      throw new BackupError("backup_unsupported");
+    }
+    return { name: "hkdf-sha256", salt: value.salt };
+  }
+  if (value.name === "scrypt" && hasExactKeys(value, SCRYPT_KEYS)) {
+    if (typeof value.salt !== "string" || decodeBase64Url(value.salt)?.byteLength !== 32 || value.N !== SCRYPT_N2 || value.r !== SCRYPT_R2 || value.p !== SCRYPT_P2) {
+      throw new BackupError("backup_unsupported");
+    }
+    return { name: "scrypt", salt: value.salt, N: SCRYPT_N2, r: SCRYPT_R2, p: SCRYPT_P2 };
+  }
+  throw new BackupError("backup_unsupported");
+}
 function buildBackupAad(header) {
   const parameters = header.kdf.name === "scrypt" ? [String(header.kdf.N), String(header.kdf.r), String(header.kdf.p)] : ["", "", ""];
   return [
@@ -47572,14 +50208,14 @@ function assertBytes(value, length) {
   }
 }
 function assertOwnerKey(ownerKey) {
-  if (!isRecord(ownerKey) || ownerKey.kdf !== "hkdf-sha256" && ownerKey.kdf !== "scrypt") {
+  if (!isRecord2(ownerKey) || ownerKey.kdf !== "hkdf-sha256" && ownerKey.kdf !== "scrypt") {
     throw new BackupError("backup_invalid_input");
   }
   assertBytes(ownerKey.key, 32);
   assertBytes(ownerKey.salt, 32);
 }
-function readRandomBytes(randomBytes4, length) {
-  const value = randomBytes4(length);
+function readRandomBytes(randomBytes7, length) {
+  const value = randomBytes7(length);
   if (!(value instanceof Uint8Array) || value.byteLength !== length) {
     throw new BackupError("backup_invalid_input");
   }
@@ -47602,7 +50238,7 @@ function isIsoUtcMilliseconds(value) {
     return false;
   }
 }
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function hasExactKeys(value, expected) {
@@ -47610,225 +50246,6 @@ function hasExactKeys(value, expected) {
   return keys.length === expected.length && expected.every((key) => Object.hasOwn(value, key));
 }
 
-// src/agent-link.ts
-import { createHash as createHash2 } from "node:crypto";
-import { mkdir as mkdir3, open as open3, stat as stat2, unlink as unlink2 } from "node:fs/promises";
-import { dirname as dirname2 } from "node:path";
-
-// src/device.ts
-var DEVICE_NAME_PATTERN = /^[a-z0-9][a-z0-9-]{0,31}$/;
-
-// src/agent-link.ts
-var AGENT_LINK_REVOKED_MESSAGE = "This agent's link was revoked or has expired. Run vapi login to link it again.";
-var AgentLinkError = class extends Error {
-  constructor(code, message) {
-    super(message);
-    this.code = code;
-    this.name = "AgentLinkError";
-  }
-  code;
-};
-var DEFAULT_AGENT_SCOPES = ["mcp:call", "router.use"];
-var ALLOWED_AGENT_SCOPES = /* @__PURE__ */ new Set([...DEFAULT_AGENT_SCOPES, "call.publish"]);
-var publicFetch = createPublicFetch({ allowPrivateNetwork: false });
-var agentSecretAccounts = (wallet) => ({
-  tokens: `vapi.agent.${wallet}.tokens`,
-  routerStake: `vapi.agent.${wallet}.router.stake`,
-  routerBalance: `vapi.agent.${wallet}.router.balance`
-});
-async function agentFetch(args, url2, init) {
-  const fetchImpl = args.fetchImpl ?? publicFetch;
-  const accessToken = await resolveAgentAccessToken(args, {});
-  const response = await safeAgentFetch(fetchImpl, url2, withBearer(init, accessToken));
-  if (response.status !== 401) return response;
-  const refreshedToken = await resolveAgentAccessToken(args, { rejectedAccessToken: accessToken });
-  const refreshedResponse = await safeAgentFetch(fetchImpl, url2, withBearer(init, refreshedToken));
-  if (refreshedResponse.status === 401) {
-    throw new AgentLinkError("not_linked", AGENT_LINK_REVOKED_MESSAGE);
-  }
-  return refreshedResponse;
-}
-async function resolveAgentAccessToken(args, options) {
-  await args.wallets.reload();
-  const link2 = args.wallets.entry(args.wallet)?.link;
-  if (link2 === void 0 || !args.secrets.available) throw notLinkedError();
-  const accounts = agentSecretAccounts(args.wallet);
-  const tokens = parseTokens(await safeGetSecret(args.secrets, accounts.tokens));
-  if (tokens === void 0) throw notLinkedError();
-  const now = args.now ?? Date.now;
-  if (options.rejectedAccessToken === void 0 && tokens.expiresAt - 6e4 > now()) {
-    return tokens.accessToken;
-  }
-  return await withAgentCredentialLock(args.wallets, link2.clientId, async () => {
-    await args.wallets.reload();
-    const currentLink = args.wallets.entry(args.wallet)?.link;
-    if (currentLink === void 0) throw notLinkedError();
-    const currentAccounts = agentSecretAccounts(args.wallet);
-    const current = parseTokens(await safeGetSecret(args.secrets, currentAccounts.tokens));
-    if (current === void 0) throw notLinkedError();
-    if (options.rejectedAccessToken !== void 0 && current.accessToken !== options.rejectedAccessToken) {
-      return current.accessToken;
-    }
-    if (options.rejectedAccessToken === void 0 && current.expiresAt - 6e4 > now()) {
-      return current.accessToken;
-    }
-    const response = await safeFetch(
-      args.fetchImpl ?? publicFetch,
-      apiEndpoint(currentLink.apiBase, "/oauth/token"),
-      {
-        method: "POST",
-        headers: { "content-type": "application/x-www-form-urlencoded" },
-        body: new URLSearchParams({
-          grant_type: "refresh_token",
-          refresh_token: current.refreshToken,
-          client_id: currentLink.clientId
-        })
-      }
-    );
-    const payload = await responseRecord(response);
-    if (!response.ok) {
-      if (response.status === 400 && stringField(payload, "error") === "invalid_grant") {
-        throw new AgentLinkError("not_linked", AGENT_LINK_REVOKED_MESSAGE);
-      }
-      throw httpError("The vAPI agent token refresh failed.");
-    }
-    const refreshed = {
-      accessToken: requiredString(payload, "access_token"),
-      refreshToken: stringField(payload, "refresh_token") ?? current.refreshToken,
-      expiresAt: now() + requiredNumber(payload, "expires_in") * 1e3,
-      scopes: stringField(payload, "scope") === void 0 ? [...current.scopes] : splitScopes(requiredString(payload, "scope"))
-    };
-    await safeSetSecret(args.secrets, currentAccounts.tokens, JSON.stringify(refreshed));
-    return refreshed.accessToken;
-  });
-}
-async function withAgentCredentialLock(wallets, clientId, operation) {
-  const digest = createHash2("sha256").update(clientId).digest("hex").slice(0, 24);
-  const lockPath = `${wallets.registryPath}.${digest}.agent-link.lock`;
-  await mkdir3(dirname2(lockPath), { recursive: true, mode: 448 });
-  const deadline = Date.now() + 3e4;
-  let handle;
-  while (!handle) {
-    try {
-      handle = await open3(lockPath, "wx", 384);
-    } catch (error61) {
-      if (!(error61 instanceof Error && "code" in error61 && error61.code === "EEXIST")) throw error61;
-      await removeStaleCredentialLock(lockPath);
-      if (Date.now() >= deadline) {
-        throw httpError("Timed out waiting to update the agent credentials.");
-      }
-      await new Promise((resolve) => setTimeout(resolve, 20));
-    }
-  }
-  try {
-    return await operation();
-  } finally {
-    await handle.close();
-    await unlink2(lockPath).catch(() => void 0);
-  }
-}
-async function removeStaleCredentialLock(path) {
-  try {
-    const metadata = await stat2(path);
-    if (Date.now() - metadata.mtimeMs > 5 * 6e4) await unlink2(path);
-  } catch {
-  }
-}
-async function safeGetSecret(secrets, account) {
-  try {
-    return await secrets.get(account);
-  } catch {
-    throw httpError("The agent tokens could not be read from the OS secret store.");
-  }
-}
-async function safeSetSecret(secrets, account, value) {
-  try {
-    await secrets.set(account, value);
-  } catch {
-    throw httpError("The agent credentials could not be stored in the OS secret store.");
-  }
-}
-function parseTokens(value) {
-  if (value === void 0) return void 0;
-  let parsed;
-  try {
-    parsed = JSON.parse(value);
-  } catch {
-    return void 0;
-  }
-  if (!isRecord2(parsed)) return void 0;
-  const accessToken = stringField(parsed, "accessToken");
-  const refreshToken = stringField(parsed, "refreshToken");
-  const expiresAt = numberField(parsed, "expiresAt");
-  const scopes = parsed.scopes;
-  if (accessToken === void 0 || refreshToken === void 0 || expiresAt === void 0 || !Array.isArray(scopes) || scopes.some((scope) => typeof scope !== "string")) {
-    return void 0;
-  }
-  return { accessToken, refreshToken, expiresAt, scopes };
-}
-function withBearer(init, accessToken) {
-  const headers = new Headers(init?.headers);
-  headers.set("authorization", `Bearer ${accessToken}`);
-  return { ...init, headers };
-}
-async function safeFetch(fetchImpl, input2, init) {
-  try {
-    return await fetchImpl(input2, init);
-  } catch {
-    throw httpError("The vAPI agent link request failed.");
-  }
-}
-async function safeAgentFetch(fetchImpl, input2, init) {
-  try {
-    return await fetchImpl(input2, init);
-  } catch {
-    throw httpError("The vAPI agent request failed.");
-  }
-}
-function notLinkedError() {
-  return new AgentLinkError("not_linked", "Run vapi login first.");
-}
-function httpError(message) {
-  return new AgentLinkError("http", message);
-}
-function apiEndpoint(apiBase, path) {
-  return new URL(path, new URL(apiBase).origin).toString();
-}
-async function responseRecord(response) {
-  let payload;
-  try {
-    payload = await response.json();
-  } catch {
-    throw httpError("The vAPI agent link response was invalid.");
-  }
-  if (!isRecord2(payload)) throw httpError("The vAPI agent link response was invalid.");
-  return payload;
-}
-function isRecord2(value) {
-  return typeof value === "object" && value !== null && !Array.isArray(value);
-}
-function stringField(record2, key) {
-  const value = record2[key];
-  return typeof value === "string" ? value : void 0;
-}
-function numberField(record2, key) {
-  const value = record2[key];
-  return typeof value === "number" && Number.isFinite(value) ? value : void 0;
-}
-function requiredString(record2, key) {
-  const value = stringField(record2, key);
-  if (value === void 0) throw httpError("The vAPI agent link response was invalid.");
-  return value;
-}
-function requiredNumber(record2, key) {
-  const value = numberField(record2, key);
-  if (value === void 0) throw httpError("The vAPI agent link response was invalid.");
-  return value;
-}
-function splitScopes(scope) {
-  return scope.split(/\s+/u).filter(Boolean);
-}
-
 // src/cloud-backup.ts
 var ERROR_MESSAGES2 = {
   relay_create_failed: "The backup approval request could not be started. Try again.",
@@ -47854,8 +50271,8 @@ var RELAY_PAYLOAD_FORMAT = "vapi-vault-relay-payload";
 var OWNER_PATTERN = /^0x[0-9a-f]{40}$/u;
 var BASE64URL_PATTERN2 = /^[A-Za-z0-9_-]*$/u;
 var ISO_UTC_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}\.\d{3}Z$/u;
-var HKDF_KEYS = ["name", "salt"];
-var SCRYPT_KEYS = ["name", "salt", "N", "r", "p"];
+var HKDF_KEYS2 = ["name", "salt"];
+var SCRYPT_KEYS2 = ["name", "salt", "N", "r", "p"];
 var ENROLL_PAYLOAD_KEYS = ["format", "v", "purpose", "owner", "device", "kdf", "key"];
 var RESTORE_PAYLOAD_KEYS = [...ENROLL_PAYLOAD_KEYS, "vault"];
 var STORED_KEY_KEYS = ["owner", "device", "kdf", "key"];
@@ -48037,7 +50454,7 @@ async function uploadBackupLocked(options, signal) {
   try {
     let vaultFile;
     try {
-      vaultFile = await readVaultFileUnlocked(join3(options.store.home, "vault.json"));
+      vaultFile = await readVaultFileUnlocked(join9(options.store.home, "vault.json"));
     } catch (error61) {
       if (error61 instanceof VaultError && error61.code === "not_found") {
         return { status: "skipped", reason: "no_vault" };
@@ -48046,7 +50463,7 @@ async function uploadBackupLocked(options, signal) {
     }
     try {
       vaultKey = vaultFile.protected ? await unlockProtectedVault({
-        path: join3(options.store.home, "vault.json"),
+        path: join9(options.store.home, "vault.json"),
         secrets: options.secrets,
         env: options.env,
         ...options.now === void 0 ? {} : { now: options.now }
@@ -48057,7 +50474,8 @@ async function uploadBackupLocked(options, signal) {
     const source = await exportBackupSource({
       store: options.store,
       vaultKey,
-      ...options.networks === void 0 ? {} : { networks: options.networks }
+      ...options.networks === void 0 ? {} : { networks: options.networks },
+      ...options.agentProfileSchema === void 0 ? {} : { agentProfileSchema: options.agentProfileSchema }
     });
     salt = decodeBase64Url2(stored.kdf.salt);
     if (salt?.byteLength !== 32) return { status: "skipped", reason: "rejected" };
@@ -48080,8 +50498,8 @@ async function uploadBackupLocked(options, signal) {
         `wallet:${selected.name}`,
         async () => {
           await options.store.reload();
-          const link2 = options.store.entry(selected.name)?.link;
-          if (!linkMatches(link2, stored.owner, options.apiBase)) {
+          const link3 = options.store.entry(selected.name)?.link;
+          if (!linkMatches(link3, stored.owner, options.apiBase)) {
             throw new AgentLinkError("not_linked", "Run vapi login first.");
           }
           return await agentFetch(
@@ -48092,7 +50510,7 @@ async function uploadBackupLocked(options, signal) {
               ...options.fetchImpl === void 0 ? {} : { fetchImpl: options.fetchImpl },
               ...now === void 0 ? {} : { now: () => now().getTime() }
             },
-            apiEndpoint2(link2.apiBase, "/api/agents/self/backup"),
+            apiEndpoint2(link3.apiBase, "/api/agents/self/backup"),
             {
               method: "PUT",
               headers: { "content-type": "application/json" },
@@ -48122,13 +50540,18 @@ async function uploadBackupLocked(options, signal) {
       status: "uploaded",
       account: selected.name,
       bytes: created.bytes,
-      uploadedAt
+      uploadedAt,
+      ...created.omitted === void 0 ? {} : { omitted: created.omitted },
+      ...source.skipped === void 0 ? {} : { skipped: source.skipped }
     };
   } catch (error61) {
     if (signal.aborted) return { status: "skipped", reason: "timeout" };
     if (error61 instanceof AgentLinkError && error61.code === "not_linked") {
       return { status: "skipped", reason: "not_linked" };
     }
+    if (error61 instanceof BackupError && error61.code === "backup_snapshot_busy") {
+      return { status: "skipped", reason: "snapshot_busy" };
+    }
     return { status: "skipped", reason: "rejected" };
   } finally {
     vaultKey?.fill(0);
@@ -48146,6 +50569,7 @@ async function restoreFromOwner(options) {
       plaintext: options.payload.vault,
       home: options.home,
       vaultKey: options.vaultKey,
+      device: options.payload.device,
       ...options.now === void 0 ? {} : { now: options.now },
       beforePublish: async ({ vault }) => {
         if (options.payload.vault?.protected === true) {
@@ -48216,7 +50640,7 @@ function parseRelayPayload(value) {
   if (!hasExactKeys2(value, expectedKeys) || value.format !== RELAY_PAYLOAD_FORMAT || value.v !== 1 || typeof value.owner !== "string" || !OWNER_PATTERN.test(value.owner) || typeof value.device !== "string" || !DEVICE_NAME_PATTERN.test(value.device) || !isRecord3(value.kdf) || typeof value.key !== "string") {
     throw new CloudBackupError("payload_invalid");
   }
-  const kdf = parseKdf(value.kdf);
+  const kdf = parseKdf2(value.kdf);
   const key = decodeBase64Url2(value.key);
   if (kdf === void 0 || key?.byteLength !== 32) {
     key?.fill(0);
@@ -48246,7 +50670,7 @@ function parseStoredBackupKey(value) {
   if (!isRecord3(value) || !hasExactKeys2(value, STORED_KEY_KEYS) || typeof value.owner !== "string" || !OWNER_PATTERN.test(value.owner) || typeof value.device !== "string" || !DEVICE_NAME_PATTERN.test(value.device) || !isRecord3(value.kdf) || typeof value.key !== "string") {
     return void 0;
   }
-  const kdf = parseKdf(value.kdf);
+  const kdf = parseKdf2(value.kdf);
   const key = decodeBase64Url2(value.key);
   if (kdf === void 0 || key?.byteLength !== 32) {
     key?.fill(0);
@@ -48256,11 +50680,11 @@ function parseStoredBackupKey(value) {
   key.fill(0);
   return { owner: value.owner, device: value.device, kdf, key: copiedKey };
 }
-function parseKdf(value) {
-  if (value.name === "hkdf-sha256" && hasExactKeys2(value, HKDF_KEYS) && typeof value.salt === "string" && isBase64UrlBytes(value.salt, 32)) {
+function parseKdf2(value) {
+  if (value.name === "hkdf-sha256" && hasExactKeys2(value, HKDF_KEYS2) && typeof value.salt === "string" && isBase64UrlBytes(value.salt, 32)) {
     return { name: "hkdf-sha256", salt: value.salt };
   }
-  if (value.name === "scrypt" && hasExactKeys2(value, SCRYPT_KEYS) && typeof value.salt === "string" && isBase64UrlBytes(value.salt, 32) && value.N === 131072 && value.r === 8 && value.p === 1) {
+  if (value.name === "scrypt" && hasExactKeys2(value, SCRYPT_KEYS2) && typeof value.salt === "string" && isBase64UrlBytes(value.salt, 32) && value.N === 131072 && value.r === 8 && value.p === 1) {
     return { name: "scrypt", salt: value.salt, N: 131072, r: 8, p: 1 };
   }
   return void 0;
@@ -48295,11 +50719,11 @@ async function selectLinkedAccount(options, owner) {
   }
   return void 0;
 }
-function linkMatches(link2, owner, apiBase) {
-  if (link2 === void 0 || link2.owner.toLowerCase() !== owner.toLowerCase()) return false;
+function linkMatches(link3, owner, apiBase) {
+  if (link3 === void 0 || link3.owner.toLowerCase() !== owner.toLowerCase()) return false;
   if (apiBase === void 0) return true;
   try {
-    return new URL(link2.apiBase).origin === new URL(apiBase).origin;
+    return new URL(link3.apiBase).origin === new URL(apiBase).origin;
   } catch {
     return false;
   }
@@ -48391,6 +50815,7 @@ export {
   awaitRelay,
   backupKeyAccount,
   backupStateAccount,
+  buildRelayRestorePayload,
   forgetBackupKey,
   readBackupKey,
   readCloudBackupState,