@zeroxyz/cli 0.0.40 → 0.0.42

package/dist/index.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env node
 
 // src/index.ts
-import { homedir as homedir8 } from "os";
-import { join as join9 } from "path";
+import { homedir as homedir9 } from "os";
+import { join as join11 } from "path";
 
 // package.json
 var package_default = {
   name: "@zeroxyz/cli",
-  version: "0.0.40",
+  version: "0.0.42",
   type: "module",
   bin: {
     zero: "dist/index.js",
@@ -61,7 +61,7 @@ var package_default = {
 };
 
 // src/app.ts
-import { Command as Command13 } from "commander";
+import { Command as Command14 } from "commander";
 
 // src/commands/auth-command.ts
 import { homedir } from "os";
@@ -204,8 +204,7 @@ var searchResultSchema = z.object({
   cost: z.object({ amount: z.string(), asset: z.string() }),
   reviewCount: z.number().optional(),
   rating: ratingSchema,
-  availabilityStatus: z.enum(["healthy", "degraded", "down", "unknown"]).nullable().optional(),
-  displayStatus: z.enum(["healthy", "stable", "degraded", "unhealthy", "unknown"]).optional(),
+  availabilityStatus: z.enum(["healthy", "unknown", "down"]).nullable().optional(),
   // Pass-through: API stamps this on Zero-published / withzero.{ai,xyz}
   // services so `zero search --json` consumers can render their own
   // provenance UI. CLI doesn't render a badge today.
@@ -258,8 +257,7 @@ var capabilityResponseSchema = z.object({
       priority: z.number()
     })
   ).nullable(),
-  availabilityStatus: z.enum(["healthy", "degraded", "down", "unknown"]).nullable().optional(),
-  displayStatus: z.enum(["healthy", "stable", "degraded", "unhealthy", "unknown"]).optional(),
+  availabilityStatus: z.enum(["healthy", "unknown", "down"]).nullable().optional(),
   activationCount: z.number().optional(),
   lastUsedAt: z.string().nullable().optional(),
   lastSuccessfullyRanAt: z.string().nullable().optional(),
@@ -360,6 +358,9 @@ var signResultSchema = z.object({
   signature: z.string(),
   walletAddress: z.string()
 });
+var migrateResultSchema = z.object({
+  transactionHash: z.string()
+});
 var deviceStartResultSchema = z.object({
   deviceCode: z.string(),
   userCode: z.string(),
@@ -583,16 +584,36 @@ var ApiService = class _ApiService {
     });
     return createBugReportResponseSchema.parse(json);
   };
+  // Mints a one-time onramp URL for the caller's wallet. Two paths, picked by
+  // which identity is available:
+  //   • BYO key present (this.account) → /v1/wallet/fund-url, proving ownership
+  //     with an EIP-191 signature. Honors the `provider` choice.
+  //   • No key but a session (managed/runner) → /v1/users/me/fund-url, which
+  //     resolves the user's managed wallet server-side from the Bearer. Coinbase
+  //     only (the managed onramp doesn't take a provider), so `provider` is
+  //     ignored on this path.
+  // Returns null on any failure so callers can fall back to manual transfer.
   getFundingUrl = async (amount, provider = "coinbase") => {
     try {
-      const params = new URLSearchParams({ provider });
-      if (amount) params.set("amount", amount);
-      const json = await this.request(
-        "GET",
-        `/v1/wallet/fund-url?${params.toString()}`
-      );
-      const parsed = z.object({ url: z.string() }).parse(json);
-      return parsed.url;
+      if (this.account) {
+        const params = new URLSearchParams({ provider });
+        if (amount) params.set("amount", amount);
+        const json = await this.request(
+          "GET",
+          `/v1/wallet/fund-url?${params.toString()}`,
+          void 0,
+          { auth: "wallet-attributed" }
+        );
+        return z.object({ url: z.string() }).parse(json).url;
+      }
+      if (this.credentials.kind === "session") {
+        const params = new URLSearchParams();
+        if (amount) params.set("amount", amount);
+        const qs = params.toString() ? `?${params.toString()}` : "";
+        const json = await this.request("GET", `/v1/users/me/fund-url${qs}`);
+        return z.object({ url: z.string(), walletAddress: z.string() }).parse(json).url;
+      }
+      return null;
     } catch {
       return null;
     }
@@ -605,6 +626,15 @@ var ApiService = class _ApiService {
     const json = await this.request("POST", "/v1/users/me/wallets/provision");
     return userWalletDtoSchema.parse(json);
   };
+  // Hands a BYO-wallet-signed EIP-3009 authorization to the server, which
+  // broadcasts it on Base via the gas-paying relayer (sweeping USDC into the
+  // caller's provisioned wallet). Session-authed.
+  migrateWallet = async (authorization) => {
+    const json = await this.request("POST", "/v1/users/me/wallets/migrate", {
+      authorization
+    });
+    return migrateResultSchema.parse(json);
+  };
   signTypedDataRemote = async (typedData) => {
     const json = await this.request("POST", "/v1/users/me/sign-typed-data", {
       typedData
@@ -931,6 +961,7 @@ import { Command as Command4 } from "commander";
 import { formatUnits as formatUnits2 } from "viem";
 
 // src/services/payment-service.ts
+import { randomBytes } from "crypto";
 import {
   adaptViemWallet,
   convertViemChainToRelayChain,
@@ -951,7 +982,7 @@ import {
   formatUnits,
   http
 } from "viem";
-import { base, baseSepolia } from "viem/chains";
+import { base, baseSepolia, tempo as viemTempoChain } from "viem/chains";
 var SessionCloseFailedError = class extends Error {
   session;
   response;
@@ -1025,6 +1056,32 @@ var ERC20_BALANCE_ABI = [
     type: "function"
   }
 ];
+var ERC20_TRANSFER_ABI = [
+  {
+    inputs: [
+      { name: "to", type: "address" },
+      { name: "amount", type: "uint256" }
+    ],
+    name: "transfer",
+    outputs: [{ name: "", type: "bool" }],
+    stateMutability: "nonpayable",
+    type: "function"
+  }
+];
+var USDC_BASE_SWEEP_DOMAIN = { name: "USD Coin", version: "2" };
+var SWEEP_AUTHORIZATION_TTL_S = 900;
+var TEMPO_FEE_RESERVE_RAW = 10000n;
+var EIP3009_TRANSFER_TYPES = {
+  // biome-ignore lint/style/useNamingConvention: EIP-712 primaryType must match the on-chain type name
+  TransferWithAuthorization: [
+    { name: "from", type: "address" },
+    { name: "to", type: "address" },
+    { name: "value", type: "uint256" },
+    { name: "validAfter", type: "uint256" },
+    { name: "validBefore", type: "uint256" },
+    { name: "nonce", type: "bytes32" }
+  ]
+};
 var decodeSessionReceiptHeader = (header) => {
   if (!header) return null;
   try {
@@ -1231,11 +1288,6 @@ var PaymentService = class {
           `Insufficient pathUSD on Tempo testnet: have ${formatUnits(tempoBalance, 6)}, need ${capturedAmount}. Fund your wallet with the Tempo testnet faucet: https://docs.tempo.xyz/quickstart/faucet`
         );
       }
-      if (this.config.managed) {
-        throw new Error(
-          `Insufficient USDC on Tempo: have ${formatUnits(tempoBalance, 6)}, need ${capturedAmount}. Managed wallets can't auto-bridge from Base yet \u2014 fund your Tempo wallet${this.account ? ` (${this.account.address})` : ""} directly, or set a local ZERO_PRIVATE_KEY to bridge.`
-        );
-      }
       await this.bridgeToTempo(requiredRaw, onProgress);
     }
     return capturedAmount;
@@ -1475,6 +1527,115 @@ var PaymentService = class {
     ]);
     return { amount: formatUnits(baseRaw + tempoRaw, 6), asset: "USDC" };
   };
+  // Total USDC across both legs (Base + Tempo) for the configured wallet — what
+  // the migrate confirmation prompt quotes. Best-effort: a chain whose RPC read
+  // fails counts as 0 rather than blocking the other leg.
+  getSweepableBalance = async () => {
+    const [baseRaw, tempoRaw] = await Promise.all([
+      this.getBalanceRaw("base").catch(() => 0n),
+      this.getBalanceRaw("tempo").catch(() => 0n)
+    ]);
+    const raw = baseRaw + tempoRaw;
+    return { raw, usdc: formatUnits(raw, 6) };
+  };
+  // Sweeps all USDC from the configured wallet into `to` across Base and Tempo.
+  // Each leg is independent and never throws — failures are captured in the
+  // returned per-chain result so the caller can decide whether to retire the
+  // source key.
+  migrateAllUsdc = async (to, relayer) => {
+    const baseResult = await this.sweepBaseUsdc(to, relayer);
+    const tempoResult = await this.sweepTempoUsdc(to);
+    return [baseResult, tempoResult];
+  };
+  // Base leg: sign an EIP-3009 transferWithAuthorization for the full balance
+  // and hand it to the relayer, which broadcasts it gaslessly.
+  sweepBaseUsdc = async (to, relayer) => {
+    try {
+      if (!this.account) throw new Error("No wallet configured");
+      const balance = await this.getBalanceRaw("base");
+      if (balance <= 0n) return { chain: "base", status: "skipped" };
+      const nowS = Math.floor(Date.now() / 1e3);
+      const message = {
+        from: this.account.address,
+        to,
+        value: balance,
+        validAfter: 0n,
+        validBefore: BigInt(nowS + SWEEP_AUTHORIZATION_TTL_S),
+        nonce: `0x${randomBytes(32).toString("hex")}`
+      };
+      const signature = await this.account.signTypedData({
+        domain: {
+          name: USDC_BASE_SWEEP_DOMAIN.name,
+          version: USDC_BASE_SWEEP_DOMAIN.version,
+          chainId: BASE_CHAIN_ID,
+          verifyingContract: USDC_BASE
+        },
+        types: EIP3009_TRANSFER_TYPES,
+        primaryType: "TransferWithAuthorization",
+        message
+      });
+      const { transactionHash } = await relayer.migrateWallet({
+        from: message.from,
+        to: message.to,
+        value: message.value.toString(),
+        validAfter: message.validAfter.toString(),
+        validBefore: message.validBefore.toString(),
+        nonce: message.nonce,
+        signature
+      });
+      return {
+        chain: "base",
+        status: "swept",
+        amount: formatUnits(balance, 6),
+        txHash: transactionHash
+      };
+    } catch (err) {
+      return { chain: "base", status: "failed", error: err.message };
+    }
+  };
+  // Tempo leg: self-broadcast an ERC-20 transfer paying the fee in USDC via
+  // `feeToken` (no native gas token needed). Uses viem's tempo chain for its
+  // type-0x76 serializer; reserves a tiny amount to cover the fee.
+  sweepTempoUsdc = async (to) => {
+    try {
+      if (!this.account) throw new Error("No wallet configured");
+      const balance = await this.getBalanceRaw("tempo");
+      if (balance <= TEMPO_FEE_RESERVE_RAW) {
+        return { chain: "tempo", status: "skipped" };
+      }
+      const amount = balance - TEMPO_FEE_RESERVE_RAW;
+      const wallet = createWalletClient({
+        account: this.account,
+        chain: viemTempoChain,
+        transport: http()
+      });
+      const txHash = await wallet.writeContract({
+        address: USDC_TEMPO,
+        abi: ERC20_TRANSFER_ABI,
+        functionName: "transfer",
+        args: [to, amount],
+        feeToken: USDC_TEMPO
+        // biome-ignore lint/suspicious/noExplicitAny: tempo feeToken param
+      });
+      const publicClient = createPublicClient({
+        chain: viemTempoChain,
+        transport: http()
+      });
+      await publicClient.waitForTransactionReceipt({ hash: txHash });
+      return {
+        chain: "tempo",
+        status: "swept",
+        amount: formatUnits(amount, 6),
+        txHash
+      };
+    } catch (err) {
+      return {
+        chain: "tempo",
+        status: "failed",
+        error: err.message
+      };
+    }
+  };
 };
 
 // src/util/infer-schema.ts
@@ -1726,55 +1887,6 @@ var fetchCommand = (appContext) => new Command4("fetch").description(
       } else {
         resolvedUrl = url;
       }
-      if (!url && options.capability && !stateService.findSearchContextByCapability(options.capability)) {
-        try {
-          let capName = resolvedCapabilityName;
-          if (capName === void 0) {
-            const cap = await apiService.getCapability(options.capability);
-            capName = cap.name;
-          }
-          const searchResult = await apiService.search({ query: capName });
-          const matchedEntry = searchResult.capabilities.find(
-            (c) => c.slug === options.capability || c.id === options.capability
-          );
-          const slugFoundInResults = Boolean(matchedEntry);
-          stateService.saveLastSearch({
-            searchId: searchResult.searchId,
-            capabilities: searchResult.capabilities.map((c) => ({
-              position: c.position,
-              id: c.id,
-              slug: c.slug,
-              url: c.url,
-              urlTemplate: c.urlTemplate ?? null,
-              displayCostAmount: c.cost.amount
-            }))
-          });
-          analyticsService.capture("search_executed", {
-            query: truncateQuery(capName),
-            queryLength: capName.length,
-            resultCount: searchResult.capabilities.length,
-            searchId: searchResult.searchId,
-            total: searchResult.total,
-            hasMore: searchResult.hasMore,
-            json: false,
-            triggeredBy: "slug_handoff",
-            slugFoundInResults
-          });
-          analyticsService.capture("capability_viewed", {
-            // Existing field preserved as the raw --capability
-            // input for back-compat.
-            capabilityId: options.capability,
-            // New canonical identifier fields hydrated from the
-            // resolved search result (when the slug was found).
-            capabilityUid: matchedEntry?.id,
-            capabilitySlug: matchedEntry?.slug,
-            fromLastSearch: false,
-            searchId: searchResult.searchId,
-            triggeredBy: "slug_handoff"
-          });
-        } catch {
-        }
-      }
       let resolvedBody;
       try {
         resolvedBody = resolveRequestBody(
@@ -1830,6 +1942,7 @@ var fetchCommand = (appContext) => new Command4("fetch").description(
       const capabilitySlug = matchCtx?.capabilitySlug ?? null;
       const searchId = matchCtx?.searchId;
       const resultRank = matchCtx?.resultRank;
+      const fetchOrigin = matchCtx ? "from_search" : options.capability ? "direct_slug" : "direct_url";
       const matchedDisplayCostAmount = matchCtx?.displayCostAmount;
       const skipReasons = [];
       if (!apiService.walletAddress) {
@@ -2047,6 +2160,9 @@ var fetchCommand = (appContext) => new Command4("fetch").description(
         resultRank: resultRank ?? void 0,
         runId: runId ?? void 0,
         runTracked: !!runId,
+        // A NULL searchId on a direct_slug fetch is correct here,
+        // not a funnel gap to paper over.
+        fetchOrigin,
         ...fetchError && { error: truncateError(fetchError.message) }
       });
       const isFetchFailure = Boolean(fetchError) || !finalResponse || typeof status === "number" && (status < 200 || status >= 300);
@@ -2305,7 +2421,7 @@ var formatCapability = (capability) => {
   const lines = [];
   lines.push(capability.name);
   lines.push(`  Rating: ${formatRating(capability.rating)}`);
-  lines.push(`  Status: ${capability.displayStatus ?? "unknown"}`);
+  lines.push(`  Status: ${capability.availabilityStatus ?? "unknown"}`);
   lines.push(...formatCost(capability));
   lines.push(`  URL: ${capability.url}`);
   lines.push(`  Method: ${capability.method}`);
@@ -2547,6 +2663,8 @@ var AGENT_TOOLS = [
   },
   { name: "Cursor", detectDir: ".cursor", skillsDir: ".cursor/skills" }
 ];
+var HOOK_FILES = ["auto-approve-zero.sh", "zero-context.sh"];
+var ZERO_SANDBOX_DOMAIN = "*.zero.xyz";
 var findResourceDir = (startDir, resourceName) => {
   let current = startDir;
   while (true) {
@@ -2616,10 +2734,9 @@ var installHook = (home, verbose = false) => {
   const zeroHooksDir = join3(home, ".zero", "hooks");
   mkdirSync3(zeroHooksDir, { recursive: true });
   if (verbose) stepInfo(`staged hook dir at ${zeroHooksDir}`);
-  const hookFiles = ["auto-approve-zero.sh", "zero-context.sh"];
   const hookDests = {};
   const hooksSourceDir = findResourceDir(getCliModuleDir(), "hooks");
-  for (const hookFile of hookFiles) {
+  for (const hookFile of HOOK_FILES) {
     const hookSource = join3(hooksSourceDir, hookFile);
     const hookDest = join3(zeroHooksDir, hookFile);
     copyFile(hookSource, hookDest);
@@ -2722,12 +2839,15 @@ var installHook = (home, verbose = false) => {
     network.allowedDomains = [];
   }
   const allowedDomains = network.allowedDomains;
-  const zeroDomain = "*.zero.xyz";
-  if (!allowedDomains.includes(zeroDomain)) {
-    allowedDomains.push(zeroDomain);
-    if (verbose) stepInfo(`sandbox.network.allowedDomains += ${zeroDomain}`);
+  if (!allowedDomains.includes(ZERO_SANDBOX_DOMAIN)) {
+    allowedDomains.push(ZERO_SANDBOX_DOMAIN);
+    if (verbose) {
+      stepInfo(`sandbox.network.allowedDomains += ${ZERO_SANDBOX_DOMAIN}`);
+    }
   } else if (verbose) {
-    stepInfo(`${zeroDomain} already in sandbox allowlist \u2014 not modified`);
+    stepInfo(
+      `${ZERO_SANDBOX_DOMAIN} already in sandbox allowlist \u2014 not modified`
+    );
   }
   writeFileSync3(settingsPath, `${JSON.stringify(settings, null, 2)}
 `);
@@ -2763,6 +2883,14 @@ var removeConflictingSkills = (home) => {
   }
   return removed;
 };
+var getBundledSkillNames = () => {
+  try {
+    const skillsSourceDir = findResourceDir(getCliModuleDir(), "skills");
+    return readdirSync(skillsSourceDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
+  } catch {
+    return ["zero"];
+  }
+};
 var installSkills = (home, verbose = false) => {
   const skillsSourceDir = findResourceDir(getCliModuleDir(), "skills");
   const skillDirs = readdirSync(skillsSourceDir, { withFileTypes: true }).filter((d) => d.isDirectory()).map((d) => d.name);
@@ -3306,8 +3434,16 @@ var formatRatingBadge = (rating) => {
   return `${successPct} success \xB7 ${reviews} reviews`;
 };
 var formatStatusBadge = (status) => {
-  if (!status || status === "unknown") return "";
-  return ` \u2014 ${status}`;
+  switch (status) {
+    case "healthy":
+      return ` \u2014 ${color.green("\u2713 healthy")}`;
+    case "down":
+      return ` \u2014 ${color.red("\u2717 down")}`;
+    case "unknown":
+      return ` \u2014 ${color.yellow("? unknown")}`;
+    default:
+      return "";
+  }
 };
 var formatSearchResults = (results) => {
   if (results.length === 0) return "No capabilities found.";
@@ -3316,7 +3452,7 @@ var formatSearchResults = (results) => {
     const displayName = r.brandName ? `${r.brandName} ${baseName}` : baseName;
     const displayDescription = r.whatItDoes ?? r.description;
     const ratingBadge = formatRatingBadge(r.rating);
-    const statusBadge = formatStatusBadge(r.displayStatus);
+    const statusBadge = formatStatusBadge(r.availabilityStatus);
     const costLabel = r.cost.amount === "0" ? "Free" : r.cost.amount === "unknown" ? "variable pricing" : `$${r.cost.amount}/call`;
     return `  ${r.position}. ${displayName} \u2014 ${costLabel} \u2014 ${ratingBadge}${statusBadge}
      "${displayDescription}"`;
@@ -3327,7 +3463,7 @@ var searchCommand = (appContext) => new Command9("search").description("Search f
   `Maximum cost per call in USD (default: ${DEFAULT_MAX_COST_USD})`
 ).option("--protocol <protocol>", "Payment protocol (x402 or mpp)").option(
   "--status <status>",
-  "Filter by availability (healthy, unknown, down). Defaults to healthy when neither --status nor --all is set; pass --all to see everything."
+  "Filter by availability (healthy, unknown, down). Default (unset) returns healthy + unknown with healthy first; pass 'healthy' for only-healthy, or --all to include everything."
 ).option("--all", "Disable default quality filtering").option(
   "--source <source>",
   "Only show results from this crawl source (e.g. mpp, bazaar)"
@@ -3362,12 +3498,8 @@ var searchCommand = (appContext) => new Command9("search").description("Search f
         process.exitCode = 1;
         return;
       }
-      let effectiveStatus = options.status;
-      let appliedDefaultStatus = false;
-      if (effectiveStatus === void 0 && !options.all) {
-        effectiveStatus = "healthy";
-        appliedDefaultStatus = true;
-      }
+      const effectiveStatus = options.status;
+      const appliedDefaultStatus = effectiveStatus === void 0 && !options.all;
       const result = await apiService.search({
         query,
         offset: options.offset,
@@ -3464,15 +3596,264 @@ Read the full terms at: ${TERMS_URL}
   }
 });
 
-// src/commands/wallet-command.ts
-import { existsSync as existsSync3, readFileSync as readFileSync7 } from "fs";
+// src/commands/uninstall-command.ts
+import {
+  existsSync as existsSync3,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync7,
+  rmSync as rmSync2,
+  writeFileSync as writeFileSync4
+} from "fs";
 import { homedir as homedir4 } from "os";
 import { join as join4 } from "path";
 import { Command as Command11 } from "commander";
+var removeSkills = (home, verbose = false) => {
+  const skillNames = getBundledSkillNames();
+  const removed = [];
+  for (const tool of AGENT_TOOLS) {
+    const toolSkillsPath = join4(home, tool.skillsDir);
+    if (!existsSync3(toolSkillsPath)) {
+      if (verbose) {
+        stepInfo(
+          `${tool.name}: ~/${tool.skillsDir} not found \u2014 nothing to remove`
+        );
+      }
+      continue;
+    }
+    for (const skillName of skillNames) {
+      const skillPath = join4(toolSkillsPath, skillName);
+      if (!existsSync3(skillPath)) continue;
+      rmSync2(skillPath, { recursive: true, force: true });
+      removed.push(`${tool.name}: ${skillPath}`);
+      if (verbose) stepInfo(`${tool.name}: removed skill '${skillName}'`);
+    }
+  }
+  return removed;
+};
+var removeHooks = (home, verbose = false) => {
+  let settingsChanged = false;
+  const settingsPath = join4(home, ".claude", "settings.json");
+  if (!existsSync3(settingsPath)) {
+    if (verbose) stepInfo(`${settingsPath} not found \u2014 no settings to clean`);
+  } else {
+    let settings = null;
+    try {
+      settings = JSON.parse(readFileSync7(settingsPath, "utf-8"));
+    } catch {
+      if (verbose) {
+        stepInfo(`${settingsPath} was unparseable JSON \u2014 leaving it untouched`);
+      }
+    }
+    if (settings) {
+      settingsChanged = stripZeroFromSettings(settings, verbose);
+      if (settingsChanged) {
+        writeFileSync4(settingsPath, `${JSON.stringify(settings, null, 2)}
+`);
+        if (verbose) stepInfo(`rewrote ${settingsPath} without Zero entries`);
+      } else if (verbose) {
+        stepInfo(`no Zero entries found in ${settingsPath}`);
+      }
+    }
+  }
+  let scriptsRemoved = 0;
+  const zeroHooksDir = join4(home, ".zero", "hooks");
+  if (existsSync3(zeroHooksDir)) {
+    for (const hookFile of HOOK_FILES) {
+      const hookPath = join4(zeroHooksDir, hookFile);
+      if (!existsSync3(hookPath)) continue;
+      rmSync2(hookPath, { force: true });
+      scriptsRemoved++;
+      if (verbose) stepInfo(`removed ${hookPath}`);
+    }
+    if (readdirSync2(zeroHooksDir).length === 0) {
+      rmSync2(zeroHooksDir, { recursive: true, force: true });
+      if (verbose) stepInfo(`removed empty ${zeroHooksDir}`);
+    }
+  } else if (verbose) {
+    stepInfo(`${zeroHooksDir} not found \u2014 no hook scripts to remove`);
+  }
+  return { settingsChanged, scriptsRemoved };
+};
+var stripZeroFromSettings = (settings, verbose) => {
+  let changed = false;
+  const hooks = settings.hooks && typeof settings.hooks === "object" ? settings.hooks : null;
+  if (hooks) {
+    changed = removeHookEntries(hooks, "PreToolUse", "auto-approve-zero", verbose) || changed;
+    changed = removeHookEntries(hooks, "UserPromptSubmit", "zero-context", verbose) || changed;
+    for (const key of ["PreToolUse", "UserPromptSubmit"]) {
+      const arr = hooks[key];
+      if (Array.isArray(arr) && arr.length === 0) delete hooks[key];
+    }
+    if (Object.keys(hooks).length === 0) delete settings.hooks;
+  }
+  const sandbox = settings.sandbox && typeof settings.sandbox === "object" ? settings.sandbox : null;
+  const network = sandbox?.network && typeof sandbox.network === "object" ? sandbox.network : null;
+  if (network && Array.isArray(network.allowedDomains)) {
+    const domains = network.allowedDomains;
+    const next = domains.filter((d) => d !== ZERO_SANDBOX_DOMAIN);
+    if (next.length !== domains.length) {
+      changed = true;
+      if (verbose) {
+        stepInfo(`sandbox.network.allowedDomains -= ${ZERO_SANDBOX_DOMAIN}`);
+      }
+      if (next.length === 0) {
+        delete network.allowedDomains;
+        if (sandbox && Object.keys(network).length === 0)
+          delete sandbox.network;
+        if (sandbox && Object.keys(sandbox).length === 0)
+          delete settings.sandbox;
+      } else {
+        network.allowedDomains = next;
+      }
+    }
+  }
+  return changed;
+};
+var removeHookEntries = (hooks, hookType, commandSubstring, verbose) => {
+  const entries = hooks[hookType];
+  if (!Array.isArray(entries)) return false;
+  const next = entries.filter((entry) => {
+    const entryHooks = entry?.hooks;
+    if (!Array.isArray(entryHooks)) return true;
+    return !entryHooks.some(
+      (h) => typeof h.command === "string" && h.command.includes(commandSubstring)
+    );
+  });
+  if (next.length === entries.length) return false;
+  hooks[hookType] = next;
+  if (verbose) stepInfo(`removed ${hookType} entry (${commandSubstring})`);
+  return true;
+};
+var removeWallet = (home, verbose = false) => {
+  const zeroDir = join4(home, ".zero");
+  const configPath = join4(zeroDir, "config.json");
+  let removed = false;
+  if (existsSync3(configPath)) {
+    rmSync2(configPath, { force: true });
+    removed = true;
+    if (verbose) stepInfo(`removed ${configPath}`);
+  }
+  if (existsSync3(zeroDir) && readdirSync2(zeroDir).length === 0) {
+    rmSync2(zeroDir, { recursive: true, force: true });
+    if (verbose) stepInfo(`removed empty ${zeroDir}`);
+  }
+  return removed;
+};
+var runUninstall = async (appContext, options = {}) => {
+  const verbose = options.verbose ?? false;
+  const purge = options.purge ?? false;
+  appContext.services.analyticsService.capture("uninstall_started", { purge });
+  let currentStep = "skills";
+  try {
+    console.log("");
+    console.log(`  ${color.boldCyan("Uninstalling Zero")}`);
+    console.log("");
+    console.log(color.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+    console.log("");
+    const home = homedir4();
+    currentStep = "skills";
+    const skillsRemoved = removeSkills(home, verbose);
+    if (skillsRemoved.length > 0) {
+      stepSuccess("Skills removed", `${skillsRemoved.length} removed`);
+    } else {
+      stepSkip("No Zero skills found");
+    }
+    currentStep = "hooks";
+    const { settingsChanged, scriptsRemoved } = removeHooks(home, verbose);
+    if (settingsChanged || scriptsRemoved > 0) {
+      stepSuccess("Hooks removed");
+    } else {
+      stepSkip("No Zero hooks found");
+    }
+    currentStep = "wallet";
+    let walletRemoved = false;
+    if (purge) {
+      walletRemoved = removeWallet(home, verbose);
+      if (walletRemoved) {
+        stepWarn("Wallet config deleted", "~/.zero/config.json");
+      } else {
+        stepSkip("No wallet config to delete");
+      }
+    } else {
+      stepSkip(
+        "Wallet preserved",
+        "run `zero uninstall --purge` to also delete ~/.zero"
+      );
+    }
+    currentStep = "complete";
+    appContext.services.analyticsService.capture("uninstall_completed", {
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      skills_removed: skillsRemoved,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      skills_removed_count: skillsRemoved.length,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      hooks_removed: settingsChanged,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      hook_scripts_removed: scriptsRemoved,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      wallet_removed: walletRemoved,
+      purge
+    });
+    sectionDivider();
+    console.log(`  ${color.boldGreen("Zero uninstalled.")}`);
+    if (!purge) {
+      console.log(
+        `  ${color.dim("Your wallet is kept at ~/.zero \u2014 reinstall anytime with `zero init`.")}`
+      );
+    }
+    console.log("");
+    return {
+      skillsRemoved,
+      hooksRemoved: settingsChanged,
+      hookScriptsRemoved: scriptsRemoved,
+      walletRemoved
+    };
+  } catch (err) {
+    appContext.services.analyticsService.capture("uninstall_failed", {
+      step: currentStep,
+      error: truncateError(err instanceof Error ? err.message : String(err)),
+      purge
+    });
+    throw err;
+  }
+};
+var uninstallCommand = (appContext) => new Command11("uninstall").description(
+  "Remove Zero skills and hooks installed by `zero init` (keeps your wallet)"
+).option(
+  "--purge",
+  "Also delete the wallet config at ~/.zero (irreversible \u2014 destroys the private key)"
+).option(
+  "-v, --verbose",
+  "Explain why each removal step was taken or skipped"
+).action(async (options) => {
+  await runUninstall(appContext, options);
+});
+
+// src/commands/wallet-command.ts
+import { existsSync as existsSync4, readFileSync as readFileSync9 } from "fs";
+import { homedir as homedir5 } from "os";
+import { join as join6 } from "path";
+import { confirm, isCancel } from "@clack/prompts";
+import { Command as Command12 } from "commander";
 import open2 from "open";
 import { isAddress } from "viem";
 import { generatePrivateKey as generatePrivateKey2, privateKeyToAccount as privateKeyToAccount2 } from "viem/accounts";
 
+// src/util/migrate-config.ts
+import { readFileSync as readFileSync8 } from "fs";
+import { join as join5 } from "path";
+var backupAndStripPrivateKey = (zeroDir) => {
+  const configPath = join5(zeroDir, "config.json");
+  const backupPath = join5(zeroDir, "config.backup.json");
+  const raw = readFileSync8(configPath, "utf8");
+  ensureSecureDir(zeroDir);
+  writeSecureFile(backupPath, raw);
+  const parsed = JSON.parse(raw);
+  delete parsed.privateKey;
+  writeSecureFile(configPath, JSON.stringify(parsed, null, 2));
+  return { backupPath, configPath };
+};
+
 // src/util/stdin.ts
 var readStdin = async () => {
   const chunks = [];
@@ -3485,7 +3866,7 @@ var readStdin = async () => {
 // src/commands/wallet-command.ts
 var PRIVATE_KEY_PATTERN = /^0x[0-9a-fA-F]{64}$/;
 var parseProvider = (raw) => raw === "stripe" ? "stripe" : "coinbase";
-var walletBalanceCommand = (appContext) => new Command11("balance").description("Show wallet balance").option(
+var walletBalanceCommand = (appContext) => new Command12("balance").description("Show wallet balance").option(
   "--address <address>",
   "Check balance for an arbitrary address (no key needed). Useful with `zero wallet generate` \u2014 verify funds arrived without setting the wallet as your default."
 ).action(async (options) => {
@@ -3534,7 +3915,7 @@ var readPrivateKeyFromStdin = async () => {
   }
   return raw;
 };
-var walletFundCommand = (appContext) => new Command11("fund").description("Fund your wallet").argument("[amount]", "Amount to fund in USDC").option("--manual", "Show wallet address for manual transfer").option(
+var walletFundCommand = (appContext) => new Command12("fund").description("Fund your wallet").argument("[amount]", "Amount to fund in USDC").option("--manual", "Show wallet address for manual transfer").option(
   "--no-open",
   "Print the funding URL instead of opening a browser (for agents \u2014 funding links are one-time use, hand the URL to the user)"
 ).option(
@@ -3631,7 +4012,7 @@ ${address}`);
     }
   }
 );
-var walletAddressCommand = (appContext) => new Command11("address").description("Show wallet address").action(() => {
+var walletAddressCommand = (appContext) => new Command12("address").description("Show wallet address").action(() => {
   const { walletService } = appContext.services;
   const address = walletService.getAddress();
   if (!address) {
@@ -3641,7 +4022,7 @@ var walletAddressCommand = (appContext) => new Command11("address").description(
   }
   console.log(address);
 });
-var walletSetCommand = (appContext) => new Command11("set").description("Set wallet from an existing private key").argument("<privateKey>", "Hex-encoded private key (0x-prefixed)").option("--force", "Overwrite existing wallet without prompting").action(async (privateKey, options) => {
+var walletSetCommand = (appContext) => new Command12("set").description("Set wallet from an existing private key").argument("<privateKey>", "Hex-encoded private key (0x-prefixed)").option("--force", "Overwrite existing wallet without prompting").action(async (privateKey, options) => {
   const { analyticsService } = appContext.services;
   if (!privateKey.startsWith("0x")) {
     console.error("Private key must be 0x-prefixed hex string.");
@@ -3656,11 +4037,11 @@ var walletSetCommand = (appContext) => new Command11("set").description("Set wal
     process.exitCode = 1;
     return;
   }
-  const zeroDir = join4(homedir4(), ".zero");
-  const configPath = join4(zeroDir, "config.json");
-  if (!options.force && existsSync3(configPath)) {
+  const zeroDir = join6(homedir5(), ".zero");
+  const configPath = join6(zeroDir, "config.json");
+  if (!options.force && existsSync4(configPath)) {
     try {
-      const existing2 = JSON.parse(readFileSync7(configPath, "utf8"));
+      const existing2 = JSON.parse(readFileSync9(configPath, "utf8"));
       if (existing2.privateKey) {
         console.error(
           "Wallet already configured. Use --force to overwrite."
@@ -3672,7 +4053,7 @@ var walletSetCommand = (appContext) => new Command11("set").description("Set wal
     }
   }
   ensureSecureDir(zeroDir);
-  const existing = existsSync3(configPath) ? JSON.parse(readFileSync7(configPath, "utf8")) : {};
+  const existing = existsSync4(configPath) ? JSON.parse(readFileSync9(configPath, "utf8")) : {};
   writeSecureFile(
     configPath,
     JSON.stringify(
@@ -3691,7 +4072,7 @@ var walletSetCommand = (appContext) => new Command11("set").description("Set wal
     force: options.force ?? false
   });
 });
-var walletGenerateCommand = (appContext) => new Command11("generate").description(
+var walletGenerateCommand = (appContext) => new Command12("generate").description(
   "Generate a fresh wallet (address + private key) without touching your configured wallet"
 ).option("--json", "Emit { address, privateKey } as JSON").option(
   "--fund",
@@ -3768,29 +4149,166 @@ var walletGenerateCommand = (appContext) => new Command11("generate").descriptio
     });
   }
 );
+var resolveZeroWalletAddress = async (apiService) => {
+  try {
+    const wallets = await apiService.getWallets();
+    const primary = wallets.find(
+      (w) => w.source === "privy_embedded" && w.isPrimary
+    );
+    if (primary) return primary.walletAddress;
+    const provisioned = await apiService.provisionWallet();
+    return provisioned.walletAddress ?? null;
+  } catch {
+    return null;
+  }
+};
+var walletMigrateCommand = (appContext) => new Command12("migrate").description(
+  "Sweep all USDC from your private-key wallet into your Zero wallet"
+).option("--json", "Emit the migration result as JSON").option("-y, --yes", "Skip the confirmation prompt").action(async (options) => {
+  const { apiService, paymentService } = appContext.services;
+  const zeroDir = join6(homedir5(), ".zero");
+  const configPath = join6(zeroDir, "config.json");
+  const config = existsSync4(configPath) ? readConfig(configPath) : {};
+  const privateKey = appContext.env.ZERO_PRIVATE_KEY ?? config.privateKey;
+  if (!privateKey) {
+    console.error(
+      "No private-key wallet found. Run `zero wallet set <key>` first."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const hasSession = Boolean(
+    appContext.env.ZERO_SESSION_TOKEN || config.session
+  );
+  if (!hasSession) {
+    console.error("Not logged in. Run `zero auth login` first.");
+    process.exitCode = 1;
+    return;
+  }
+  let source;
+  try {
+    source = privateKeyToAccount2(privateKey);
+  } catch {
+    console.error("Invalid private key in config.");
+    process.exitCode = 1;
+    return;
+  }
+  const to = await resolveZeroWalletAddress(apiService);
+  if (!to) {
+    console.error(
+      "Could not resolve your Zero wallet. Run `zero auth login` and try again."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  if (to.toLowerCase() === source.address.toLowerCase()) {
+    console.error(
+      "Source and destination are the same wallet \u2014 nothing to migrate."
+    );
+    process.exitCode = 1;
+    return;
+  }
+  const balance = await paymentService.getSweepableBalance();
+  if (balance.raw <= 0n) {
+    if (options.json) {
+      console.log(
+        JSON.stringify({ destination: to, legs: [], keyRemoved: false })
+      );
+    } else {
+      console.log("Nothing to migrate (no USDC found).");
+    }
+    return;
+  }
+  if (!options.yes) {
+    if (options.json || !process.stdin.isTTY) {
+      console.error(
+        "Refusing to migrate without confirmation. Re-run with --yes to proceed."
+      );
+      process.exitCode = 1;
+      return;
+    }
+    const proceed = await confirm({
+      message: `Please confirm you would like to transfer $${balance.usdc} from your private wallet to your Zero managed wallet`
+    });
+    if (isCancel(proceed) || !proceed) {
+      console.log("Migration cancelled.");
+      return;
+    }
+  }
+  const results = await paymentService.migrateAllUsdc(to, apiService);
+  const anyFailed = results.some((r) => r.status === "failed");
+  const anySwept = results.some((r) => r.status === "swept");
+  let backupPath = null;
+  if (anySwept && !anyFailed && config.privateKey) {
+    try {
+      backupPath = backupAndStripPrivateKey(zeroDir).backupPath;
+    } catch {
+      backupPath = null;
+    }
+  }
+  if (options.json) {
+    console.log(
+      JSON.stringify({
+        destination: to,
+        legs: results,
+        keyRemoved: backupPath !== null,
+        backupPath
+      })
+    );
+  } else {
+    console.log(`Migrating USDC \u2192 ${to}`);
+    for (const r of results) {
+      if (r.status === "swept") {
+        console.log(
+          `  ${r.chain}: swept ${r.amount} USDC (tx ${r.txHash})`
+        );
+      } else if (r.status === "skipped") {
+        console.log(`  ${r.chain}: skipped (no balance)`);
+      } else {
+        console.log(`  ${r.chain}: FAILED \u2014 ${r.error}`);
+      }
+    }
+    if (backupPath) {
+      console.log("");
+      console.log(
+        `Private key removed from config (backed up to ${backupPath}). Your Zero wallet is now primary.`
+      );
+    } else if (anyFailed) {
+      console.log("");
+      console.log(
+        "A transfer failed \u2014 your private key was kept. Re-run `zero wallet migrate` to retry."
+      );
+    } else if (!anySwept) {
+      console.log("");
+      console.log("Nothing to migrate (no USDC found).");
+    }
+  }
+  if (anyFailed) process.exitCode = 1;
+});
 var walletCommand = (appContext) => {
-  const cmd = new Command11("wallet").description("Manage your wallet");
+  const cmd = new Command12("wallet").description("Manage your wallet");
   cmd.addCommand(walletBalanceCommand(appContext));
   cmd.addCommand(walletFundCommand(appContext));
   cmd.addCommand(walletAddressCommand(appContext));
   cmd.addCommand(walletSetCommand(appContext));
   cmd.addCommand(walletGenerateCommand(appContext));
+  cmd.addCommand(walletMigrateCommand(appContext), { hidden: true });
   return cmd;
 };
 
 // src/commands/welcome-command.ts
-import { existsSync as existsSync4, readFileSync as readFileSync8 } from "fs";
-import { homedir as homedir5 } from "os";
-import { join as join5 } from "path";
-import { Command as Command12 } from "commander";
+import { existsSync as existsSync5, readFileSync as readFileSync10 } from "fs";
+import { homedir as homedir6 } from "os";
+import { join as join7 } from "path";
+import { Command as Command13 } from "commander";
 import open3 from "open";
 import { getAddress } from "viem";
 import { privateKeyToAccount as privateKeyToAccount3 } from "viem/accounts";
 var readPrivateKey = () => {
-  const configPath = join5(homedir5(), ".zero", "config.json");
-  if (!existsSync4(configPath)) return null;
+  const configPath = join7(homedir6(), ".zero", "config.json");
+  if (!existsSync5(configPath)) return null;
   try {
-    const config = JSON.parse(readFileSync8(configPath, "utf8"));
+    const config = JSON.parse(readFileSync10(configPath, "utf8"));
     if (typeof config.privateKey === "string") {
       return config.privateKey;
     }
@@ -3825,7 +4343,7 @@ var printManualFallback = (url) => {
   }
   console.log(lines.join("\n"));
 };
-var welcomeCommand = (appContext) => new Command12("welcome").description("Claim your $5 welcome bonus.").action(async () => {
+var welcomeCommand = (appContext) => new Command13("welcome").description("Claim your $5 welcome bonus.").action(async () => {
   const { analyticsService } = appContext.services;
   analyticsService.capture("welcome_started", {});
   let walletAddress;
@@ -3885,7 +4403,7 @@ If your browser didn't open, paste the URL above.`
 // src/app.ts
 var createApp = (appContext) => {
   const { analyticsService } = appContext.services;
-  const program = new Command13().name("zero").description("Zero CLI \u2014 Search engine for AI agents").version(package_default.version, "-v, --version").exitOverride().hook("preAction", async (_thisCommand, actionCommand) => {
+  const program = new Command14().name("zero").description("Zero CLI \u2014 Search engine for AI agents").version(package_default.version, "-v, --version").exitOverride().hook("preAction", async (_thisCommand, actionCommand) => {
     const agentFlag = actionCommand.opts().agent;
     if (typeof agentFlag === "string" && agentFlag.trim().length > 0) {
       analyticsService.setAgentHost(agentFlag.trim());
@@ -3899,6 +4417,7 @@ var createApp = (appContext) => {
     });
   });
   program.addCommand(initCommand(appContext));
+  program.addCommand(uninstallCommand(appContext));
   program.addCommand(searchCommand(appContext));
   program.addCommand(getCommand(appContext));
   program.addCommand(fetchCommand(appContext));
@@ -3934,14 +4453,14 @@ var getEnv = () => {
 
 // src/app/app-services.ts
 import { randomUUID as randomUUID2 } from "crypto";
-import { existsSync as existsSync7 } from "fs";
-import { homedir as homedir6 } from "os";
-import { join as join7 } from "path";
+import { existsSync as existsSync8 } from "fs";
+import { homedir as homedir7 } from "os";
+import { join as join9 } from "path";
 import { privateKeyToAccount as privateKeyToAccount4 } from "viem/accounts";
 
 // src/services/analytics-service.ts
 import { randomUUID } from "crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync4, readFileSync as readFileSync9, writeFileSync as writeFileSync4 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync11, writeFileSync as writeFileSync5 } from "fs";
 import { dirname as dirname2 } from "path";
 import { PostHog } from "posthog-node";
 var POSTHOG_API_KEY = "phc_B2vLyNxAf2mnqvdPQajf4d4b2iXc35dep2ZrvebMJLuX";
@@ -3963,8 +4482,8 @@ var AnalyticsService = class {
     let telemetryEnabled = true;
     let persistedAnonId;
     try {
-      if (existsSync5(opts.configPath)) {
-        const config = JSON.parse(readFileSync9(opts.configPath, "utf8"));
+      if (existsSync6(opts.configPath)) {
+        const config = JSON.parse(readFileSync11(opts.configPath, "utf8"));
         if (config.telemetry === false) {
           telemetryEnabled = false;
         }
@@ -3990,8 +4509,8 @@ var AnalyticsService = class {
         try {
           const dir = dirname2(opts.configPath);
           mkdirSync4(dir, { recursive: true });
-          const existing = existsSync5(opts.configPath) ? JSON.parse(readFileSync9(opts.configPath, "utf8")) : {};
-          writeFileSync4(
+          const existing = existsSync6(opts.configPath) ? JSON.parse(readFileSync11(opts.configPath, "utf8")) : {};
+          writeFileSync5(
             opts.configPath,
             JSON.stringify({ ...existing, anonId: newAnonId }, null, 2)
           );
@@ -4031,7 +4550,7 @@ var AnalyticsService = class {
     if (anonId === walletAddress) return;
     let aliasedTo;
     try {
-      const config = JSON.parse(readFileSync9(configPath, "utf8"));
+      const config = JSON.parse(readFileSync11(configPath, "utf8"));
       if (typeof config.aliasedTo === "string") {
         aliasedTo = config.aliasedTo;
       }
@@ -4041,8 +4560,8 @@ var AnalyticsService = class {
     this.posthog.alias({ distinctId: walletAddress, alias: anonId });
     if (process.env.VITEST) return;
     try {
-      const config = existsSync5(configPath) ? JSON.parse(readFileSync9(configPath, "utf8")) : {};
-      writeFileSync4(
+      const config = existsSync6(configPath) ? JSON.parse(readFileSync11(configPath, "utf8")) : {};
+      writeFileSync5(
         configPath,
         JSON.stringify({ ...config, aliasedTo: walletAddress }, null, 2)
       );
@@ -4145,34 +4664,34 @@ var createApiAccount = (walletAddress, api) => toAccount({
 });
 
 // src/services/state-service.ts
-import { existsSync as existsSync6, mkdirSync as mkdirSync5, readFileSync as readFileSync10, writeFileSync as writeFileSync5 } from "fs";
-import { join as join6 } from "path";
+import { existsSync as existsSync7, mkdirSync as mkdirSync5, readFileSync as readFileSync12, writeFileSync as writeFileSync6 } from "fs";
+import { join as join8 } from "path";
 var RECENT_SEARCH_LIMIT = 10;
 var StateService = class {
   constructor(zeroDir) {
     this.zeroDir = zeroDir;
-    this.lastSearchPath = join6(zeroDir, "last_search.json");
-    this.recentSearchesPath = join6(zeroDir, "recent_searches.json");
+    this.lastSearchPath = join8(zeroDir, "last_search.json");
+    this.recentSearchesPath = join8(zeroDir, "recent_searches.json");
   }
   lastSearchPath;
   recentSearchesPath;
   saveLastSearch = (data) => {
     mkdirSync5(this.zeroDir, { recursive: true });
-    writeFileSync5(this.lastSearchPath, JSON.stringify(data, null, 2));
+    writeFileSync6(this.lastSearchPath, JSON.stringify(data, null, 2));
     const recent = this.loadRecentSearches();
     const filtered = recent.searches.filter(
       (s) => s.searchId !== data.searchId
     );
     const next = [data, ...filtered].slice(0, RECENT_SEARCH_LIMIT);
-    writeFileSync5(
+    writeFileSync6(
       this.recentSearchesPath,
       JSON.stringify({ searches: next }, null, 2)
     );
   };
   loadLastSearch = () => {
     try {
-      if (!existsSync6(this.lastSearchPath)) return null;
-      const raw = readFileSync10(this.lastSearchPath, "utf8");
+      if (!existsSync7(this.lastSearchPath)) return null;
+      const raw = readFileSync12(this.lastSearchPath, "utf8");
       return JSON.parse(raw);
     } catch {
       return null;
@@ -4180,11 +4699,11 @@ var StateService = class {
   };
   loadRecentSearches = () => {
     try {
-      if (!existsSync6(this.recentSearchesPath)) {
+      if (!existsSync7(this.recentSearchesPath)) {
         const last = this.loadLastSearch();
         return { searches: last ? [last] : [] };
       }
-      const raw = readFileSync10(this.recentSearchesPath, "utf8");
+      const raw = readFileSync12(this.recentSearchesPath, "utf8");
       const parsed = JSON.parse(raw);
       return { searches: parsed.searches ?? [] };
     } catch {
@@ -4312,9 +4831,9 @@ var buildOnSessionRefreshed = (configPath) => async (tokens) => {
   writeSecureFile(configPath, JSON.stringify(next, null, 2));
 };
 var getServices = async (env) => {
-  const zeroDir = join7(homedir6(), ".zero");
-  const configPath = join7(zeroDir, "config.json");
-  const config = existsSync7(configPath) ? readConfig(configPath) : {};
+  const zeroDir = join9(homedir7(), ".zero");
+  const configPath = join9(zeroDir, "config.json");
+  const config = existsSync8(configPath) ? readConfig(configPath) : {};
   const { credentials, privateKey } = resolveCredentials(env, config);
   const lowBalanceWarning = typeof config.lowBalanceWarning === "number" ? config.lowBalanceWarning : 1;
   const apiService = new ApiService(
@@ -4324,20 +4843,17 @@ var getServices = async (env) => {
     buildOnSessionRefreshed(configPath)
   );
   let account = privateKey ? privateKeyToAccount4(privateKey) : null;
-  let managed = false;
   if (!account && credentials.kind === "session") {
     const address = await resolveManagedWalletAddress(apiService);
     if (address) {
       account = createApiAccount(address, apiService);
-      managed = true;
     }
   }
   if (account && !apiService.walletAddress) {
     apiService.setWalletAddress(account.address);
   }
   const paymentService = new PaymentService(account, {
-    lowBalanceWarning,
-    managed
+    lowBalanceWarning
   });
   const stateService = new StateService(zeroDir);
   const walletService = new WalletService(
@@ -4390,15 +4906,15 @@ var createAppContext = async () => {
 
 // src/util/update-check.ts
 import {
-  existsSync as existsSync8,
+  existsSync as existsSync9,
   lstatSync,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync11,
+  readFileSync as readFileSync13,
   readlinkSync,
-  writeFileSync as writeFileSync6
+  writeFileSync as writeFileSync7
 } from "fs";
-import { homedir as homedir7 } from "os";
-import { dirname as dirname3, join as join8, resolve } from "path";
+import { homedir as homedir8 } from "os";
+import { dirname as dirname3, join as join10, resolve } from "path";
 var CACHE_FILENAME = "update_check.json";
 var NPM_REGISTRY_URL = "https://registry.npmjs.org/@zeroxyz/cli/latest";
 var CHECK_INTERVAL_MS = 60 * 60 * 1e3;
@@ -4422,10 +4938,10 @@ var resolveExecPath = (execPath) => {
 var detectInstallMethod = (opts = {}) => {
   const execPath = opts.execPath ?? process.execPath;
   const pkg = opts.pkg ?? process.pkg;
-  const home = opts.home ?? homedir7();
+  const home = opts.home ?? homedir8();
   if (pkg) return "binary";
   const resolved = resolveExecPath(execPath);
-  const zeroBin = join8(home, ".zero", "bin");
+  const zeroBin = join10(home, ".zero", "bin");
   if (resolved.startsWith(zeroBin)) return "binary";
   return "npm";
 };
@@ -4450,12 +4966,12 @@ var compareVersions = (a, b) => {
   if (pb.pre === null) return -1;
   return pa.pre < pb.pre ? -1 : 1;
 };
-var cachePath = (zeroDir) => join8(zeroDir, CACHE_FILENAME);
+var cachePath = (zeroDir) => join10(zeroDir, CACHE_FILENAME);
 var readCache = (zeroDir) => {
   try {
     const path = cachePath(zeroDir);
-    if (!existsSync8(path)) return emptyCache;
-    const raw = readFileSync11(path, "utf8");
+    if (!existsSync9(path)) return emptyCache;
+    const raw = readFileSync13(path, "utf8");
     const parsed = JSON.parse(raw);
     return {
       lastCheckedMs: typeof parsed.lastCheckedMs === "number" ? parsed.lastCheckedMs : 0,
@@ -4469,7 +4985,7 @@ var readCache = (zeroDir) => {
 var writeCache = (zeroDir, cache) => {
   try {
     mkdirSync6(zeroDir, { recursive: true });
-    writeFileSync6(cachePath(zeroDir), JSON.stringify(cache, null, 2));
+    writeFileSync7(cachePath(zeroDir), JSON.stringify(cache, null, 2));
   } catch {
   }
 };
@@ -4544,7 +5060,7 @@ var main = async () => {
     console.error("Failed to create app context");
     process.exit(1);
   }
-  const zeroDir = join9(homedir8(), ".zero");
+  const zeroDir = join11(homedir9(), ".zero");
   maybePrintUpdateBanner(zeroDir, package_default.version);
   const app = createApp(appContext);
   let caughtError = null;

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@zeroxyz/cli",
-	"version": "0.0.40",
+	"version": "0.0.42",
 	"type": "module",
 	"bin": {
 		"zero": "dist/index.js",