@zeroxyz/cli 1.7.0 → 1.9.0

package/dist/index.js

@@ -52631,12 +52631,12 @@ var require_array = __commonJS({
       if (Array.isArray(values)) {
         arrayValues = values;
       } else if (values && typeof values === "object") {
-        let unique = {};
+        let unique2 = {};
         arrayValues = coders.map((coder) => {
           const name = coder.localName;
           (0, index_js_1.assert)(name, "cannot encode object for signature with missing names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
-          (0, index_js_1.assert)(!unique[name], "cannot encode object for signature with duplicate names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
-          unique[name] = true;
+          (0, index_js_1.assert)(!unique2[name], "cannot encode object for signature with duplicate names", "INVALID_ARGUMENT", { argument: "values", info: { coder }, value: values });
+          unique2[name] = true;
           return values[name];
         });
       } else {
@@ -55096,10 +55096,10 @@ var require_dist = __commonJS({
                 }
               }
               check_fenced(norm);
-              let unique = Array_from(new Set(chars));
-              let [g2] = determine_group(unique);
+              let unique2 = Array_from(new Set(chars));
+              let [g2] = determine_group(unique2);
               check_group(g2, chars);
-              check_whole(g2, unique);
+              check_whole(g2, unique2);
               type2 = g2.N;
             }
           }
@@ -55110,10 +55110,10 @@ var require_dist = __commonJS({
         return info;
       });
     }
-    function check_whole(group, unique) {
+    function check_whole(group, unique2) {
       let maker;
       let shared = [];
-      for (let cp of unique) {
+      for (let cp of unique2) {
         let whole = WHOLE_MAP.get(cp);
         if (whole === UNIQUE_PH) return;
         if (whole) {
@@ -55132,9 +55132,9 @@ var require_dist = __commonJS({
         }
       }
     }
-    function determine_group(unique) {
+    function determine_group(unique2) {
       let groups = GROUPS;
-      for (let cp of unique) {
+      for (let cp of unique2) {
         let gs = groups.filter((g2) => group_has_cp(g2, cp));
         if (!gs.length) {
           if (!GROUPS.some((g2) => group_has_cp(g2, cp))) {
@@ -76582,7 +76582,7 @@ init_esm_shims();
 
 // package.json
 var package_default = {
-  version: "1.7.0"};
+  version: "1.9.0"};
 
 // src/app.ts
 init_esm_shims();
@@ -77590,7 +77590,7 @@ init_esm_shims();
 // ../sdk/dist/index.js
 init_esm_shims();
 
-// ../sdk/dist/chunk-3YKWO4B2.js
+// ../sdk/dist/chunk-26IHUYNK.js
 init_esm_shims();
 
 // ../../node_modules/.pnpm/viem@2.52.2_bufferutil@4.1.0_typescript@5.9.3_utf-8-validate@6.0.6_zod@4.3.6/node_modules/viem/_esm/index.js
@@ -142971,6 +142971,8 @@ config(en_default2());
 
 // ../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/index.js
 var zod_default = external_exports3;
+
+// ../sdk/dist/chunk-26IHUYNK.js
 var createManagedAccount = (client, address2) => toAccount({
   address: address2,
   async signMessage({ message: message2 }) {
@@ -144161,368 +144163,988 @@ var Payments = class {
     };
   };
 };
-var package_default2 = {
-  version: "0.6.0"
-};
-var SDK_VERSION2 = package_default2.version;
-var userWalletDtoSchema = external_exports3.object({
-  walletAddress: external_exports3.string(),
-  source: external_exports3.enum(["self_custody", "privy_embedded"]),
-  isPrimary: external_exports3.boolean(),
-  linkedAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).nullable().optional(),
-  delegationGranted: external_exports3.boolean(),
-  signerQuorumId: external_exports3.string().nullable(),
-  // Per-transaction USDC cap in base units (6 dp). null = unlimited, 0 = free-only.
-  maxTransactionUsdcBaseUnits: external_exports3.number().int().nullable()
-});
-var welcomeBonusSummarySchema = external_exports3.object({
-  status: external_exports3.string(),
-  amountUsd: external_exports3.number()
-});
-var internalUserDtoSchema = external_exports3.object({
-  id: external_exports3.string(),
-  email: external_exports3.string().nullable(),
-  createdAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).optional(),
-  lastLoginAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).nullable().optional(),
-  onboardingCompleted: external_exports3.boolean().optional(),
-  delegationGranted: external_exports3.boolean().optional(),
-  wallets: external_exports3.array(userWalletDtoSchema).optional(),
-  balance: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }).nullable().optional(),
-  welcomeBonus: welcomeBonusSummarySchema.nullable().optional()
-});
-var publicUserDtoSchema = external_exports3.object({
-  user: external_exports3.object({
-    id: external_exports3.string(),
-    email: external_exports3.string().nullable()
-  }),
-  walletAddress: external_exports3.string().nullable(),
-  balance: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }).nullable(),
-  welcomeBonus: welcomeBonusSummarySchema.nullable()
-});
-var signResponseSchema = external_exports3.object({
-  signature: external_exports3.string().regex(/^0x[0-9a-fA-F]+$/, "must be 0x-prefixed hex"),
-  walletAddress: external_exports3.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be 0x-prefixed 40-char hex address")
-});
-var deviceStartResponseSchema = external_exports3.object({
-  deviceCode: external_exports3.string(),
-  userCode: external_exports3.string(),
-  verificationUri: external_exports3.string(),
-  pollInterval: external_exports3.number(),
-  expiresAt: external_exports3.number()
-});
-var devicePollResponseSchema = external_exports3.union([
-  // userCode + verificationUri are optional: older API deployments don't
-  // echo them on pending.
-  external_exports3.object({
-    error: external_exports3.literal("authorization_pending"),
-    userCode: external_exports3.string().optional(),
-    verificationUri: external_exports3.string().optional()
-  }),
-  external_exports3.object({ error: external_exports3.literal("expired_token") }),
-  external_exports3.object({
-    accessToken: external_exports3.string(),
-    refreshToken: external_exports3.string(),
-    expiresIn: external_exports3.number(),
-    user: internalUserDtoSchema
-  })
-]);
-var sessionExchangeResponseSchema = external_exports3.object({
-  token: external_exports3.string(),
-  expiresAt: external_exports3.number()
-});
-var refreshResponseSchema = external_exports3.object({
-  accessToken: external_exports3.string(),
-  refreshToken: external_exports3.string()
-});
-var tryRefreshSession = async (client, callerSignal) => {
-  const credentials = client.getCredentials();
-  if (credentials.kind !== "session") return false;
-  if (!credentials.refreshToken) return false;
-  const url4 = `${client.baseUrl.replace(/\/$/, "")}/v1/auth/refresh`;
-  const timeoutSignal = AbortSignal.timeout(client.timeout);
-  const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
-  let response;
-  try {
-    response = await client.fetchImpl(url4, {
-      method: "POST",
-      headers: { "content-type": "application/json" },
-      body: JSON.stringify({ refreshToken: credentials.refreshToken }),
-      signal
-    });
-  } catch {
-    return false;
+var isShortToken = (id) => id.startsWith("z_") && id.indexOf(".", 2) !== -1;
+var MAX_402_PROBE_BYTES = 1024 * 1024;
+var MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
+var TEXT_CONTENT_TYPES = [
+  "application/json",
+  "application/xml",
+  "application/javascript",
+  "application/ecmascript",
+  "application/x-www-form-urlencoded",
+  "text/",
+  "+json",
+  "+xml"
+];
+var MPP_SCHEME_TOKENS = /* @__PURE__ */ new Set(["payment", "mpp"]);
+var splitWwwAuthenticateChallenges = (header) => {
+  const chunks = [];
+  let buf = "";
+  let inQuotes = false;
+  for (let i = 0; i < header.length; i++) {
+    const ch = header[i];
+    if (inQuotes) {
+      if (ch === "\\" && i + 1 < header.length) {
+        buf += ch + header[i + 1];
+        i++;
+        continue;
+      }
+      if (ch === '"') inQuotes = false;
+      buf += ch;
+      continue;
+    }
+    if (ch === '"') {
+      inQuotes = true;
+      buf += ch;
+      continue;
+    }
+    if (ch === ",") {
+      chunks.push(buf);
+      buf = "";
+      continue;
+    }
+    buf += ch;
   }
-  if (!response.ok) return false;
-  let body;
+  if (buf.length > 0) chunks.push(buf);
+  return chunks;
+};
+var isTextContentType = (contentType) => {
+  if (!contentType) return true;
+  const lower = contentType.toLowerCase();
+  return TEXT_CONTENT_TYPES.some((marker) => lower.includes(marker));
+};
+var redactUrl2 = (url4) => {
   try {
-    body = await response.json();
+    const u2 = new URL(url4);
+    return `${u2.origin}${u2.pathname}`;
   } catch {
-    return false;
+    return "<invalid url>";
   }
-  const parsed = refreshResponseSchema.safeParse(body);
-  if (!parsed.success) return false;
-  await client.applyRefreshedTokens({
-    accessToken: parsed.data.accessToken,
-    refreshToken: parsed.data.refreshToken
-  });
-  return true;
-};
-var buildSessionAuthHeaders = (accessToken) => ({
-  authorization: `Bearer ${accessToken}`
-});
-var buildCanonicalMessage = (method, pathWithQuery, body, timestamp, nonce2) => {
-  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
-  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce2}`;
 };
-var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
-  const timestamp = Math.floor(Date.now() / 1e3).toString();
-  const nonce2 = crypto.randomUUID();
-  const message2 = buildCanonicalMessage(
-    method,
-    pathWithQuery,
-    body,
-    timestamp,
-    nonce2
+var ECHO_DETECT_MIN_LEN = 16;
+var ECHO_DETECT_MAX_SCAN = 64 * 1024;
+var requestBodyEchoed = (candidate, requestBody) => {
+  if (requestBody === void 0) return false;
+  const asString = typeof requestBody === "string" ? requestBody : new TextDecoder("utf-8", { fatal: false }).decode(
+    requestBody.byteLength > ECHO_DETECT_MAX_SCAN ? requestBody.subarray(0, ECHO_DETECT_MAX_SCAN) : requestBody
   );
-  const signature2 = await account.signMessage({ message: message2 });
-  return {
-    "x-zero-address": account.address,
-    "x-zero-timestamp": timestamp,
-    "x-zero-nonce": nonce2,
-    "x-zero-signature": signature2
-  };
-};
-var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
-var sleep2 = (ms, signal) => new Promise((resolve6, reject) => {
-  if (signal?.aborted) {
-    reject(new DOMException("Aborted", "AbortError"));
-    return;
-  }
-  const timer = setTimeout(() => {
-    signal?.removeEventListener("abort", onAbort);
-    resolve6();
-  }, ms);
-  const onAbort = () => {
-    clearTimeout(timer);
-    reject(new DOMException("Aborted", "AbortError"));
-  };
-  signal?.addEventListener("abort", onAbort, { once: true });
-});
-var buildPathWithQuery = (path3, query) => {
-  const normalizedPath = path3.startsWith("/") ? path3 : `/${path3}`;
-  if (!query) return normalizedPath;
-  const params = new URLSearchParams();
-  for (const [key, value] of Object.entries(query)) {
-    if (value !== void 0) params.set(key, String(value));
-  }
-  const qs = params.toString();
-  return qs ? `${normalizedPath}?${qs}` : normalizedPath;
-};
-var joinUrl = (baseUrl, pathWithQuery) => {
-  const base3 = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
-  return `${base3}${pathWithQuery}`;
-};
-var buildHeaders = async (client, method, pathWithQuery, hasBody, bodyStr) => {
-  const headers = { ...client.defaultHeaders };
-  if (hasBody) headers["content-type"] = "application/json";
-  headers["x-zero-sdk-version"] = SDK_VERSION2;
-  if (client.apiVersion) headers["x-zero-api-version"] = client.apiVersion;
-  const credentials = client.getCredentials();
-  if (credentials.kind === "session") {
-    Object.assign(headers, buildSessionAuthHeaders(credentials.accessToken));
-  } else if (credentials.kind === "account") {
-    const signed = await buildAccountAuthHeaders(
-      credentials.account,
-      method,
-      pathWithQuery,
-      bodyStr
-    );
-    Object.assign(headers, signed);
+  if (asString.length < ECHO_DETECT_MIN_LEN) return false;
+  const scanLen = Math.min(asString.length, ECHO_DETECT_MAX_SCAN);
+  for (let i = 0; i + ECHO_DETECT_MIN_LEN <= scanLen; i++) {
+    if (candidate.includes(asString.slice(i, i + ECHO_DETECT_MIN_LEN))) {
+      return true;
+    }
   }
-  return headers;
+  return false;
 };
-var parseErrorBody = async (response) => {
+var cancelBody2 = (response) => {
   try {
-    return await response.clone().json();
+    response.body?.cancel().catch(() => {
+    });
   } catch {
+  }
+};
+var detectPaymentRequirement = async (response) => {
+  if (response.status !== 402) return null;
+  const x402Header = response.headers.get("payment-required") ?? response.headers.get("x-payment-required");
+  if (x402Header) {
+    cancelBody2(response);
     try {
-      return await response.text();
+      const decoded = JSON.parse(
+        Buffer.from(x402Header, "base64").toString("utf8")
+      );
+      return { protocol: "x402", raw: decoded };
     } catch {
-      return void 0;
+      return { protocol: "x402", raw: { encoded: x402Header } };
     }
   }
-};
-var errorMessageFromBody = (body, status) => {
-  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
-    return body.error;
-  }
-  return `HTTP ${status}`;
-};
-var request2 = async (client, opts, schema) => {
-  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
-  const url4 = joinUrl(client.baseUrl, pathWithQuery);
-  const hasBody = opts.body !== void 0;
-  const bodyStr = hasBody ? JSON.stringify(
-    opts.body,
-    (_k, v) => typeof v === "bigint" ? v.toString() : v
-  ) : void 0;
-  const configuredFetch = buildConfiguredFetch(client);
-  const performOnce = async () => configuredFetch(url4, {
-    method: opts.method,
-    headers: await buildHeaders(
-      client,
-      opts.method,
-      pathWithQuery,
-      hasBody,
-      bodyStr
-    ),
-    body: bodyStr,
-    signal: opts.signal
-  });
-  let refreshAttempted = false;
-  const executeWithRefresh = async () => {
-    const response = await performOnce();
-    if (response.status !== 401 || refreshAttempted) return response;
-    const credentials = client.getCredentials();
-    if (credentials.kind !== "session") return response;
-    refreshAttempted = true;
-    const refreshed = await client.refreshSessionOnce(opts.signal);
-    if (!refreshed) return response;
-    return await performOnce();
-  };
-  let lastNetworkError;
-  for (let attempt = 0; attempt <= client.maxRetries; attempt++) {
-    let response;
+  const declaredLen = Number.parseInt(
+    response.headers.get("content-length") ?? "",
+    10
+  );
+  const bodyFits = !Number.isFinite(declaredLen) || declaredLen <= MAX_402_PROBE_BYTES;
+  if (bodyFits) {
     try {
-      response = await executeWithRefresh();
-    } catch (e2) {
-      if (e2 instanceof ZeroError) throw e2;
-      lastNetworkError = e2;
-      if (attempt < client.maxRetries) {
-        try {
-          await sleep2(2 ** attempt * 200, opts.signal);
-        } catch (sleepErr) {
-          throw new ZeroApiError("Request aborted by caller", {
-            status: 0,
-            cause: sleepErr
-          });
+      const text = await readClippedText(response, MAX_402_PROBE_BYTES);
+      if (text) {
+        const parsed = JSON.parse(text);
+        if (looksLikeX402Body(parsed)) {
+          return { protocol: "x402", raw: parsed };
         }
-        continue;
-      }
-      throw new ZeroApiError("Network request failed", {
-        status: 0,
-        cause: e2
-      });
-    }
-    if (response.ok) {
-      let text;
-      try {
-        text = await response.text();
-      } catch (e2) {
-        throw new ZeroApiError("Response body read failed", {
-          status: response.status,
-          cause: e2
-        });
-      }
-      let json3;
-      try {
-        json3 = JSON.parse(text);
-      } catch {
-      }
-      const parsed = schema.safeParse(json3);
-      if (!parsed.success) {
-        throw new ZeroValidationError(
-          `Response did not match expected schema for ${opts.method} ${opts.path}`,
-          { cause: parsed.error, body: text }
-        );
       }
-      return parsed.data;
+    } catch {
     }
-    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
-      try {
-        await sleep2(2 ** attempt * 200, opts.signal);
-      } catch (sleepErr) {
-        throw new ZeroApiError("Request aborted by caller", {
-          status: 0,
-          cause: sleepErr
-        });
-      }
-      continue;
+  }
+  const wwwAuth = response.headers.get("www-authenticate");
+  if (wwwAuth) {
+    const schemes = splitWwwAuthenticateChallenges(wwwAuth).map(
+      (challenge2) => challenge2.trim().split(/\s+/)[0]?.toLowerCase() ?? ""
+    );
+    if (schemes.some((scheme) => MPP_SCHEME_TOKENS.has(scheme))) {
+      cancelBody2(response);
+      return { protocol: "mpp", raw: { "www-authenticate": wwwAuth } };
     }
-    const errorBody = await parseErrorBody(response);
-    const requestId = response.headers.get("x-request-id") ?? void 0;
-    throw new ZeroApiError(errorMessageFromBody(errorBody, response.status), {
-      status: response.status,
-      requestId,
-      body: errorBody
-    });
   }
-  throw new ZeroApiError("Exhausted retries", {
-    status: 0,
-    cause: lastNetworkError
-  });
+  cancelBody2(response);
+  return { protocol: "unknown", raw: {} };
 };
-var AuthDevice = class {
-  constructor(client) {
-    this.client = client;
-  }
-  start = (opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/auth/device/start",
-      signal: opts.signal
-    },
-    deviceStartResponseSchema
-  );
-  poll = async (deviceCode, opts = {}) => {
-    const parsed = await request2(
-      this.client,
-      {
-        method: "POST",
-        path: "/v1/auth/device/poll",
-        body: { deviceCode },
-        signal: opts.signal
-      },
-      devicePollResponseSchema
-    );
-    if ("error" in parsed) {
-      return parsed.error === "authorization_pending" ? {
-        status: "pending",
-        userCode: parsed.userCode,
-        verificationUri: parsed.verificationUri
-      } : { status: "expired" };
+var readClippedBytes = async (response, max) => {
+  if (response.body === null) return new Uint8Array(0);
+  const reader = response.body.getReader();
+  const chunks = [];
+  let total = 0;
+  try {
+    while (total < max) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      if (!value) continue;
+      chunks.push(value);
+      total += value.byteLength;
+    }
+  } finally {
+    try {
+      await reader.cancel();
+    } catch {
     }
+  }
+  const merged = new Uint8Array(Math.min(total, max));
+  let offset = 0;
+  for (const c of chunks) {
+    const take = Math.min(c.byteLength, max - offset);
+    merged.set(c.subarray(0, take), offset);
+    offset += take;
+    if (offset >= max) break;
+  }
+  return merged;
+};
+var readClippedText = async (response, max) => {
+  const bytes = await readClippedBytes(response, max);
+  return new TextDecoder().decode(bytes);
+};
+var parseResponseBody = async (response, max) => {
+  const contentType = response.headers.get("content-type");
+  const bytes = await readClippedBytes(response, max + 1);
+  const truncated = bytes.byteLength > max;
+  const view = truncated ? bytes.subarray(0, max) : bytes;
+  const buf = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
+  if (!isTextContentType(contentType)) {
+    const base644 = buf.toString("base64");
     return {
-      status: "ok",
-      accessToken: parsed.accessToken,
-      refreshToken: parsed.refreshToken,
-      expiresIn: parsed.expiresIn,
-      user: parsed.user
+      body: base644,
+      bodyRaw: base644,
+      bodyEncoding: "base64",
+      truncated
     };
-  };
+  }
+  const text = buf.toString("utf8");
+  if (contentType?.toLowerCase().includes("json")) {
+    try {
+      return { body: JSON.parse(text), bodyRaw: text, truncated };
+    } catch {
+    }
+  }
+  return { body: text, bodyRaw: text, truncated };
 };
-var userWalletsSchema = external_exports3.array(userWalletDtoSchema);
-var normalizeMessage = (message2) => {
-  if (typeof message2 === "string") return message2;
-  if (typeof message2.raw === "string") return message2.raw;
-  return bytesToHex(message2.raw);
+var UPSTREAM_ERROR_FIELDS = [
+  "error",
+  "message",
+  "detail",
+  "reason",
+  "error_description"
+];
+var UPSTREAM_ERROR_MAX_LEN = 200;
+var ERROR_SNIPPET_BYTES = 500;
+var clampUpstreamMessage = (value) => {
+  const trimmed = value.trim();
+  if (!trimmed) return void 0;
+  return trimmed.length > UPSTREAM_ERROR_MAX_LEN ? `${trimmed.slice(0, UPSTREAM_ERROR_MAX_LEN)}\u2026` : trimmed;
 };
-var repackageSignFailure = (err, op) => {
-  if (err instanceof ZeroApiError && err.status === 402) {
-    const body = err.body;
-    const detail = body && typeof body.error === "string" ? `: ${body.error}` : "";
-    throw new ZeroPaymentError(
-      `Sign endpoint refused ${op} (HTTP 402)${detail}`,
-      { cause: err }
-    );
+var tryParseJson = (text) => {
+  try {
+    return JSON.parse(text);
+  } catch {
+    return null;
   }
-  throw err;
 };
-var Auth = class {
-  constructor(client) {
-    this.client = client;
-    this.device = new AuthDevice(client);
+var extractUpstreamErrorMessage = (body) => {
+  const parsed = tryParseJson(body);
+  if (parsed === null || typeof parsed !== "object") {
+    return clampUpstreamMessage(body);
+  }
+  const record3 = parsed;
+  for (const field of UPSTREAM_ERROR_FIELDS) {
+    const value = record3[field];
+    if (typeof value === "string" && value.length > 0) {
+      return clampUpstreamMessage(value);
+    }
+    if (value && typeof value === "object") {
+      const nested = value.message;
+      if (typeof nested === "string" && nested.length > 0) {
+        return clampUpstreamMessage(nested);
+      }
+    }
+  }
+  return void 0;
+};
+var buildUpstreamError = (status, bodyRaw, bodyEncoding) => {
+  if (status >= 200 && status < 300) return void 0;
+  if (bodyRaw === null || bodyRaw.length === 0) return void 0;
+  if (bodyEncoding === "base64") return void 0;
+  const snippet = bodyRaw.slice(0, ERROR_SNIPPET_BYTES);
+  return {
+    status,
+    message: extractUpstreamErrorMessage(bodyRaw),
+    snippetHash: createHash("sha256").update(snippet).digest("hex"),
+    snippetLength: snippet.length
+  };
+};
+var computeOutcome = (status, payment, warnings) => {
+  if (warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed))
+    return "payment_close_failed";
+  if (status === 402 && payment !== null) return "payment_rejected";
+  if (status === 402) return "payment_failed";
+  if (status >= 400) return "server_error";
+  return "success";
+};
+var errorFetchResult = (startedAt, error48, skipReason, capabilityIdRequested, outcome, status = null) => {
+  const result = {
+    runId: null,
+    ok: false,
+    status,
+    latencyMs: Date.now() - startedAt,
+    payment: null,
+    outcome,
+    body: null,
+    bodyRaw: null,
+    error: error48
+  };
+  if (capabilityIdRequested) result.runTrackingSkipped = [skipReason];
+  return result;
+};
+var resolveRecordingClient = (client, opts) => {
+  const credentials = client.getCredentials();
+  const recordingClient = opts.account ? client.withAccount(opts.account) : client;
+  const canRecord = opts.account !== void 0 || credentials.kind === "account" || credentials.kind === "session";
+  return { recordingClient, canRecord };
+};
+var recordErrorFetchRun = async (client, opts, result, capabilityIdOverride) => {
+  const effectiveCapId = opts.capabilityId;
+  if (effectiveCapId === void 0) return;
+  const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
+  if (!canRecord) return;
+  const fetchOriginForRecord = opts.capabilityId === void 0 ? "direct_url" : isShortToken(effectiveCapId) ? "from_search" : opts.fetchOrigin;
+  try {
+    const created = await recordingClient.runs.create({
+      capabilityId: effectiveCapId,
+      ...opts.searchId && { searchId: opts.searchId },
+      ...fetchOriginForRecord && { fetchOrigin: fetchOriginForRecord },
+      ...result.status !== null && { status: result.status },
+      latencyMs: result.latencyMs,
+      ...opts.requestSchema && { requestSchema: opts.requestSchema }
+    });
+    result.runId = created.runId;
+    delete result.runTrackingSkipped;
+  } catch {
+  }
+};
+var recordTimeoutRun = async (client, opts, err, startedAt, capabilityIdRequested, capabilityIdOverride) => {
+  const result = errorFetchResult(
+    startedAt,
+    err.message,
+    "timeout",
+    capabilityIdRequested,
+    "network_error"
+  );
+  await recordErrorFetchRun(client, opts, result);
+};
+var sniffJsonShapeBytes = (buf) => {
+  let i = 0;
+  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
+    i = 3;
+  }
+  while (i < buf.length && (buf[i] === 32 || buf[i] === 9 || buf[i] === 10 || buf[i] === 13)) {
+    i++;
+  }
+  if (i >= buf.length) return false;
+  return buf[i] === 123 || buf[i] === 91;
+};
+var withDefaultContentType = (headers, body) => {
+  if (!headers && body === void 0) return void 0;
+  const next = headers ? { ...headers } : {};
+  if (body === void 0) return next;
+  const hasContentType = Object.keys(next).some(
+    (k3) => k3.toLowerCase() === "content-type"
+  );
+  if (!hasContentType) {
+    next["content-type"] = typeof body === "string" || sniffJsonShapeBytes(body) ? "application/json" : "application/octet-stream";
+  }
+  return next;
+};
+var clientFetch = async (client, url4, opts = {}) => {
+  const startedAt = Date.now();
+  const capabilityIdRequested = opts.capabilityId !== void 0;
+  const normalized = normalizeTransportEnvelopeRequest(url4, {
+    method: opts.method,
+    body: opts.body
+  });
+  const requestUrl = normalized.url;
+  const requestBody = normalized.body;
+  const method = normalized.method ?? (requestBody !== void 0 ? "POST" : "GET");
+  const { canRecord: canRecordForResolve } = resolveRecordingClient(
+    client,
+    opts
+  );
+  const resolvePromise = !capabilityIdRequested && canRecordForResolve ? client.capabilities.resolveByUrl(redactUrl2(requestUrl), method).catch(() => null) : Promise.resolve(null);
+  const probeHeaders = withDefaultContentType(opts.headers, requestBody);
+  const requestInit = {
+    method,
+    headers: probeHeaders,
+    body: requestBody,
+    signal: opts.signal
+  };
+  const configuredFetch = buildConfiguredFetch(client, {
+    timeoutMs: opts.timeoutMs
+  });
+  let response;
+  let payment = null;
+  const skipReasons = [];
+  const warnings = [];
+  try {
+    response = await configuredFetch(requestUrl, requestInit);
+  } catch (err) {
+    if (err instanceof ZeroTimeoutError) {
+      await recordTimeoutRun(
+        client,
+        opts,
+        err,
+        startedAt,
+        capabilityIdRequested
+      );
+      throw err;
+    }
+    if (err instanceof ZeroError) throw err;
+    const errMessage = err instanceof Error ? err.message : String(err);
+    const result2 = errorFetchResult(
+      startedAt,
+      errMessage,
+      "fetch_failed_before_response",
+      capabilityIdRequested,
+      "network_error"
+    );
+    await recordErrorFetchRun(client, opts, result2);
+    return result2;
+  }
+  if (response.status === 402) {
+    const requirement = await detectPaymentRequirement(response);
+    if (requirement?.protocol === "x402" || requirement?.protocol === "mpp") {
+      const payCall = requirement.protocol === "x402" ? client.payments.pay : client.payments.payMpp;
+      try {
+        const paid = await payCall({
+          url: requestUrl,
+          method,
+          // Fresh clone for the paid retry — same rationale as
+          // the probe-side clone above. Re-derives the default
+          // Content-Type so the paid leg matches the probe.
+          headers: withDefaultContentType(opts.headers, requestBody),
+          body: requestBody,
+          maxPay: opts.maxPay,
+          account: opts.account,
+          signal: opts.signal,
+          timeoutMs: opts.timeoutMs,
+          ...opts.displayCostAmount && {
+            displayCostAmount: opts.displayCostAmount
+          }
+        });
+        response = paid.response;
+        payment = paid.payment;
+        if (paid.warnings) warnings.push(...paid.warnings);
+      } catch (err) {
+        if (err instanceof ZeroSessionCloseFailedError) {
+          response = err.response;
+          payment = {
+            protocol: "mpp",
+            chain: tempoChainLabelFromId(err.session.chainId),
+            txHash: null,
+            amount: err.capturedAmount,
+            asset: "USDC",
+            session: err.session
+          };
+          warnings.push(FETCH_WARNINGS.mppSessionCloseFailed);
+        } else if (err instanceof ZeroInsufficientFundsError) {
+          return errorFetchResult(
+            startedAt,
+            err.message,
+            FETCH_SKIP_REASONS.insufficientFunds,
+            capabilityIdRequested,
+            "insufficient_funds",
+            null
+          );
+        } else if (err instanceof ZeroPaymentError || err instanceof ZeroAuthError) {
+          const result2 = errorFetchResult(
+            startedAt,
+            err.message,
+            "payment_failed",
+            capabilityIdRequested,
+            "payment_failed",
+            402
+          );
+          await recordErrorFetchRun(client, opts, result2);
+          return result2;
+        } else if (err instanceof ZeroTimeoutError) {
+          await recordTimeoutRun(
+            client,
+            opts,
+            err,
+            startedAt,
+            capabilityIdRequested
+          );
+          throw err;
+        } else {
+          throw err;
+        }
+      }
+    } else if (requirement?.protocol === "unknown") {
+      const result2 = errorFetchResult(
+        startedAt,
+        "Capability returned 402 with an unrecognized payment protocol. Neither x402 nor MPP markers were detected in the response headers or body.",
+        "unrecognized_402_protocol",
+        capabilityIdRequested,
+        "payment_failed",
+        402
+      );
+      await recordErrorFetchRun(client, opts, result2);
+      return result2;
+    }
+  }
+  const latencyMs = Date.now() - startedAt;
+  const maxResponseBytes = opts.maxResponseBytes ?? MAX_RESPONSE_BYTES;
+  let body;
+  let bodyRaw;
+  let bodyEncoding;
+  try {
+    const parsed = await parseResponseBody(response, maxResponseBytes);
+    body = parsed.body;
+    bodyRaw = parsed.bodyRaw;
+    bodyEncoding = parsed.bodyEncoding;
+    if (parsed.truncated) warnings.push(FETCH_WARNINGS.bodyTruncated);
+  } catch (err) {
+    if (err instanceof Error && err.name === "AbortError") {
+      throw new ZeroApiError("Request aborted by caller", {
+        status: 0,
+        cause: err
+      });
+    }
+    const message2 = err instanceof Error ? err.message : String(err);
+    const skips = [];
+    const settledLocally = paymentHasAnchor(payment);
+    if (settledLocally && response.status === 402) {
+      warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+      skips.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+    }
+    if (payment !== null && !settledLocally) {
+      warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+      skips.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+    }
+    if (payment !== null && payment.amount === "unknown") {
+      warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
+    }
+    skips.push(FETCH_SKIP_REASONS.bodyReadFailed);
+    const result2 = {
+      runId: null,
+      ok: false,
+      status: response.status,
+      latencyMs: Date.now() - startedAt,
+      payment,
+      outcome: computeOutcome(response.status, payment, warnings),
+      body: null,
+      bodyRaw: null,
+      error: message2
+    };
+    if (capabilityIdRequested) result2.runTrackingSkipped = skips;
+    if (warnings.length > 0) result2.warnings = warnings;
+    return result2;
+  }
+  const settled = paymentHasAnchor(payment);
+  const paidButStill402 = settled && response.status === 402;
+  const settlementUnconfirmed = payment !== null && !settled;
+  if (paidButStill402) warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+  if (settlementUnconfirmed)
+    warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+  if (payment !== null && payment.amount === "unknown") {
+    warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
+  }
+  let runId = null;
+  const closeFailed = warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed);
+  const upstreamErrorForRecord = buildUpstreamError(
+    response.status,
+    bodyRaw,
+    bodyEncoding
+  );
+  if (capabilityIdRequested) {
+    if (paidButStill402)
+      skipReasons.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+    else if (closeFailed)
+      skipReasons.push(FETCH_SKIP_REASONS.mppSessionCloseFailedNotRecorded);
+  }
+  const resolvedCap = await resolvePromise;
+  const effectiveCapabilityId = opts.capabilityId ?? resolvedCap?.capabilityId;
+  const capabilityResolution = !capabilityIdRequested && canRecordForResolve ? resolvedCap !== null ? {
+    resolved: true,
+    capabilityId: resolvedCap.capabilityId,
+    capabilitySlug: resolvedCap.capabilitySlug,
+    matchedVia: resolvedCap.matchedVia
+  } : { resolved: false } : void 0;
+  if (effectiveCapabilityId !== void 0 && !paidButStill402 && !closeFailed) {
+    const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
+    if (!canRecord) {
+      skipReasons.push("no_credentials");
+    } else {
+      const knownAmount = payment !== null && payment.amount !== "unknown";
+      try {
+        let derived;
+        if (opts.deriveRunMetadata) {
+          try {
+            derived = opts.deriveRunMetadata({
+              status: response.status,
+              ok: response.ok,
+              bodyRaw,
+              ...bodyEncoding && { bodyEncoding }
+            });
+          } catch {
+          }
+        }
+        const result2 = await recordingClient.runs.create({
+          capabilityId: effectiveCapabilityId,
+          searchId: opts.searchId,
+          // Auto-resolved runs are always direct_url — they only fire when
+          // no capabilityId was supplied (the direct_url path by definition).
+          ...opts.capabilityId === void 0 ? { fetchOrigin: "direct_url" } : opts.fetchOrigin && { fetchOrigin: opts.fetchOrigin },
+          status: response.status,
+          latencyMs,
+          ...opts.requestSchema && { requestSchema: opts.requestSchema },
+          ...derived?.responseSchema && {
+            responseSchema: derived.responseSchema
+          },
+          ...upstreamErrorForRecord && {
+            errorSnippetHash: upstreamErrorForRecord.snippetHash,
+            errorSnippetLength: upstreamErrorForRecord.snippetLength
+          },
+          ...payment && {
+            ...knownAmount && {
+              costAmount: payment.amount,
+              costAsset: payment.asset
+            },
+            paymentProtocol: payment.protocol,
+            paymentChain: payment.chain,
+            paymentTxHash: payment.txHash ?? void 0,
+            paymentMode: payment.session ? "session" : "charge"
+          }
+        });
+        runId = result2.runId;
+      } catch (err) {
+        const errorMessage22 = err instanceof Error ? err.message : String(err);
+        const code = err instanceof ZeroError ? err.code : void 0;
+        const skipMsg = code ? `run_create_failed:${code}: ${errorMessage22}` : `run_create_failed: ${errorMessage22}`;
+        skipReasons.push(skipMsg);
+        client.logger?.({
+          level: "warn",
+          message: "Failed to record run for fetch",
+          meta: {
+            url: redactUrl2(url4),
+            capabilityId: effectiveCapabilityId,
+            error: errorMessage22,
+            errorCode: code
+          }
+        });
+      }
+    }
+  }
+  const result = {
+    runId,
+    ok: response.ok,
+    status: response.status,
+    latencyMs,
+    payment,
+    outcome: computeOutcome(response.status, payment, warnings),
+    body,
+    bodyRaw
+  };
+  if (bodyEncoding) result.bodyEncoding = bodyEncoding;
+  if (!response.ok) {
+    const candidate = bodyRaw !== null && bodyRaw.length > 0 && bodyEncoding !== "base64" ? bodyRaw.slice(0, 240) : null;
+    result.error = candidate !== null && !requestBodyEchoed(candidate, opts.body) ? candidate : `HTTP ${response.status}`;
+    if (upstreamErrorForRecord) result.upstreamError = upstreamErrorForRecord;
+  }
+  if (capabilityIdRequested && skipReasons.length > 0) {
+    result.runTrackingSkipped = skipReasons;
+  }
+  if (warnings.length > 0) result.warnings = warnings;
+  if (capabilityResolution !== void 0)
+    result.capabilityResolution = capabilityResolution;
+  return result;
+};
+var package_default2 = {
+  version: "0.7.0"
+};
+var SDK_VERSION2 = package_default2.version;
+var userWalletDtoSchema = external_exports3.object({
+  walletAddress: external_exports3.string(),
+  source: external_exports3.enum(["self_custody", "privy_embedded"]),
+  isPrimary: external_exports3.boolean(),
+  linkedAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).nullable().optional(),
+  delegationGranted: external_exports3.boolean(),
+  signerQuorumId: external_exports3.string().nullable(),
+  // Per-transaction USDC cap in base units (6 dp). null = unlimited, 0 = free-only.
+  maxTransactionUsdcBaseUnits: external_exports3.number().int().nullable()
+});
+var welcomeBonusSummarySchema = external_exports3.object({
+  status: external_exports3.string(),
+  amountUsd: external_exports3.number()
+});
+var internalUserDtoSchema = external_exports3.object({
+  id: external_exports3.string(),
+  email: external_exports3.string().nullable(),
+  createdAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).optional(),
+  lastLoginAt: external_exports3.union([external_exports3.string(), external_exports3.date()]).nullable().optional(),
+  onboardingCompleted: external_exports3.boolean().optional(),
+  delegationGranted: external_exports3.boolean().optional(),
+  wallets: external_exports3.array(userWalletDtoSchema).optional(),
+  balance: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }).nullable().optional(),
+  welcomeBonus: welcomeBonusSummarySchema.nullable().optional()
+});
+var publicUserDtoSchema = external_exports3.object({
+  user: external_exports3.object({
+    id: external_exports3.string(),
+    email: external_exports3.string().nullable()
+  }),
+  walletAddress: external_exports3.string().nullable(),
+  balance: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }).nullable(),
+  welcomeBonus: welcomeBonusSummarySchema.nullable()
+});
+var signResponseSchema = external_exports3.object({
+  signature: external_exports3.string().regex(/^0x[0-9a-fA-F]+$/, "must be 0x-prefixed hex"),
+  walletAddress: external_exports3.string().regex(/^0x[0-9a-fA-F]{40}$/, "must be 0x-prefixed 40-char hex address")
+});
+var deviceStartResponseSchema = external_exports3.object({
+  deviceCode: external_exports3.string(),
+  userCode: external_exports3.string(),
+  verificationUri: external_exports3.string(),
+  pollInterval: external_exports3.number(),
+  expiresAt: external_exports3.number()
+});
+var devicePollResponseSchema = external_exports3.union([
+  // userCode + verificationUri are optional: older API deployments don't
+  // echo them on pending.
+  external_exports3.object({
+    error: external_exports3.literal("authorization_pending"),
+    userCode: external_exports3.string().optional(),
+    verificationUri: external_exports3.string().optional()
+  }),
+  external_exports3.object({ error: external_exports3.literal("expired_token") }),
+  external_exports3.object({
+    accessToken: external_exports3.string(),
+    refreshToken: external_exports3.string(),
+    expiresIn: external_exports3.number(),
+    user: internalUserDtoSchema
+  })
+]);
+var sessionExchangeResponseSchema = external_exports3.object({
+  token: external_exports3.string(),
+  expiresAt: external_exports3.number()
+});
+var refreshResponseSchema = external_exports3.object({
+  accessToken: external_exports3.string(),
+  refreshToken: external_exports3.string()
+});
+var tryRefreshSession = async (client, callerSignal) => {
+  const credentials = client.getCredentials();
+  if (credentials.kind !== "session") return false;
+  if (!credentials.refreshToken) return false;
+  const url4 = `${client.baseUrl.replace(/\/$/, "")}/v1/auth/refresh`;
+  const timeoutSignal = AbortSignal.timeout(client.timeout);
+  const signal = callerSignal ? AbortSignal.any([callerSignal, timeoutSignal]) : timeoutSignal;
+  let response;
+  try {
+    response = await client.fetchImpl(url4, {
+      method: "POST",
+      headers: { "content-type": "application/json" },
+      body: JSON.stringify({ refreshToken: credentials.refreshToken }),
+      signal
+    });
+  } catch {
+    return false;
+  }
+  if (!response.ok) return false;
+  let body;
+  try {
+    body = await response.json();
+  } catch {
+    return false;
+  }
+  const parsed = refreshResponseSchema.safeParse(body);
+  if (!parsed.success) return false;
+  await client.applyRefreshedTokens({
+    accessToken: parsed.data.accessToken,
+    refreshToken: parsed.data.refreshToken
+  });
+  return true;
+};
+var buildSessionAuthHeaders = (accessToken) => ({
+  authorization: `Bearer ${accessToken}`
+});
+var buildCanonicalMessage = (method, pathWithQuery, body, timestamp, nonce2) => {
+  const bodyHash = createHash("sha256").update(body ?? "").digest("hex");
+  return `${method}:${pathWithQuery}:${bodyHash}:${timestamp}:${nonce2}`;
+};
+var buildAccountAuthHeaders = async (account, method, pathWithQuery, body) => {
+  const timestamp = Math.floor(Date.now() / 1e3).toString();
+  const nonce2 = crypto.randomUUID();
+  const message2 = buildCanonicalMessage(
+    method,
+    pathWithQuery,
+    body,
+    timestamp,
+    nonce2
+  );
+  const signature2 = await account.signMessage({ message: message2 });
+  return {
+    "x-zero-address": account.address,
+    "x-zero-timestamp": timestamp,
+    "x-zero-nonce": nonce2,
+    "x-zero-signature": signature2
+  };
+};
+var RETRYABLE_STATUS = /* @__PURE__ */ new Set([408, 502, 503, 504]);
+var sleep2 = (ms, signal) => new Promise((resolve6, reject) => {
+  if (signal?.aborted) {
+    reject(new DOMException("Aborted", "AbortError"));
+    return;
+  }
+  const timer = setTimeout(() => {
+    signal?.removeEventListener("abort", onAbort);
+    resolve6();
+  }, ms);
+  const onAbort = () => {
+    clearTimeout(timer);
+    reject(new DOMException("Aborted", "AbortError"));
+  };
+  signal?.addEventListener("abort", onAbort, { once: true });
+});
+var buildPathWithQuery = (path3, query) => {
+  const normalizedPath = path3.startsWith("/") ? path3 : `/${path3}`;
+  if (!query) return normalizedPath;
+  const params = new URLSearchParams();
+  for (const [key, value] of Object.entries(query)) {
+    if (value !== void 0) params.set(key, String(value));
+  }
+  const qs = params.toString();
+  return qs ? `${normalizedPath}?${qs}` : normalizedPath;
+};
+var joinUrl = (baseUrl, pathWithQuery) => {
+  const base3 = baseUrl.endsWith("/") ? baseUrl.slice(0, -1) : baseUrl;
+  return `${base3}${pathWithQuery}`;
+};
+var buildHeaders = async (client, method, pathWithQuery, hasBody, bodyStr) => {
+  const headers = { ...client.defaultHeaders };
+  if (hasBody) headers["content-type"] = "application/json";
+  headers["x-zero-sdk-version"] = SDK_VERSION2;
+  if (client.apiVersion) headers["x-zero-api-version"] = client.apiVersion;
+  const credentials = client.getCredentials();
+  if (credentials.kind === "session") {
+    Object.assign(headers, buildSessionAuthHeaders(credentials.accessToken));
+  } else if (credentials.kind === "account") {
+    const signed = await buildAccountAuthHeaders(
+      credentials.account,
+      method,
+      pathWithQuery,
+      bodyStr
+    );
+    Object.assign(headers, signed);
+  }
+  return headers;
+};
+var parseErrorBody = async (response) => {
+  try {
+    return await response.clone().json();
+  } catch {
+    try {
+      return await response.text();
+    } catch {
+      return void 0;
+    }
+  }
+};
+var errorMessageFromBody = (body, status) => {
+  if (body !== null && typeof body === "object" && "error" in body && typeof body.error === "string") {
+    return body.error;
+  }
+  return `HTTP ${status}`;
+};
+var request2 = async (client, opts, schema) => {
+  const pathWithQuery = buildPathWithQuery(opts.path, opts.query);
+  const url4 = joinUrl(client.baseUrl, pathWithQuery);
+  const hasBody = opts.body !== void 0;
+  const bodyStr = hasBody ? JSON.stringify(
+    opts.body,
+    (_k, v) => typeof v === "bigint" ? v.toString() : v
+  ) : void 0;
+  const configuredFetch = buildConfiguredFetch(client);
+  const performOnce = async () => configuredFetch(url4, {
+    method: opts.method,
+    headers: await buildHeaders(
+      client,
+      opts.method,
+      pathWithQuery,
+      hasBody,
+      bodyStr
+    ),
+    body: bodyStr,
+    signal: opts.signal
+  });
+  let refreshAttempted = false;
+  const executeWithRefresh = async () => {
+    const response = await performOnce();
+    if (response.status !== 401 || refreshAttempted) return response;
+    const credentials = client.getCredentials();
+    if (credentials.kind !== "session") return response;
+    refreshAttempted = true;
+    const refreshed = await client.refreshSessionOnce(opts.signal);
+    if (!refreshed) return response;
+    return await performOnce();
+  };
+  let lastNetworkError;
+  for (let attempt = 0; attempt <= client.maxRetries; attempt++) {
+    let response;
+    try {
+      response = await executeWithRefresh();
+    } catch (e2) {
+      if (e2 instanceof ZeroError) throw e2;
+      lastNetworkError = e2;
+      if (attempt < client.maxRetries) {
+        try {
+          await sleep2(2 ** attempt * 200, opts.signal);
+        } catch (sleepErr) {
+          throw new ZeroApiError("Request aborted by caller", {
+            status: 0,
+            cause: sleepErr
+          });
+        }
+        continue;
+      }
+      throw new ZeroApiError("Network request failed", {
+        status: 0,
+        cause: e2
+      });
+    }
+    if (response.ok) {
+      let text;
+      try {
+        text = await response.text();
+      } catch (e2) {
+        throw new ZeroApiError("Response body read failed", {
+          status: response.status,
+          cause: e2
+        });
+      }
+      let json3;
+      try {
+        json3 = JSON.parse(text);
+      } catch {
+      }
+      const parsed = schema.safeParse(json3);
+      if (!parsed.success) {
+        throw new ZeroValidationError(
+          `Response did not match expected schema for ${opts.method} ${opts.path}`,
+          { cause: parsed.error, body: text }
+        );
+      }
+      return parsed.data;
+    }
+    if (RETRYABLE_STATUS.has(response.status) && attempt < client.maxRetries) {
+      try {
+        await sleep2(2 ** attempt * 200, opts.signal);
+      } catch (sleepErr) {
+        throw new ZeroApiError("Request aborted by caller", {
+          status: 0,
+          cause: sleepErr
+        });
+      }
+      continue;
+    }
+    const errorBody = await parseErrorBody(response);
+    const requestId = response.headers.get("x-request-id") ?? void 0;
+    throw new ZeroApiError(errorMessageFromBody(errorBody, response.status), {
+      status: response.status,
+      requestId,
+      body: errorBody
+    });
+  }
+  throw new ZeroApiError("Exhausted retries", {
+    status: 0,
+    cause: lastNetworkError
+  });
+};
+var AuthDevice = class {
+  constructor(client) {
+    this.client = client;
+  }
+  start = (opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/auth/device/start",
+      signal: opts.signal
+    },
+    deviceStartResponseSchema
+  );
+  poll = async (deviceCode, opts = {}) => {
+    const parsed = await request2(
+      this.client,
+      {
+        method: "POST",
+        path: "/v1/auth/device/poll",
+        body: { deviceCode },
+        signal: opts.signal
+      },
+      devicePollResponseSchema
+    );
+    if ("error" in parsed) {
+      return parsed.error === "authorization_pending" ? {
+        status: "pending",
+        userCode: parsed.userCode,
+        verificationUri: parsed.verificationUri
+      } : { status: "expired" };
+    }
+    return {
+      status: "ok",
+      accessToken: parsed.accessToken,
+      refreshToken: parsed.refreshToken,
+      expiresIn: parsed.expiresIn,
+      user: parsed.user
+    };
+  };
+};
+var userWalletsSchema = external_exports3.array(userWalletDtoSchema);
+var normalizeMessage = (message2) => {
+  if (typeof message2 === "string") return message2;
+  if (typeof message2.raw === "string") return message2.raw;
+  return bytesToHex(message2.raw);
+};
+var repackageSignFailure = (err, op) => {
+  if (err instanceof ZeroApiError && err.status === 402) {
+    const body = err.body;
+    const detail = body && typeof body.error === "string" ? `: ${body.error}` : "";
+    throw new ZeroPaymentError(
+      `Sign endpoint refused ${op} (HTTP 402)${detail}`,
+      { cause: err }
+    );
+  }
+  throw err;
+};
+var Auth = class {
+  constructor(client) {
+    this.client = client;
+    this.device = new AuthDevice(client);
   }
   device;
   // The internal (web-app facing) user profile. Richer than profile(): full
@@ -145005,816 +145627,201 @@ var Runs = class {
     this.client,
     {
       method: "POST",
-      path: "/v1/reviews/batch",
-      body: { reviews },
-      signal: opts.signal
-    },
-    batchReviewResponseSchema
-  );
-};
-var USDC_BASE2 = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
-var USDC_TEMPO2 = "0x20c000000000000000000000b9537d11c60e8b50";
-var TEMPO_CHAIN_ID2 = 4217;
-var baseChain = base;
-var tempoChain2 = {
-  id: TEMPO_CHAIN_ID2,
-  name: "Tempo",
-  nativeCurrency: { name: "USD", symbol: "USD", decimals: 18 },
-  rpcUrls: {
-    default: { http: ["https://rpc.tempo.xyz"] }
-  }
-};
-var ERC20_BALANCE_ABI2 = [
-  {
-    inputs: [{ name: "account", type: "address" }],
-    name: "balanceOf",
-    outputs: [{ name: "", type: "uint256" }],
-    stateMutability: "view",
-    type: "function"
-  }
-];
-var USDC_DECIMALS = 6;
-var fundingUrlResponseSchema = external_exports3.object({ url: external_exports3.string() });
-var userWalletListSchema = external_exports3.array(userWalletDtoSchema);
-var migrateAuthorizationResponseSchema = external_exports3.object({
-  transactionHash: external_exports3.string()
-});
-var errorMessage = (reason) => reason instanceof Error ? reason.message : String(reason);
-var Wallet = class {
-  constructor(client) {
-    this.client = client;
-  }
-  clients = {};
-  // The configured wallet address, or null if the client wasn't constructed
-  // with an account. Stable read — does not hit the network.
-  get address() {
-    const credentials = this.client.getCredentials();
-    if (credentials.kind !== "account") return null;
-    return credentials.account.address;
-  }
-  balance = async (opts = {}) => {
-    const target = opts.address ?? this.address;
-    if (!target) {
-      throw new ZeroWalletError(
-        "balance() requires either an `address` option or a client constructed with an account"
-      );
-    }
-    const chain2 = opts.chain ?? "total";
-    if (chain2 !== "total") {
-      const raw = await this.readChainBalance(chain2, target);
-      return { amount: formatUnits(raw, USDC_DECIMALS), asset: "USDC" };
-    }
-    const chains = ["base", "tempo"];
-    const settled = await Promise.allSettled(
-      chains.map((c) => this.readChainBalance(c, target))
-    );
-    let sum = 0n;
-    const errors = [];
-    for (let i = 0; i < settled.length; i++) {
-      const result = settled[i];
-      const chainName = chains[i];
-      if (!result || !chainName) continue;
-      if (result.status === "fulfilled") {
-        sum += result.value;
-      } else {
-        errors.push({ chain: chainName, message: errorMessage(result.reason) });
-      }
-    }
-    if (errors.length === settled.length) {
-      throw new ZeroWalletError(
-        `balance() failed for every chain: ${errors.map((e2) => `${e2.chain} (${e2.message})`).join(", ")}`
-      );
-    }
-    const balance = {
-      amount: formatUnits(sum, USDC_DECIMALS),
-      asset: "USDC"
-    };
-    if (errors.length > 0) balance.errors = errors;
-    return balance;
-  };
-  // All wallets linked to the authenticated session user. Session-only.
-  list = (opts = {}) => request2(
-    this.client,
-    {
-      method: "GET",
-      path: "/v1/users/me/wallets",
-      signal: opts.signal
-    },
-    userWalletListSchema
-  );
-  // Provision a managed (Privy-embedded) wallet for the session user.
-  // Idempotent server-side — repeat calls return the existing wallet.
-  provision = (opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/users/me/wallets/provision",
-      signal: opts.signal
-    },
-    userWalletDtoSchema
-  );
-  // Relays a BYO-wallet-signed EIP-3009 ReceiveWithAuthorization, sweeping
-  // USDC from the BYO wallet to the user's Zero wallet on Base via the
-  // gas-paying relayer. The SDK does not author the authorization (chain
-  // nonce + EIP-712 domain coupling stays caller-side); it only forwards
-  // the signed payload. Session-only.
-  migrateAuthorization = (authorization, opts = {}) => request2(
-    this.client,
-    {
-      method: "POST",
-      path: "/v1/users/me/wallets/migrate",
-      body: { authorization },
-      signal: opts.signal
-    },
-    migrateAuthorizationResponseSchema
-  );
-  // Routes by identity: account mode signs EIP-191 against /v1/wallet/fund-url,
-  // session mode hits /v1/users/me/fund-url (Bearer-authed, wallet resolved
-  // server-side). Both honor `provider` (coinbase | stripe).
-  fundingUrl = async (opts = {}) => {
-    const credentials = this.client.getCredentials();
-    const path3 = credentials.kind === "account" ? "/v1/wallet/fund-url" : credentials.kind === "session" ? "/v1/users/me/fund-url" : null;
-    if (!path3) {
-      throw new ZeroWalletError(
-        "fundingUrl() requires a client constructed with an account or session credentials"
-      );
-    }
-    const query = {
-      provider: opts.provider ?? "coinbase"
-    };
-    if (opts.amount) query.amount = opts.amount;
-    const { url: url4 } = await request2(
-      this.client,
-      { method: "GET", path: path3, query, signal: opts.signal },
-      fundingUrlResponseSchema
-    );
-    return url4;
-  };
-  getPublicClient = (chain2) => {
-    if (chain2 === "base") {
-      if (!this.clients.base) {
-        this.clients.base = createPublicClient({
-          chain: baseChain,
-          transport: http()
-        });
-      }
-      return this.clients.base;
-    }
-    if (!this.clients.tempo) {
-      this.clients.tempo = createPublicClient({
-        // biome-ignore lint/suspicious/noExplicitAny: tempo is a custom chain object that viem's stricter Chain type rejects shape-wise but accepts at runtime
-        chain: tempoChain2,
-        transport: http()
-      });
-    }
-    return this.clients.tempo;
-  };
-  /**
-   * @internal
-   *
-   * Per-chain USDC balance read. Exposed (rather than private) so unit
-   * tests can stub it without standing up a real viem public client —
-   * viem's `http()` transport doesn't go through `client.fetchImpl`, so
-   * the standard mock-fetch trick doesn't cover this path.
-   */
-  readChainBalance = async (chain2, address2) => {
-    const publicClient = this.getPublicClient(chain2);
-    const tokenAddress = chain2 === "base" ? USDC_BASE2 : USDC_TEMPO2;
-    const balance = await publicClient.readContract({
-      address: tokenAddress,
-      abi: ERC20_BALANCE_ABI2,
-      functionName: "balanceOf",
-      args: [address2]
-    });
-    return balance;
-  };
-};
-var DEFAULT_BASE_URL = "https://api.zero.xyz";
-var DEFAULT_TIMEOUT_MS = 18e4;
-var DEFAULT_MAX_RETRIES = 2;
-var noopRefresh = async () => {
-};
-var MAX_402_PROBE_BYTES = 1024 * 1024;
-var MAX_RESPONSE_BYTES = 10 * 1024 * 1024;
-var TEXT_CONTENT_TYPES = [
-  "application/json",
-  "application/xml",
-  "application/javascript",
-  "application/ecmascript",
-  "application/x-www-form-urlencoded",
-  "text/",
-  "+json",
-  "+xml"
-];
-var MPP_SCHEME_TOKENS = /* @__PURE__ */ new Set(["payment", "mpp"]);
-var splitWwwAuthenticateChallenges = (header) => {
-  const chunks = [];
-  let buf = "";
-  let inQuotes = false;
-  for (let i = 0; i < header.length; i++) {
-    const ch = header[i];
-    if (inQuotes) {
-      if (ch === "\\" && i + 1 < header.length) {
-        buf += ch + header[i + 1];
-        i++;
-        continue;
-      }
-      if (ch === '"') inQuotes = false;
-      buf += ch;
-      continue;
-    }
-    if (ch === '"') {
-      inQuotes = true;
-      buf += ch;
-      continue;
-    }
-    if (ch === ",") {
-      chunks.push(buf);
-      buf = "";
-      continue;
-    }
-    buf += ch;
-  }
-  if (buf.length > 0) chunks.push(buf);
-  return chunks;
-};
-var isTextContentType = (contentType) => {
-  if (!contentType) return true;
-  const lower = contentType.toLowerCase();
-  return TEXT_CONTENT_TYPES.some((marker) => lower.includes(marker));
-};
-var redactUrl2 = (url4) => {
-  try {
-    const u2 = new URL(url4);
-    return `${u2.origin}${u2.pathname}`;
-  } catch {
-    return "<invalid url>";
-  }
-};
-var ECHO_DETECT_MIN_LEN = 16;
-var ECHO_DETECT_MAX_SCAN = 64 * 1024;
-var requestBodyEchoed = (candidate, requestBody) => {
-  if (requestBody === void 0) return false;
-  const asString = typeof requestBody === "string" ? requestBody : new TextDecoder("utf-8", { fatal: false }).decode(
-    requestBody.byteLength > ECHO_DETECT_MAX_SCAN ? requestBody.subarray(0, ECHO_DETECT_MAX_SCAN) : requestBody
-  );
-  if (asString.length < ECHO_DETECT_MIN_LEN) return false;
-  const scanLen = Math.min(asString.length, ECHO_DETECT_MAX_SCAN);
-  for (let i = 0; i + ECHO_DETECT_MIN_LEN <= scanLen; i++) {
-    if (candidate.includes(asString.slice(i, i + ECHO_DETECT_MIN_LEN))) {
-      return true;
-    }
-  }
-  return false;
-};
-var cancelBody2 = (response) => {
-  try {
-    response.body?.cancel().catch(() => {
-    });
-  } catch {
-  }
-};
-var detectPaymentRequirement = async (response) => {
-  if (response.status !== 402) return null;
-  const x402Header = response.headers.get("payment-required") ?? response.headers.get("x-payment-required");
-  if (x402Header) {
-    cancelBody2(response);
-    try {
-      const decoded = JSON.parse(
-        Buffer.from(x402Header, "base64").toString("utf8")
-      );
-      return { protocol: "x402", raw: decoded };
-    } catch {
-      return { protocol: "x402", raw: { encoded: x402Header } };
-    }
-  }
-  const declaredLen = Number.parseInt(
-    response.headers.get("content-length") ?? "",
-    10
-  );
-  const bodyFits = !Number.isFinite(declaredLen) || declaredLen <= MAX_402_PROBE_BYTES;
-  if (bodyFits) {
-    try {
-      const text = await readClippedText(response, MAX_402_PROBE_BYTES);
-      if (text) {
-        const parsed = JSON.parse(text);
-        if (looksLikeX402Body(parsed)) {
-          return { protocol: "x402", raw: parsed };
-        }
-      }
-    } catch {
-    }
-  }
-  const wwwAuth = response.headers.get("www-authenticate");
-  if (wwwAuth) {
-    const schemes = splitWwwAuthenticateChallenges(wwwAuth).map(
-      (challenge2) => challenge2.trim().split(/\s+/)[0]?.toLowerCase() ?? ""
-    );
-    if (schemes.some((scheme) => MPP_SCHEME_TOKENS.has(scheme))) {
-      cancelBody2(response);
-      return { protocol: "mpp", raw: { "www-authenticate": wwwAuth } };
-    }
-  }
-  cancelBody2(response);
-  return { protocol: "unknown", raw: {} };
-};
-var readClippedBytes = async (response, max) => {
-  if (response.body === null) return new Uint8Array(0);
-  const reader = response.body.getReader();
-  const chunks = [];
-  let total = 0;
-  try {
-    while (total < max) {
-      const { done, value } = await reader.read();
-      if (done) break;
-      if (!value) continue;
-      chunks.push(value);
-      total += value.byteLength;
-    }
-  } finally {
-    try {
-      await reader.cancel();
-    } catch {
-    }
-  }
-  const merged = new Uint8Array(Math.min(total, max));
-  let offset = 0;
-  for (const c of chunks) {
-    const take = Math.min(c.byteLength, max - offset);
-    merged.set(c.subarray(0, take), offset);
-    offset += take;
-    if (offset >= max) break;
-  }
-  return merged;
-};
-var readClippedText = async (response, max) => {
-  const bytes = await readClippedBytes(response, max);
-  return new TextDecoder().decode(bytes);
-};
-var parseResponseBody = async (response, max) => {
-  const contentType = response.headers.get("content-type");
-  const bytes = await readClippedBytes(response, max + 1);
-  const truncated = bytes.byteLength > max;
-  const view = truncated ? bytes.subarray(0, max) : bytes;
-  const buf = Buffer.from(view.buffer, view.byteOffset, view.byteLength);
-  if (!isTextContentType(contentType)) {
-    const base644 = buf.toString("base64");
-    return {
-      body: base644,
-      bodyRaw: base644,
-      bodyEncoding: "base64",
-      truncated
-    };
-  }
-  const text = buf.toString("utf8");
-  if (contentType?.toLowerCase().includes("json")) {
-    try {
-      return { body: JSON.parse(text), bodyRaw: text, truncated };
-    } catch {
-    }
-  }
-  return { body: text, bodyRaw: text, truncated };
-};
-var UPSTREAM_ERROR_FIELDS = [
-  "error",
-  "message",
-  "detail",
-  "reason",
-  "error_description"
-];
-var UPSTREAM_ERROR_MAX_LEN = 200;
-var ERROR_SNIPPET_BYTES = 500;
-var clampUpstreamMessage = (value) => {
-  const trimmed = value.trim();
-  if (!trimmed) return void 0;
-  return trimmed.length > UPSTREAM_ERROR_MAX_LEN ? `${trimmed.slice(0, UPSTREAM_ERROR_MAX_LEN)}\u2026` : trimmed;
-};
-var tryParseJson = (text) => {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return null;
-  }
-};
-var extractUpstreamErrorMessage = (body) => {
-  const parsed = tryParseJson(body);
-  if (parsed === null || typeof parsed !== "object") {
-    return clampUpstreamMessage(body);
-  }
-  const record3 = parsed;
-  for (const field of UPSTREAM_ERROR_FIELDS) {
-    const value = record3[field];
-    if (typeof value === "string" && value.length > 0) {
-      return clampUpstreamMessage(value);
-    }
-    if (value && typeof value === "object") {
-      const nested = value.message;
-      if (typeof nested === "string" && nested.length > 0) {
-        return clampUpstreamMessage(nested);
-      }
-    }
-  }
-  return void 0;
-};
-var buildUpstreamError = (status, bodyRaw, bodyEncoding) => {
-  if (status >= 200 && status < 300) return void 0;
-  if (bodyRaw === null || bodyRaw.length === 0) return void 0;
-  if (bodyEncoding === "base64") return void 0;
-  const snippet = bodyRaw.slice(0, ERROR_SNIPPET_BYTES);
-  return {
-    status,
-    message: extractUpstreamErrorMessage(bodyRaw),
-    snippetHash: createHash("sha256").update(snippet).digest("hex"),
-    snippetLength: snippet.length
-  };
-};
-var computeOutcome = (status, payment, warnings) => {
-  if (warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed))
-    return "payment_close_failed";
-  if (status === 402 && payment !== null) return "payment_rejected";
-  if (status === 402) return "payment_failed";
-  if (status >= 400) return "server_error";
-  return "success";
-};
-var errorFetchResult = (startedAt, error48, skipReason, capabilityIdRequested, outcome, status = null) => {
-  const result = {
-    runId: null,
-    ok: false,
-    status,
-    latencyMs: Date.now() - startedAt,
-    payment: null,
-    outcome,
-    body: null,
-    bodyRaw: null,
-    error: error48
-  };
-  if (capabilityIdRequested) result.runTrackingSkipped = [skipReason];
-  return result;
-};
-var resolveRecordingClient = (client, opts) => {
-  const credentials = client.getCredentials();
-  const recordingClient = opts.account ? client.withAccount(opts.account) : client;
-  const canRecord = opts.account !== void 0 || credentials.kind === "account" || credentials.kind === "session";
-  return { recordingClient, canRecord };
-};
-var recordErrorFetchRun = async (client, opts, result, capabilityIdOverride) => {
-  const effectiveCapId = opts.capabilityId;
-  if (effectiveCapId === void 0) return;
-  const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
-  if (!canRecord) return;
-  const fetchOriginForRecord = opts.capabilityId === void 0 ? "direct_url" : opts.fetchOrigin;
-  try {
-    const created = await recordingClient.runs.create({
-      capabilityId: effectiveCapId,
-      ...opts.searchId && { searchId: opts.searchId },
-      ...fetchOriginForRecord && { fetchOrigin: fetchOriginForRecord },
-      ...result.status !== null && { status: result.status },
-      latencyMs: result.latencyMs,
-      ...opts.requestSchema && { requestSchema: opts.requestSchema }
-    });
-    result.runId = created.runId;
-    delete result.runTrackingSkipped;
-  } catch {
-  }
-};
-var recordTimeoutRun = async (client, opts, err, startedAt, capabilityIdRequested, capabilityIdOverride) => {
-  const result = errorFetchResult(
-    startedAt,
-    err.message,
-    "timeout",
-    capabilityIdRequested,
-    "network_error"
+      path: "/v1/reviews/batch",
+      body: { reviews },
+      signal: opts.signal
+    },
+    batchReviewResponseSchema
   );
-  await recordErrorFetchRun(client, opts, result);
 };
-var sniffJsonShapeBytes = (buf) => {
-  let i = 0;
-  if (buf.length >= 3 && buf[0] === 239 && buf[1] === 187 && buf[2] === 191) {
-    i = 3;
-  }
-  while (i < buf.length && (buf[i] === 32 || buf[i] === 9 || buf[i] === 10 || buf[i] === 13)) {
-    i++;
+var USDC_BASE2 = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
+var USDC_TEMPO2 = "0x20c000000000000000000000b9537d11c60e8b50";
+var TEMPO_CHAIN_ID2 = 4217;
+var baseChain = base;
+var tempoChain2 = {
+  id: TEMPO_CHAIN_ID2,
+  name: "Tempo",
+  nativeCurrency: { name: "USD", symbol: "USD", decimals: 18 },
+  rpcUrls: {
+    default: { http: ["https://rpc.tempo.xyz"] }
   }
-  if (i >= buf.length) return false;
-  return buf[i] === 123 || buf[i] === 91;
 };
-var withDefaultContentType = (headers, body) => {
-  if (!headers && body === void 0) return void 0;
-  const next = headers ? { ...headers } : {};
-  if (body === void 0) return next;
-  const hasContentType = Object.keys(next).some(
-    (k3) => k3.toLowerCase() === "content-type"
-  );
-  if (!hasContentType) {
-    next["content-type"] = typeof body === "string" || sniffJsonShapeBytes(body) ? "application/json" : "application/octet-stream";
+var ERC20_BALANCE_ABI2 = [
+  {
+    inputs: [{ name: "account", type: "address" }],
+    name: "balanceOf",
+    outputs: [{ name: "", type: "uint256" }],
+    stateMutability: "view",
+    type: "function"
   }
-  return next;
-};
-var clientFetch = async (client, url4, opts = {}) => {
-  const startedAt = Date.now();
-  const capabilityIdRequested = opts.capabilityId !== void 0;
-  const normalized = normalizeTransportEnvelopeRequest(url4, {
-    method: opts.method,
-    body: opts.body
-  });
-  const requestUrl = normalized.url;
-  const requestBody = normalized.body;
-  const method = normalized.method ?? (requestBody !== void 0 ? "POST" : "GET");
-  const { canRecord: canRecordForResolve } = resolveRecordingClient(
-    client,
-    opts
-  );
-  const resolvePromise = !capabilityIdRequested && canRecordForResolve ? client.capabilities.resolveByUrl(redactUrl2(requestUrl), method).catch(() => null) : Promise.resolve(null);
-  const probeHeaders = withDefaultContentType(opts.headers, requestBody);
-  const requestInit = {
-    method,
-    headers: probeHeaders,
-    body: requestBody,
-    signal: opts.signal
-  };
-  const configuredFetch = buildConfiguredFetch(client, {
-    timeoutMs: opts.timeoutMs
-  });
-  let response;
-  let payment = null;
-  const skipReasons = [];
-  const warnings = [];
-  try {
-    response = await configuredFetch(requestUrl, requestInit);
-  } catch (err) {
-    if (err instanceof ZeroTimeoutError) {
-      await recordTimeoutRun(
-        client,
-        opts,
-        err,
-        startedAt,
-        capabilityIdRequested
-      );
-      throw err;
-    }
-    if (err instanceof ZeroError) throw err;
-    const errMessage = err instanceof Error ? err.message : String(err);
-    const result2 = errorFetchResult(
-      startedAt,
-      errMessage,
-      "fetch_failed_before_response",
-      capabilityIdRequested,
-      "network_error"
-    );
-    await recordErrorFetchRun(client, opts, result2);
-    return result2;
+];
+var USDC_DECIMALS = 6;
+var fundingUrlResponseSchema = external_exports3.object({ url: external_exports3.string() });
+var userWalletListSchema = external_exports3.array(userWalletDtoSchema);
+var migrateAuthorizationResponseSchema = external_exports3.object({
+  transactionHash: external_exports3.string()
+});
+var errorMessage = (reason) => reason instanceof Error ? reason.message : String(reason);
+var Wallet = class {
+  constructor(client) {
+    this.client = client;
   }
-  if (response.status === 402) {
-    const requirement = await detectPaymentRequirement(response);
-    if (requirement?.protocol === "x402" || requirement?.protocol === "mpp") {
-      const payCall = requirement.protocol === "x402" ? client.payments.pay : client.payments.payMpp;
-      try {
-        const paid = await payCall({
-          url: requestUrl,
-          method,
-          // Fresh clone for the paid retry — same rationale as
-          // the probe-side clone above. Re-derives the default
-          // Content-Type so the paid leg matches the probe.
-          headers: withDefaultContentType(opts.headers, requestBody),
-          body: requestBody,
-          maxPay: opts.maxPay,
-          account: opts.account,
-          signal: opts.signal,
-          timeoutMs: opts.timeoutMs,
-          ...opts.displayCostAmount && {
-            displayCostAmount: opts.displayCostAmount
-          }
-        });
-        response = paid.response;
-        payment = paid.payment;
-        if (paid.warnings) warnings.push(...paid.warnings);
-      } catch (err) {
-        if (err instanceof ZeroSessionCloseFailedError) {
-          response = err.response;
-          payment = {
-            protocol: "mpp",
-            chain: tempoChainLabelFromId(err.session.chainId),
-            txHash: null,
-            amount: err.capturedAmount,
-            asset: "USDC",
-            session: err.session
-          };
-          warnings.push(FETCH_WARNINGS.mppSessionCloseFailed);
-        } else if (err instanceof ZeroInsufficientFundsError) {
-          return errorFetchResult(
-            startedAt,
-            err.message,
-            FETCH_SKIP_REASONS.insufficientFunds,
-            capabilityIdRequested,
-            "insufficient_funds",
-            null
-          );
-        } else if (err instanceof ZeroPaymentError || err instanceof ZeroAuthError) {
-          const result2 = errorFetchResult(
-            startedAt,
-            err.message,
-            "payment_failed",
-            capabilityIdRequested,
-            "payment_failed",
-            402
-          );
-          await recordErrorFetchRun(client, opts, result2);
-          return result2;
-        } else if (err instanceof ZeroTimeoutError) {
-          await recordTimeoutRun(
-            client,
-            opts,
-            err,
-            startedAt,
-            capabilityIdRequested
-          );
-          throw err;
-        } else {
-          throw err;
-        }
-      }
-    } else if (requirement?.protocol === "unknown") {
-      const result2 = errorFetchResult(
-        startedAt,
-        "Capability returned 402 with an unrecognized payment protocol. Neither x402 nor MPP markers were detected in the response headers or body.",
-        "unrecognized_402_protocol",
-        capabilityIdRequested,
-        "payment_failed",
-        402
-      );
-      await recordErrorFetchRun(client, opts, result2);
-      return result2;
-    }
+  clients = {};
+  // The configured wallet address, or null if the client wasn't constructed
+  // with an account. Stable read — does not hit the network.
+  get address() {
+    const credentials = this.client.getCredentials();
+    if (credentials.kind !== "account") return null;
+    return credentials.account.address;
   }
-  const latencyMs = Date.now() - startedAt;
-  const maxResponseBytes = opts.maxResponseBytes ?? MAX_RESPONSE_BYTES;
-  let body;
-  let bodyRaw;
-  let bodyEncoding;
-  try {
-    const parsed = await parseResponseBody(response, maxResponseBytes);
-    body = parsed.body;
-    bodyRaw = parsed.bodyRaw;
-    bodyEncoding = parsed.bodyEncoding;
-    if (parsed.truncated) warnings.push(FETCH_WARNINGS.bodyTruncated);
-  } catch (err) {
-    if (err instanceof Error && err.name === "AbortError") {
-      throw new ZeroApiError("Request aborted by caller", {
-        status: 0,
-        cause: err
-      });
+  balance = async (opts = {}) => {
+    const target = opts.address ?? this.address;
+    if (!target) {
+      throw new ZeroWalletError(
+        "balance() requires either an `address` option or a client constructed with an account"
+      );
     }
-    const message2 = err instanceof Error ? err.message : String(err);
-    const skips = [];
-    const settledLocally = paymentHasAnchor(payment);
-    if (settledLocally && response.status === 402) {
-      warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
-      skips.push(FETCH_WARNINGS.paidButStill402NotRecorded);
+    const chain2 = opts.chain ?? "total";
+    if (chain2 !== "total") {
+      const raw = await this.readChainBalance(chain2, target);
+      return { amount: formatUnits(raw, USDC_DECIMALS), asset: "USDC" };
     }
-    if (payment !== null && !settledLocally) {
-      warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
-      skips.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
+    const chains = ["base", "tempo"];
+    const settled = await Promise.allSettled(
+      chains.map((c) => this.readChainBalance(c, target))
+    );
+    let sum = 0n;
+    const errors = [];
+    for (let i = 0; i < settled.length; i++) {
+      const result = settled[i];
+      const chainName = chains[i];
+      if (!result || !chainName) continue;
+      if (result.status === "fulfilled") {
+        sum += result.value;
+      } else {
+        errors.push({ chain: chainName, message: errorMessage(result.reason) });
+      }
     }
-    if (payment !== null && payment.amount === "unknown") {
-      warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
+    if (errors.length === settled.length) {
+      throw new ZeroWalletError(
+        `balance() failed for every chain: ${errors.map((e2) => `${e2.chain} (${e2.message})`).join(", ")}`
+      );
     }
-    skips.push(FETCH_SKIP_REASONS.bodyReadFailed);
-    const result2 = {
-      runId: null,
-      ok: false,
-      status: response.status,
-      latencyMs: Date.now() - startedAt,
-      payment,
-      outcome: computeOutcome(response.status, payment, warnings),
-      body: null,
-      bodyRaw: null,
-      error: message2
+    const balance = {
+      amount: formatUnits(sum, USDC_DECIMALS),
+      asset: "USDC"
     };
-    if (capabilityIdRequested) result2.runTrackingSkipped = skips;
-    if (warnings.length > 0) result2.warnings = warnings;
-    return result2;
-  }
-  const settled = paymentHasAnchor(payment);
-  const paidButStill402 = settled && response.status === 402;
-  const settlementUnconfirmed = payment !== null && !settled;
-  if (paidButStill402) warnings.push(FETCH_WARNINGS.paidButStill402NotRecorded);
-  if (settlementUnconfirmed)
-    warnings.push(FETCH_WARNINGS.paymentSettlementUnconfirmed);
-  if (payment !== null && payment.amount === "unknown") {
-    warnings.push(FETCH_WARNINGS.paymentAmountUnknown);
-  }
-  let runId = null;
-  const closeFailed = warnings.includes(FETCH_WARNINGS.mppSessionCloseFailed);
-  const upstreamErrorForRecord = buildUpstreamError(
-    response.status,
-    bodyRaw,
-    bodyEncoding
+    if (errors.length > 0) balance.errors = errors;
+    return balance;
+  };
+  // All wallets linked to the authenticated session user. Session-only.
+  list = (opts = {}) => request2(
+    this.client,
+    {
+      method: "GET",
+      path: "/v1/users/me/wallets",
+      signal: opts.signal
+    },
+    userWalletListSchema
   );
-  if (capabilityIdRequested) {
-    if (paidButStill402)
-      skipReasons.push(FETCH_WARNINGS.paidButStill402NotRecorded);
-    else if (closeFailed)
-      skipReasons.push(FETCH_SKIP_REASONS.mppSessionCloseFailedNotRecorded);
-  }
-  const resolvedCap = await resolvePromise;
-  const effectiveCapabilityId = opts.capabilityId ?? resolvedCap?.capabilityId;
-  const capabilityResolution = !capabilityIdRequested && canRecordForResolve ? resolvedCap !== null ? {
-    resolved: true,
-    capabilityId: resolvedCap.capabilityId,
-    capabilitySlug: resolvedCap.capabilitySlug,
-    matchedVia: resolvedCap.matchedVia
-  } : { resolved: false } : void 0;
-  if (effectiveCapabilityId !== void 0 && !paidButStill402 && !closeFailed) {
-    const { recordingClient, canRecord } = resolveRecordingClient(client, opts);
-    if (!canRecord) {
-      skipReasons.push("no_credentials");
-    } else {
-      const knownAmount = payment !== null && payment.amount !== "unknown";
-      try {
-        let derived;
-        if (opts.deriveRunMetadata) {
-          try {
-            derived = opts.deriveRunMetadata({
-              status: response.status,
-              ok: response.ok,
-              bodyRaw,
-              ...bodyEncoding && { bodyEncoding }
-            });
-          } catch {
-          }
-        }
-        const result2 = await recordingClient.runs.create({
-          capabilityId: effectiveCapabilityId,
-          searchId: opts.searchId,
-          // Auto-resolved runs are always direct_url — they only fire when
-          // no capabilityId was supplied (the direct_url path by definition).
-          ...opts.capabilityId === void 0 ? { fetchOrigin: "direct_url" } : opts.fetchOrigin && { fetchOrigin: opts.fetchOrigin },
-          status: response.status,
-          latencyMs,
-          ...opts.requestSchema && { requestSchema: opts.requestSchema },
-          ...derived?.responseSchema && {
-            responseSchema: derived.responseSchema
-          },
-          ...upstreamErrorForRecord && {
-            errorSnippetHash: upstreamErrorForRecord.snippetHash,
-            errorSnippetLength: upstreamErrorForRecord.snippetLength
-          },
-          ...payment && {
-            ...knownAmount && {
-              costAmount: payment.amount,
-              costAsset: payment.asset
-            },
-            paymentProtocol: payment.protocol,
-            paymentChain: payment.chain,
-            paymentTxHash: payment.txHash ?? void 0,
-            paymentMode: payment.session ? "session" : "charge"
-          }
-        });
-        runId = result2.runId;
-      } catch (err) {
-        const errorMessage22 = err instanceof Error ? err.message : String(err);
-        const code = err instanceof ZeroError ? err.code : void 0;
-        const skipMsg = code ? `run_create_failed:${code}: ${errorMessage22}` : `run_create_failed: ${errorMessage22}`;
-        skipReasons.push(skipMsg);
-        client.logger?.({
-          level: "warn",
-          message: "Failed to record run for fetch",
-          meta: {
-            url: redactUrl2(url4),
-            capabilityId: effectiveCapabilityId,
-            error: errorMessage22,
-            errorCode: code
-          }
+  // Provision a managed (Privy-embedded) wallet for the session user.
+  // Idempotent server-side — repeat calls return the existing wallet.
+  provision = (opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/users/me/wallets/provision",
+      signal: opts.signal
+    },
+    userWalletDtoSchema
+  );
+  // Relays a BYO-wallet-signed EIP-3009 ReceiveWithAuthorization, sweeping
+  // USDC from the BYO wallet to the user's Zero wallet on Base via the
+  // gas-paying relayer. The SDK does not author the authorization (chain
+  // nonce + EIP-712 domain coupling stays caller-side); it only forwards
+  // the signed payload. Session-only.
+  migrateAuthorization = (authorization, opts = {}) => request2(
+    this.client,
+    {
+      method: "POST",
+      path: "/v1/users/me/wallets/migrate",
+      body: { authorization },
+      signal: opts.signal
+    },
+    migrateAuthorizationResponseSchema
+  );
+  // Routes by identity: account mode signs EIP-191 against /v1/wallet/fund-url,
+  // session mode hits /v1/users/me/fund-url (Bearer-authed, wallet resolved
+  // server-side). Both honor `provider` (coinbase | stripe).
+  fundingUrl = async (opts = {}) => {
+    const credentials = this.client.getCredentials();
+    const path3 = credentials.kind === "account" ? "/v1/wallet/fund-url" : credentials.kind === "session" ? "/v1/users/me/fund-url" : null;
+    if (!path3) {
+      throw new ZeroWalletError(
+        "fundingUrl() requires a client constructed with an account or session credentials"
+      );
+    }
+    const query = {
+      provider: opts.provider ?? "coinbase"
+    };
+    if (opts.amount) query.amount = opts.amount;
+    const { url: url4 } = await request2(
+      this.client,
+      { method: "GET", path: path3, query, signal: opts.signal },
+      fundingUrlResponseSchema
+    );
+    return url4;
+  };
+  getPublicClient = (chain2) => {
+    if (chain2 === "base") {
+      if (!this.clients.base) {
+        this.clients.base = createPublicClient({
+          chain: baseChain,
+          transport: http()
         });
       }
+      return this.clients.base;
     }
-  }
-  const result = {
-    runId,
-    ok: response.ok,
-    status: response.status,
-    latencyMs,
-    payment,
-    outcome: computeOutcome(response.status, payment, warnings),
-    body,
-    bodyRaw
+    if (!this.clients.tempo) {
+      this.clients.tempo = createPublicClient({
+        // biome-ignore lint/suspicious/noExplicitAny: tempo is a custom chain object that viem's stricter Chain type rejects shape-wise but accepts at runtime
+        chain: tempoChain2,
+        transport: http()
+      });
+    }
+    return this.clients.tempo;
   };
-  if (bodyEncoding) result.bodyEncoding = bodyEncoding;
-  if (!response.ok) {
-    const candidate = bodyRaw !== null && bodyRaw.length > 0 && bodyEncoding !== "base64" ? bodyRaw.slice(0, 240) : null;
-    result.error = candidate !== null && !requestBodyEchoed(candidate, opts.body) ? candidate : `HTTP ${response.status}`;
-    if (upstreamErrorForRecord) result.upstreamError = upstreamErrorForRecord;
-  }
-  if (capabilityIdRequested && skipReasons.length > 0) {
-    result.runTrackingSkipped = skipReasons;
-  }
-  if (warnings.length > 0) result.warnings = warnings;
-  if (capabilityResolution !== void 0)
-    result.capabilityResolution = capabilityResolution;
-  return result;
+  /**
+   * @internal
+   *
+   * Per-chain USDC balance read. Exposed (rather than private) so unit
+   * tests can stub it without standing up a real viem public client —
+   * viem's `http()` transport doesn't go through `client.fetchImpl`, so
+   * the standard mock-fetch trick doesn't cover this path.
+   */
+  readChainBalance = async (chain2, address2) => {
+    const publicClient = this.getPublicClient(chain2);
+    const tokenAddress = chain2 === "base" ? USDC_BASE2 : USDC_TEMPO2;
+    const balance = await publicClient.readContract({
+      address: tokenAddress,
+      abi: ERC20_BALANCE_ABI2,
+      functionName: "balanceOf",
+      args: [address2]
+    });
+    return balance;
+  };
+};
+var DEFAULT_BASE_URL = "https://api.zero.xyz";
+var DEFAULT_TIMEOUT_MS = 18e4;
+var DEFAULT_MAX_RETRIES = 2;
+var noopRefresh = async () => {
 };
 var searchResultSchema = external_exports3.object({
   id: external_exports3.string(),
+  // Opaque attribution token (format: `z_{shortId}.{position}`). Optional
+  // so old API deploys that don't emit it still parse cleanly. Pass as
+  // capabilityId to client.fetch() for exact search attribution.
+  token: external_exports3.string().nullable().optional(),
   position: external_exports3.number(),
   slug: external_exports3.string(),
   name: external_exports3.string(),
@@ -145833,6 +145840,9 @@ var searchResultSchema = external_exports3.object({
   cost: external_exports3.object({ amount: external_exports3.string(), asset: external_exports3.string() }),
   reviewCount: external_exports3.number().optional(),
   rating: ratingSchema,
+  // All-time activation count (non-deleted runs), mirroring capabilities.ts.
+  // Optional so a response from an older API deploy still parses (ZERO-385).
+  activationCount: external_exports3.number().optional(),
   availabilityStatus: external_exports3.enum(["healthy", "unknown", "down"]).nullable().optional(),
   /**
    * @deprecated The API no longer emits `displayStatus`; it has been replaced
@@ -146313,7 +146323,7 @@ Categories the classifier picks from:
 ).action(
   async (description, options) => {
     try {
-      const { analyticsService, client, stateService, walletAddress } = appContext.services;
+      const { analyticsService, client, walletAddress } = appContext.services;
       if (!walletAddress) {
         console.error(
           "Wallet auth required \u2014 run `zero auth login`, or `zero wallet set <key>` / set ZERO_PRIVATE_KEY."
@@ -146394,12 +146404,6 @@ Bulk bug-report complete: ${ok} ok, ${failed} failed`
       let { capability, run, search } = options;
       const useAutoContext = options.context !== false;
       if (useAutoContext) {
-        const lastSearch = stateService.loadLastSearch();
-        if (lastSearch) {
-          search = search ?? lastSearch.searchId;
-          const recent = lastSearch.capabilities[0];
-          capability = capability ?? recent?.id;
-        }
         if (!run) {
           try {
             const list2 = await client.runs.list({ limit: 1 });
@@ -146607,11 +146611,6 @@ var sniffJsonShape = (buf) => {
   if (i >= buf.length) return false;
   return buf[i] === 123 || buf[i] === 91;
 };
-var urlMatchesTemplate = (url4, template) => {
-  const escaped = template.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-  const withCaptures = escaped.replace(/\\\{[^/\\}]+\\\}/g, "[^/]+");
-  return new RegExp(`^${withCaptures}$`).test(url4);
-};
 var resolveRequestBody = (rawData, readStdin2) => {
   const fromFile = (spec) => {
     if (spec === "@-") return readFileSync(0);
@@ -146678,27 +146677,25 @@ var fetchCommand = (appContext) => new Command("fetch").description(
 ).action(
   async (url4, options) => {
     try {
-      const {
-        analyticsService,
-        client,
-        stateService,
-        walletAddress,
-        lowBalanceWarning
-      } = appContext.services;
+      const { analyticsService, client, walletAddress, lowBalanceWarning } = appContext.services;
+      const fromToken = options.capability ? isShortToken(options.capability) : false;
+      const effectiveCapRef = options.capability;
       let resolvedUrl;
       let resolvedMethodFromCapability;
+      let capFromNoUrl;
       if (!url4) {
         if (!options.capability) {
           console.error(
-            "Missing URL. Pass a URL argument or --capability <uid|slug> so the URL can be resolved from the capability."
+            "Missing URL. Pass a URL argument or --capability <uid|slug|token> so the URL can be resolved from the capability."
           );
           process.exitCode = 1;
           return;
         }
         try {
-          const cap = await client.capabilities.get(options.capability);
+          const cap = await client.capabilities.get(effectiveCapRef ?? "");
           resolvedUrl = cap.url;
           resolvedMethodFromCapability = cap.method;
+          capFromNoUrl = cap;
         } catch (err) {
           console.error(
             `Failed to resolve --capability ${options.capability}: ${err instanceof Error ? err.message : String(err)}`
@@ -146755,24 +146752,31 @@ var fetchCommand = (appContext) => new Command("fetch").description(
       }
       const log2 = (msg) => console.error(`  ${msg}`);
       const method = options.method ? options.method.toUpperCase() : resolvedMethodFromCapability ? resolvedMethodFromCapability.toUpperCase() : resolvedBody ? "POST" : "GET";
-      const explicitCapabilityCtx = options.capability ? stateService.findSearchContextByCapability(options.capability) : null;
-      const urlCtx = stateService.findSearchContextByUrl(resolvedUrl, {
-        matchTemplate: (template) => {
-          try {
-            return urlMatchesTemplate(resolvedUrl, template);
-          } catch {
-            return false;
-          }
-        }
-      });
-      const matchCtx = explicitCapabilityCtx ?? urlCtx;
-      const capabilityId = options.capability ?? matchCtx?.capabilityId ?? null;
-      let capabilityUid = matchCtx?.capabilityUid ?? null;
-      let 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;
+      let capabilityId = null;
+      let capabilityUid = null;
+      let capabilitySlug = null;
+      let searchId;
+      let displayCostAmount;
+      let fetchOrigin;
+      if (fromToken) {
+        capabilityUid = capFromNoUrl?.uid ?? null;
+        capabilityId = options.capability ?? "";
+        capabilitySlug = capFromNoUrl?.slug ?? null;
+        displayCostAmount = capFromNoUrl?.displayCostAmount;
+        fetchOrigin = "from_search";
+      } else if (options.capability) {
+        capabilityUid = capFromNoUrl?.uid ?? null;
+        capabilitySlug = capFromNoUrl?.slug ?? null;
+        capabilityId = options.capability;
+        displayCostAmount = capFromNoUrl?.displayCostAmount;
+        fetchOrigin = "direct_slug";
+      } else {
+        const resolved = await client.capabilities.resolveByUrl(resolvedUrl, options.method ?? "GET").catch(() => null);
+        capabilityUid = resolved?.capabilityId ?? null;
+        capabilityId = capabilityUid;
+        fetchOrigin = "direct_url";
+      }
+      const resultRank = void 0;
       const cliSkipReasons = [];
       if (!walletAddress) {
         cliSkipReasons.push(
@@ -146808,16 +146812,17 @@ var fetchCommand = (appContext) => new Command("fetch").description(
           // Adaptive MPP channel prefund: when the seller sends no
           // suggestedDeposit and the caller didn't pass --max-pay,
           // the SDK scales the channel to 10× displayCostAmount so
-          // an expensive single call doesn't under-fund. Threaded
-          // from the search-cache entry.
-          ...matchedDisplayCostAmount && {
-            displayCostAmount: matchedDisplayCostAmount
-          },
+          // an expensive single call doesn't under-fund. Derived from
+          // the capability details when available (token or direct-slug
+          // paths that triggered a capabilities.get).
+          ...displayCostAmount && { displayCostAmount },
           // Only attach the capability when wallet auth is available;
           // recording without a wallet would skip server-side anyway,
           // and omitting here keeps result.runTrackingSkipped clean.
           ...capabilityId && walletAddress && { capabilityId },
-          ...searchId && { searchId },
+          // searchId intentionally omitted: server derives attribution
+          // via SearchAttributor (wallet + capId + 30-min window) so
+          // parallel fetches are race-free without shared client state.
           // Stamp how the agent arrived (from_search | direct_slug |
           // direct_url) onto the run's metadata so direct execution is
           // distinguishable from search-driven runs server-side. Only
@@ -146944,19 +146949,12 @@ var fetchCommand = (appContext) => new Command("fetch").description(
         } else {
           if (walletAddress && !runId) {
             cliSkipReasons.push(
-              "no capability resolved \u2014 pass --capability <uid|slug> or run `zero search` first so the URL can be matched"
+              "no capability resolved \u2014 pass --capability <uid|slug|token> or run `zero search` first so the URL can be matched"
             );
           }
-          const lastSearch = stateService.loadLastSearch();
-          const cached2 = lastSearch?.capabilities ?? [];
           analyticsService.capture("capability_resolution_missed", {
             url: redactUrl(resolvedUrl),
-            method,
-            hasLastSearch: lastSearch !== null,
-            lastSearchSize: cached2.length,
-            lastSearchHasTemplates: cached2.some(
-              (c) => Boolean(c.urlTemplate)
-            )
+            method
           });
         }
       }
@@ -147471,66 +147469,26 @@ var formatCapability = (capability) => {
   lines.push(...buildTryItExample(capability));
   return lines.join("\n");
 };
-var getCommand = (appContext) => new Command("get").description(
-  "Get details for a capability by position from last search, or by slug"
-).argument(
+var getCommand = (appContext) => new Command("get").description("Get details for a capability by token, slug, or uid").argument(
   "<identifier>",
-  "Position number from search results, or a capability slug"
+  "Attribution token (z_xxx.N from search results), capability slug, or uid"
 ).option("--formatted", "Output formatted capability details").option("--json", "Output raw JSON to stdout (default)").option(
   "--agent <name>",
   "Identify your agent host for this invocation. Overrides auto-detect for this call only."
 ).action(async (identifier, options) => {
   try {
-    const { analyticsService, client, stateService } = appContext.services;
-    const position = Number.parseInt(identifier, 10);
-    const isPosition = !Number.isNaN(position) && position >= 1;
-    let capabilityId;
-    let searchId;
-    if (isPosition) {
-      const lastSearch = stateService.loadLastSearch();
-      if (!lastSearch) {
-        console.error("No recent search found. Run `zero search` first.");
-        process.exitCode = 1;
-        return;
-      }
-      const entry = lastSearch.capabilities.find(
-        (c) => c.position === position
-      );
-      if (!entry) {
-        console.error(
-          `No capability at position ${position}. Positions: ${lastSearch.capabilities.map((c) => c.position).join(", ")}`
-        );
-        process.exitCode = 1;
-        return;
-      }
-      capabilityId = entry.id;
-      searchId = lastSearch.searchId;
-    } else {
-      capabilityId = identifier;
-      const ctx = stateService.findSearchContextByCapability(identifier);
-      if (ctx) searchId = ctx.searchId;
-    }
-    const capability = await client.capabilities.get(capabilityId, {
-      searchId
-    });
+    const { analyticsService, client } = appContext.services;
+    const capability = await client.capabilities.get(identifier);
     if (options.formatted && !options.json) {
       console.log(formatCapability(capability));
     } else {
       console.log(JSON.stringify(capability, null, 2));
     }
     analyticsService.capture("capability_viewed", {
-      // Existing field — raw user input (uid, slug, or position
-      // resolved to uid via the last-search cache). Preserved
-      // for back-compat with existing dashboards.
-      capabilityId,
-      // New canonical identifier fields read off the API response,
-      // so they are always populated regardless of how the user
-      // referenced the capability.
+      capabilityRef: identifier,
       capabilityUid: capability.uid,
       capabilitySlug: capability.slug,
-      fromLastSearch: isPosition,
-      ...isPosition ? { position } : {},
-      ...searchId ? { searchId } : {}
+      fromToken: isShortToken(identifier)
     });
   } catch (err) {
     console.error(err instanceof Error ? err.message : "Get failed");
@@ -147591,9 +147549,251 @@ var sectionDivider = () => {
   console.log("");
 };
 
+// src/util/json-config-file.ts
+init_esm_shims();
+var updateJsonConfigFile = (path3, update2, options = {}) => {
+  let config2 = {};
+  if (existsSync(path3)) {
+    try {
+      config2 = JSON.parse(readFileSync(path3, "utf-8"));
+    } catch {
+      return { status: "unparseable", path: path3 };
+    }
+  } else if (!options.createIfMissing) {
+    return { status: "missing", path: path3 };
+  }
+  const changed = update2(config2);
+  if (!changed) return { status: "unchanged", path: path3 };
+  mkdirSync(dirname(path3), { recursive: true });
+  writeFileSync(path3, `${JSON.stringify(config2, null, 2)}
+`);
+  return { status: "updated", path: path3 };
+};
+
 // src/commands/init-command.ts
 var SKILL_DIRS = [".claude/skills", ".agents/skills"];
 var ZERO_SANDBOX_DOMAIN = "*.zero.xyz";
+var CLAUDE_SETTINGS_PATH = ".claude/settings.json";
+var CODEX_HOOKS_PATH = ".codex/hooks.json";
+var PLUGIN_AGENTS = ["codex", "claude", "gemini", "openclaw"];
+var INIT_AGENTS = [...PLUGIN_AGENTS, "standalone"];
+var initAgentSchema = zod_default.enum(INIT_AGENTS);
+var HARNESS_SPECS = {
+  claude: {
+    agent: "claude",
+    displayName: "Claude Code",
+    executable: "claude",
+    installCommands: [
+      {
+        label: "add marketplace",
+        command: "claude",
+        args: ["plugin", "marketplace", "add", "officialzeroxyz/zero-plugins"],
+        required: false
+      },
+      {
+        label: "install plugin",
+        command: "claude",
+        args: ["plugin", "install", "zero@zero-plugins"]
+      }
+    ],
+    manualInstructions: [
+      "Claude Code Desktop: open the Code tab, choose Customize, then add a Personal plugin marketplace from officialzeroxyz/zero-plugins.",
+      "After it syncs, click the + icon on the Zero plugin, then start a new session and ask Claude to help set up and test Zero."
+    ]
+  },
+  codex: {
+    agent: "codex",
+    displayName: "Codex",
+    executable: "codex",
+    installCommands: [
+      {
+        label: "add marketplace",
+        command: "codex",
+        args: ["plugin", "marketplace", "add", "officialzeroxyz/zero-plugins"],
+        required: false
+      },
+      {
+        label: "install plugin",
+        command: "codex",
+        args: ["plugin", "add", "zero@zero-plugins"]
+      }
+    ],
+    manualInstructions: [
+      "Codex app: open Plugins in the sidebar, click +, then add marketplace officialzeroxyz/zero-plugins.",
+      "Select the Zero filter, click Add plugin on Zero, then start a new chat and ask Codex to help set up and test Zero."
+    ]
+  },
+  gemini: {
+    agent: "gemini",
+    displayName: "Gemini CLI",
+    executable: "gemini",
+    installCommands: [
+      {
+        label: "install extension",
+        command: "gemini",
+        args: [
+          "extensions",
+          "install",
+          "https://github.com/officialzeroxyz/zero-plugins",
+          "--auto-update"
+        ]
+      }
+    ],
+    manualInstructions: [
+      "Gemini CLI: run this from a shell where `gemini` is on PATH: gemini extensions install https://github.com/officialzeroxyz/zero-plugins --auto-update"
+    ]
+  },
+  openclaw: {
+    agent: "openclaw",
+    displayName: "OpenClaw",
+    executable: "openclaw",
+    installCommands: [
+      {
+        label: "install plugin",
+        command: "openclaw",
+        args: [
+          "plugins",
+          "install",
+          "zero",
+          "--marketplace",
+          "officialzeroxyz/zero-plugins"
+        ]
+      }
+    ],
+    manualInstructions: [
+      "OpenClaw: run this from a shell where `openclaw` is on PATH: openclaw plugins install zero --marketplace officialzeroxyz/zero-plugins"
+    ]
+  }
+};
+var unique = (items) => [...new Set(items)];
+var parseAgentValues = (values) => {
+  if (!values || values.length === 0) {
+    return {
+      kind: "default",
+      requestedAgents: [...PLUGIN_AGENTS],
+      pluginAgents: [...PLUGIN_AGENTS]
+    };
+  }
+  const parsed = unique(
+    values.flatMap(
+      (value) => value.split(",").map((part) => part.trim().toLowerCase()).filter(Boolean)
+    )
+  );
+  if (parsed.length === 0) {
+    throw new Error("Pass at least one agent name to --agent");
+  }
+  const agents = parsed.map((value) => {
+    const result = initAgentSchema.safeParse(value);
+    if (!result.success) {
+      throw new Error(
+        `Unknown agent "${value}". Expected one of: ${INIT_AGENTS.join(", ")}`
+      );
+    }
+    return result.data;
+  });
+  if (agents.includes("standalone") && agents.length > 1) {
+    throw new Error(
+      "`standalone` cannot be combined with other --agent values; run it separately."
+    );
+  }
+  if (agents[0] === "standalone") {
+    return { kind: "standalone", requestedAgents: agents, pluginAgents: [] };
+  }
+  return {
+    kind: "specific",
+    requestedAgents: agents,
+    pluginAgents: agents
+  };
+};
+var collectAgentOption = (value, previous = []) => [
+  ...previous,
+  value
+];
+var commandSummary = (command, args) => [command, ...args].join(" ");
+var commandOutput = (result) => {
+  const chunks = [result.stderr, result.stdout].map((chunk) => typeof chunk === "string" ? chunk.trim() : "").filter(Boolean);
+  return chunks.join("\n").trim();
+};
+var commandErrorDetail = (result, fallback2) => {
+  if (result.error) return result.error.message;
+  const output = commandOutput(result);
+  if (output.length > 0) return truncateError(output);
+  if (result.signal) return `${fallback2} exited via signal ${result.signal}`;
+  return `${fallback2} exited with status ${result.status ?? "unknown"}`;
+};
+var isCommandCallable = (command) => {
+  if (process.platform === "win32") {
+    const result2 = spawnSync("where.exe", [command], {
+      encoding: "utf8",
+      stdio: "ignore"
+    });
+    return result2.status === 0;
+  }
+  const result = spawnSync("/bin/sh", ["-c", `command -v ${command}`], {
+    encoding: "utf8",
+    stdio: "ignore"
+  });
+  return result.status === 0;
+};
+var installHarnessPlugin = (spec, options) => {
+  if (options.dryRun) {
+    for (const step of spec.installCommands) {
+      stepInfo(`would run: ${commandSummary(step.command, step.args)}`);
+    }
+    return {
+      agent: spec.agent,
+      displayName: spec.displayName,
+      status: "would_install",
+      detail: "dry run"
+    };
+  }
+  let optionalFailure;
+  for (const step of spec.installCommands) {
+    if (options.verbose) {
+      stepInfo(`running: ${commandSummary(step.command, step.args)}`);
+    }
+    const result = spawnSync(step.command, step.args, {
+      encoding: "utf8",
+      stdio: "pipe",
+      env: process.env
+    });
+    if (result.status === 0) continue;
+    const detail = commandErrorDetail(result, step.label);
+    if (step.required === false) {
+      optionalFailure = `${step.label}: ${detail}`;
+      if (options.verbose) stepInfo(`${optionalFailure}; continuing`);
+      continue;
+    }
+    return {
+      agent: spec.agent,
+      displayName: spec.displayName,
+      status: "failed",
+      detail
+    };
+  }
+  return {
+    agent: spec.agent,
+    displayName: spec.displayName,
+    status: "installed",
+    detail: optionalFailure ? `installed; ignored ${optionalFailure}` : void 0
+  };
+};
+var printManualInstructions = (spec) => {
+  for (const line of spec.manualInstructions) {
+    console.log(`      ${color.gray("\xB7")} ${color.dim(line)}`);
+  }
+};
+var fallbackReason = (selection, detectedAgents, results) => {
+  if (selection.kind === "standalone")
+    return "--agent standalone was requested";
+  if (selection.kind === "default" && detectedAgents.length === 0) {
+    return "no supported harness CLIs were callable in this shell";
+  }
+  if (results.every((result) => result.status === "skipped_unavailable")) {
+    return "no requested harness CLIs were callable in this shell";
+  }
+  return "no plugin install succeeded";
+};
 var PLUGIN_HOOKS_ROOT = "${CLAUDE_PLUGIN_ROOT}/hooks";
 var SCRIPT_NAME_PATTERN = /\$\{CLAUDE_PLUGIN_ROOT\}\/hooks\/([a-z0-9][a-z0-9-]*\.sh)/;
 var fetchText = async (url4) => {
@@ -147658,59 +147858,7 @@ var installHookScripts = async (home, hooksJson, webBase, verbose) => {
     })
   );
 };
-var registerHooksInClaudeSettings = (home, hooksJson, verbose) => {
-  const hooksDir = join(home, ".zero", "hooks");
-  const settingsPath = join(home, ".claude", "settings.json");
-  let settings = {};
-  if (existsSync(settingsPath)) {
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    } catch {
-      stepWarn(
-        "Hooks not registered",
-        `${settingsPath} is not valid JSON \u2014 fix it and re-run \`zero init\``
-      );
-      return false;
-    }
-  }
-  if (!settings.hooks || typeof settings.hooks !== "object") {
-    settings.hooks = {};
-  }
-  const hooks = settings.hooks;
-  for (const [event, entries] of Object.entries(hooksJson.hooks)) {
-    for (const entry of entries ?? []) {
-      const scripts = entryScriptNames(entry);
-      if (scripts.length === 0) {
-        if (verbose) {
-          stepInfo(`${event}: entry has no plugin hook script \u2014 skipped`);
-        }
-        continue;
-      }
-      const rewritten = {
-        ...entry,
-        hooks: (entry.hooks ?? []).map((hook) => ({
-          ...hook,
-          command: typeof hook.command === "string" ? hook.command.replaceAll(PLUGIN_HOOKS_ROOT, hooksDir) : hook.command
-        }))
-      };
-      if (!Array.isArray(hooks[event])) hooks[event] = [];
-      const list2 = hooks[event];
-      const existingIdx = list2.findIndex((existing) => {
-        const existingHooks = existing?.hooks;
-        if (!Array.isArray(existingHooks)) return false;
-        return existingHooks.some(
-          (h2) => typeof h2.command === "string" && scripts.some((s) => h2.command.includes(s))
-        );
-      });
-      if (existingIdx >= 0) {
-        list2[existingIdx] = rewritten;
-        if (verbose) stepInfo(`${event}: ${scripts.join(", ")} entry replaced`);
-      } else {
-        list2.push(rewritten);
-        if (verbose) stepInfo(`${event}: ${scripts.join(", ")} entry appended`);
-      }
-    }
-  }
+var ensureZeroSandboxAllowlist = (settings, verbose) => {
   if (!settings.sandbox || typeof settings.sandbox !== "object") {
     settings.sandbox = {};
   }
@@ -147729,86 +147877,326 @@ var registerHooksInClaudeSettings = (home, hooksJson, verbose) => {
       stepInfo(`sandbox.network.allowedDomains += ${ZERO_SANDBOX_DOMAIN}`);
     }
   }
-  mkdirSync(join(home, ".claude"), { recursive: true });
-  writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
-`);
+};
+var registerHooksInJsonFile = (home, hooksJson, target, verbose) => {
+  const hooksDir = join(home, ".zero", "hooks");
+  const configPath = join(home, target.relativePath);
+  const result = updateJsonConfigFile(
+    configPath,
+    (config2) => {
+      if (!config2.hooks || typeof config2.hooks !== "object") {
+        config2.hooks = {};
+      }
+      const hooks = config2.hooks;
+      for (const [event, entries] of Object.entries(hooksJson.hooks)) {
+        for (const entry of entries ?? []) {
+          const scripts = entryScriptNames(entry);
+          if (scripts.length === 0) {
+            if (verbose) {
+              stepInfo(`${event}: entry has no plugin hook script \u2014 skipped`);
+            }
+            continue;
+          }
+          const rewritten = {
+            ...entry,
+            hooks: (entry.hooks ?? []).map((hook) => ({
+              ...hook,
+              command: typeof hook.command === "string" ? hook.command.replaceAll(PLUGIN_HOOKS_ROOT, hooksDir) : hook.command
+            }))
+          };
+          if (!Array.isArray(hooks[event])) hooks[event] = [];
+          const list2 = hooks[event];
+          const existingIdx = list2.findIndex((existing) => {
+            const existingHooks = existing?.hooks;
+            if (!Array.isArray(existingHooks)) return false;
+            return existingHooks.some(
+              (h2) => typeof h2.command === "string" && scripts.some((s) => h2.command.includes(s))
+            );
+          });
+          if (existingIdx >= 0) {
+            list2[existingIdx] = rewritten;
+            if (verbose) {
+              stepInfo(`${event}: ${scripts.join(", ")} entry replaced`);
+            }
+          } else {
+            list2.push(rewritten);
+            if (verbose) {
+              stepInfo(`${event}: ${scripts.join(", ")} entry appended`);
+            }
+          }
+        }
+      }
+      if (target.includeSandboxAllowlist) {
+        ensureZeroSandboxAllowlist(config2, verbose);
+      }
+      return true;
+    },
+    { createIfMissing: true }
+  );
+  if (result.status === "unparseable") {
+    stepWarn(
+      "Hooks not registered",
+      `${configPath} is not valid JSON \u2014 fix it and re-run \`zero init\``
+    );
+    return false;
+  }
   return true;
 };
+var runStandaloneInit = async (appContext, options = {}) => {
+  const verbose = options.verbose ?? false;
+  options.onStep?.("fetch");
+  console.log("");
+  console.log(`  ${color.boldCyan("Installing standalone Zero fallback")}`);
+  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 = homedir();
+  const webBase = appContext.env.ZERO_WEB_URL;
+  const [skillMd, hooksJsonRaw] = await Promise.all([
+    fetchText(`${webBase}/SKILL.md`),
+    fetchText(`${webBase}/hooks.json`)
+  ]);
+  let hooksJson;
+  try {
+    hooksJson = JSON.parse(hooksJsonRaw);
+  } catch {
+    throw new Error(`${webBase}/hooks.json is not valid JSON`);
+  }
+  if (!hooksJson?.hooks || typeof hooksJson.hooks !== "object") {
+    throw new Error(`${webBase}/hooks.json has no "hooks" object`);
+  }
+  if (verbose) {
+    stepInfo(`fetched ${webBase}/SKILL.md and ${webBase}/hooks.json`);
+  }
+  options.onStep?.("skill");
+  const skillsDirs = unique([
+    ...SKILL_DIRS.map((dir) => join(home, dir)),
+    ...(options.skillsDir ?? []).map((dir) => expandHome(dir, home))
+  ]);
+  const skillsInstalled = installSkill(skillsDirs, skillMd, verbose);
+  if (skillsInstalled.length === 0) {
+    throw new Error("could not write the Zero skill to any skills directory");
+  }
+  stepSuccess("Skill installed", `${skillsInstalled.length} locations`);
+  options.onStep?.("hooks");
+  const hookScriptsInstalled = await installHookScripts(
+    home,
+    hooksJson,
+    webBase,
+    verbose
+  );
+  stepSuccess("Hook scripts installed", "~/.zero/hooks");
+  options.onStep?.("settings");
+  const settingsRegistered = registerHooksInJsonFile(
+    home,
+    hooksJson,
+    {
+      relativePath: CLAUDE_SETTINGS_PATH,
+      includeSandboxAllowlist: true
+    },
+    verbose
+  );
+  if (settingsRegistered) {
+    stepSuccess("Hooks registered", "~/.claude/settings.json");
+  }
+  const codexHooksRegistered = registerHooksInJsonFile(
+    home,
+    hooksJson,
+    {
+      relativePath: CODEX_HOOKS_PATH,
+      includeSandboxAllowlist: false
+    },
+    verbose
+  );
+  if (codexHooksRegistered) {
+    stepSuccess("Codex hooks registered", "~/.codex/hooks.json");
+  }
+  return {
+    skillsInstalled,
+    hookScriptsInstalled,
+    settingsRegistered,
+    codexHooksRegistered
+  };
+};
+var statusLabel = (result) => {
+  switch (result.status) {
+    case "installed":
+      return "plugin installed";
+    case "skipped_unavailable":
+      return "skipped unavailable";
+    case "failed":
+      return "failed";
+    case "would_install":
+      return "would install";
+  }
+};
+var printRunnerModelNote = () => {
+  console.log(
+    `  ${color.dim("Agent sessions use the auto-updated managed runner at ~/.zero/runtime/bin/zero.")}`
+  );
+  console.log(
+    `  ${color.dim("The global npm `zero` is the bootstrap and manual CLI; it does not replace the managed runner.")}`
+  );
+};
 var runInit = async (appContext, options = {}) => {
   const verbose = options.verbose ?? false;
+  const dryRun = options.dryRun ?? false;
+  const fallbackAllowed = options.fallback ?? true;
+  const selection = parseAgentValues(options.agent);
+  const requestedAgents = selection.requestedAgents;
+  let currentStep = "plugins";
   appContext.services.analyticsService.capture("init_started", {});
-  let currentStep = "fetch";
   try {
     console.log("");
-    console.log(`  ${color.boldCyan("Installing Zero")}`);
+    console.log(`  ${color.boldCyan("Initializing 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 = homedir();
-    const webBase = appContext.env.ZERO_WEB_URL;
-    const [skillMd, hooksJsonRaw] = await Promise.all([
-      fetchText(`${webBase}/SKILL.md`),
-      fetchText(`${webBase}/hooks.json`)
-    ]);
-    let hooksJson;
-    try {
-      hooksJson = JSON.parse(hooksJsonRaw);
-    } catch {
-      throw new Error(`${webBase}/hooks.json is not valid JSON`);
-    }
-    if (!hooksJson?.hooks || typeof hooksJson.hooks !== "object") {
-      throw new Error(`${webBase}/hooks.json has no "hooks" object`);
-    }
-    if (verbose) {
-      stepInfo(`fetched ${webBase}/SKILL.md and ${webBase}/hooks.json`);
+    console.log(`  Requested agents: ${requestedAgents.join(", ")}`);
+    if (dryRun) stepInfo("dry run: no plugin commands or file writes will run");
+    const detectedAgents = selection.kind === "standalone" ? [] : selection.pluginAgents.filter(
+      (agent) => isCommandCallable(HARNESS_SPECS[agent].executable)
+    );
+    if (selection.kind === "default") {
+      console.log(
+        `  Detected callable harnesses: ${detectedAgents.length > 0 ? detectedAgents.join(", ") : "none"}`
+      );
     }
-    currentStep = "skill";
-    const skillsDirs = [
-      .../* @__PURE__ */ new Set([
-        ...SKILL_DIRS.map((dir) => join(home, dir)),
-        ...(options.skillsDir ?? []).map((dir) => expandHome(dir, home))
-      ])
-    ];
-    const skillsInstalled = installSkill(skillsDirs, skillMd, verbose);
-    if (skillsInstalled.length === 0) {
-      throw new Error("could not write the Zero skill to any skills directory");
+    console.log("");
+    const pluginResults = [];
+    if (selection.kind !== "standalone") {
+      for (const agent of selection.pluginAgents) {
+        const spec = HARNESS_SPECS[agent];
+        if (!detectedAgents.includes(agent)) {
+          const result2 = {
+            agent,
+            displayName: spec.displayName,
+            status: "skipped_unavailable",
+            detail: `\`${spec.executable}\` is not callable in this shell`
+          };
+          pluginResults.push(result2);
+          stepSkip(
+            `${spec.displayName}: ${statusLabel(result2)}`,
+            result2.detail
+          );
+          if (selection.kind === "specific") {
+            printManualInstructions(spec);
+          }
+          continue;
+        }
+        const result = installHarnessPlugin(spec, { dryRun, verbose });
+        pluginResults.push(result);
+        if (result.status === "installed") {
+          stepSuccess(
+            `${spec.displayName}: ${statusLabel(result)}`,
+            result.detail
+          );
+        } else if (result.status === "would_install") {
+          stepSkip(
+            `${spec.displayName}: ${statusLabel(result)}`,
+            result.detail
+          );
+        } else {
+          stepWarn(
+            `${spec.displayName}: ${statusLabel(result)}`,
+            result.detail
+          );
+        }
+      }
     }
-    stepSuccess("Skill installed", `${skillsInstalled.length} locations`);
-    currentStep = "hooks";
-    const hookScriptsInstalled = await installHookScripts(
-      home,
-      hooksJson,
-      webBase,
-      verbose
-    );
-    stepSuccess("Hook scripts installed", "~/.zero/hooks");
-    currentStep = "settings";
-    const settingsRegistered = registerHooksInClaudeSettings(
-      home,
-      hooksJson,
-      verbose
+    const pluginSucceeded = pluginResults.some(
+      (result) => result.status === "installed" || result.status === "would_install"
     );
-    if (settingsRegistered) {
-      stepSuccess("Hooks registered", "~/.claude/settings.json");
+    let standaloneFallbackReason;
+    let standaloneFallbackUsed = false;
+    let standaloneResult = {
+      skillsInstalled: [],
+      hookScriptsInstalled: [],
+      settingsRegistered: false,
+      codexHooksRegistered: false
+    };
+    if (selection.kind === "standalone" || !pluginSucceeded) {
+      standaloneFallbackReason = fallbackReason(
+        selection,
+        detectedAgents,
+        pluginResults
+      );
+      if (!fallbackAllowed && selection.kind !== "standalone") {
+        throw new Error(
+          `No Zero plugin install succeeded and --no-fallback was set (${standaloneFallbackReason}).`
+        );
+      }
+      standaloneFallbackUsed = !dryRun;
+      sectionDivider();
+      const fallbackVerb = dryRun ? "would be used" : "used";
+      console.log(
+        `  Standalone fallback ${fallbackVerb}: ${standaloneFallbackReason}.`
+      );
+      if (dryRun) {
+        stepInfo("would install/update ~/.claude/skills/zero");
+        stepInfo("would install/update ~/.agents/skills/zero");
+        stepInfo(
+          "would register current standalone hooks in ~/.claude/settings.json and ~/.codex/hooks.json"
+        );
+      } else {
+        standaloneResult = await runStandaloneInit(appContext, {
+          verbose,
+          skillsDir: options.skillsDir,
+          onStep: (step) => {
+            currentStep = step;
+          }
+        });
+      }
+    } else {
+      sectionDivider();
+      console.log(
+        "  Standalone fallback not used: at least one harness plugin install succeeded."
+      );
     }
     currentStep = "complete";
     appContext.services.analyticsService.capture("init_completed", {
       // biome-ignore lint/style/useNamingConvention: snake_case for analytics
-      skills_installed: skillsInstalled,
+      requested_agents: requestedAgents,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      detected_harnesses: detectedAgents,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      plugin_installs: pluginResults.map((result) => ({
+        agent: result.agent,
+        status: result.status
+      })),
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      standalone_fallback_used: standaloneFallbackUsed,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      standalone_fallback_reason: standaloneFallbackReason,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      dry_run: dryRun,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      skills_installed: standaloneResult.skillsInstalled,
+      // biome-ignore lint/style/useNamingConvention: snake_case for analytics
+      skills_installed_count: standaloneResult.skillsInstalled.length,
       // biome-ignore lint/style/useNamingConvention: snake_case for analytics
-      skills_installed_count: skillsInstalled.length,
+      hook_scripts_installed: standaloneResult.hookScriptsInstalled,
       // biome-ignore lint/style/useNamingConvention: snake_case for analytics
-      hook_scripts_installed: hookScriptsInstalled,
+      settings_registered: standaloneResult.settingsRegistered,
       // biome-ignore lint/style/useNamingConvention: snake_case for analytics
-      settings_registered: settingsRegistered
+      codex_hooks_registered: standaloneResult.codexHooksRegistered
     });
     sectionDivider();
-    console.log(`  ${color.boldGreen("Zero is set up.")}`);
+    console.log(`  ${color.boldGreen("Zero init complete.")}`);
     console.log(
       `  ${color.dim("Next: sign in with `zero auth login` \u2014 it prints a URL to approve in your browser.")}`
     );
+    printRunnerModelNote();
     console.log("");
-    return { skillsInstalled, hookScriptsInstalled, settingsRegistered };
+    return {
+      ...standaloneResult,
+      requestedAgents,
+      detectedAgents,
+      pluginResults,
+      standaloneFallbackUsed,
+      standaloneFallbackReason,
+      dryRun
+    };
   } catch (err) {
     appContext.services.analyticsService.capture("init_failed", {
       step: currentStep,
@@ -147818,7 +148206,18 @@ var runInit = async (appContext, options = {}) => {
   }
 };
 var initCommand = (appContext) => new Command("init").description(
-  "Install the Zero skill and hooks for the agent harnesses on this machine"
+  "Install the Zero plugin for supported agents, with a standalone skill/hook fallback"
+).option(
+  "--agent <agent>",
+  "Agent target: codex, claude, gemini, openclaw, or standalone. Repeat or comma-separate values. Omit to target every supported agent.",
+  collectAgentOption,
+  []
+).option(
+  "--no-fallback",
+  "Do not install standalone skills/hooks if plugin install does not succeed"
+).option(
+  "--dry-run",
+  "Show what would be installed without running commands or writing files"
 ).option(
   "-v, --verbose",
   "Explain why each install step was taken or skipped"
@@ -148166,11 +148565,12 @@ var formatDetail = (r2) => {
   }
   return lines.join("\n");
 };
-var runsDetailCommand = (appContext) => new Command("detail").description("Show full metadata for a single run").argument("<runId>", "Run ID (run_\u2026)").option("--json", "Output raw JSON to stdout").action(async (runId, options) => {
+var runsDetailCommand = (appContext) => new Command("detail").description("Show full metadata for a single run (from server)").argument("<runId>", "Run ID (run_\u2026)").option("--json", "Output raw JSON to stdout").action(async (runId, _opts, cmd) => {
+  const { json: json3 } = cmd.opts();
   try {
     const { client } = appContext.services;
     const run = await client.runs.get(runId);
-    if (options.json) {
+    if (json3) {
       console.log(JSON.stringify(run, null, 2));
       return;
     }
@@ -148180,9 +148580,10 @@ var runsDetailCommand = (appContext) => new Command("detail").description("Show
     process.exitCode = 1;
   }
 });
-var runsCommand = (appContext) => new Command("runs").description("List your recent capability runs").addHelpText(
-  "after",
-  `
+var runsCommand = (appContext) => {
+  const cmd = new Command("runs").description("List your recent capability runs").addHelpText(
+    "after",
+    `
 View your recent capability runs \u2014 status, latency, cost, and payment info.
 A leading [\u2713] means the run already has a review; [ ] means it does not.
 
@@ -148191,52 +148592,55 @@ Examples:
   zero runs --unreviewed               # filter to runs without a review
   zero runs --capability translate-en  # filter to one capability (uid or slug)
   zero runs --json                     # full structured output for scripts
-  zero runs detail <runId>             # full metadata for a single run`
-).addCommand(runsDetailCommand(appContext)).option("--capability <id>", "Filter by capability uid or slug").option("--unreviewed", "Only show runs without a review").option(
-  "--limit <n>",
-  "Max rows (1-100, default 25)",
-  (v) => Number.parseInt(v, 10)
-).option("--json", "Output raw JSON to stdout").option(
-  "--agent <name>",
-  "Identify your agent host for this invocation. Overrides auto-detect for this call only."
-).action(
-  async (options) => {
-    try {
-      const { client } = appContext.services;
-      const result = await client.runs.list({
-        capabilityId: options.capability,
-        unreviewed: options.unreviewed,
-        limit: options.limit
-      });
-      if (options.json) {
-        console.log(JSON.stringify(result, null, 2));
-        return;
-      }
-      if (result.runs.length === 0) {
-        console.log("No runs found.");
-        return;
-      }
-      for (const r2 of result.runs) {
-        const when = r2.createdAt.toISOString().replace("T", " ").slice(0, 19);
-        const mark = r2.reviewed ? "\u2713" : " ";
-        const status = r2.status ?? "\u2014";
-        const latency = r2.latencyMs != null ? `${r2.latencyMs}ms` : "\u2014";
-        const cost = formatCost2(r2.cost);
-        const payment = formatPayment(r2.payment);
-        console.log(
-          `[${mark}] ${r2.uid}  ${r2.capabilitySlug}  status=${status}  ${latency}  ${cost}  ${payment}  ${when}`
-        );
-      }
-      if (result.nextCursor) {
-        console.log(`
+  zero runs detail <runId>             # full server-side metadata for a run`
+  ).option("--capability <id>", "Filter by capability uid or slug").option("--unreviewed", "Only show runs without a review").option(
+    "--limit <n>",
+    "Max rows (1-100, default 25)",
+    (v) => Number.parseInt(v, 10)
+  ).option("--json", "Output raw JSON to stdout").option(
+    "--agent <name>",
+    "Identify your agent host for this invocation. Overrides auto-detect for this call only."
+  ).action(
+    async (options) => {
+      try {
+        const { client } = appContext.services;
+        const result = await client.runs.list({
+          capabilityId: options.capability,
+          unreviewed: options.unreviewed,
+          limit: options.limit
+        });
+        if (options.json) {
+          console.log(JSON.stringify(result, null, 2));
+          return;
+        }
+        if (result.runs.length === 0) {
+          console.log("No runs found.");
+          return;
+        }
+        for (const r2 of result.runs) {
+          const when = r2.createdAt.toISOString().replace("T", " ").slice(0, 19);
+          const mark = r2.reviewed ? "\u2713" : " ";
+          const status = r2.status ?? "\u2014";
+          const latency = r2.latencyMs != null ? `${r2.latencyMs}ms` : "\u2014";
+          const cost = formatCost2(r2.cost);
+          const payment = formatPayment(r2.payment);
+          console.log(
+            `[${mark}] ${r2.uid}  ${r2.capabilitySlug}  status=${status}  ${latency}  ${cost}  ${payment}  ${when}`
+          );
+        }
+        if (result.nextCursor) {
+          console.log(`
 (more available \u2014 use --limit to see more)`);
+        }
+      } catch (err) {
+        console.error(err instanceof Error ? err.message : "Failed");
+        process.exitCode = 1;
       }
-    } catch (err) {
-      console.error(err instanceof Error ? err.message : "Failed");
-      process.exitCode = 1;
     }
-  }
-);
+  );
+  cmd.addCommand(runsDetailCommand(appContext));
+  return cmd;
+};
 
 // src/commands/search-command.ts
 init_esm_shims();
@@ -148297,7 +148701,7 @@ var searchCommand = (appContext) => new Command("search").description("Search fo
 ).action(
   async (query, options) => {
     try {
-      const { analyticsService, client, stateService } = appContext.services;
+      const { analyticsService, client } = appContext.services;
       if (options.protocol && !["x402", "mpp"].includes(options.protocol)) {
         console.error(
           `Invalid protocol "${options.protocol}". Must be x402 or mpp.`
@@ -148366,17 +148770,6 @@ var searchCommand = (appContext) => new Command("search").description("Search fo
         );
         return;
       }
-      stateService.saveLastSearch({
-        searchId: result.searchId,
-        capabilities: result.capabilities.map((c) => ({
-          position: c.position,
-          id: c.id,
-          slug: c.slug,
-          url: c.url,
-          urlTemplate: c.urlTemplate ?? null,
-          displayCostAmount: c.cost.amount
-        }))
-      });
       console.log(formatSearchResults(result.capabilities));
       if (result.hasMore) {
         console.error(
@@ -148386,7 +148779,7 @@ var searchCommand = (appContext) => new Command("search").description("Search fo
       }
       if (result.capabilities.length > 0) {
         console.error(
-          "\n  Run `zero get {NUMBER}` to view a capability.\n"
+          "\n  Run `zero get <token>` (or `zero get <slug>`) to view a capability.\n"
         );
       }
     } catch (err) {
@@ -148434,6 +148827,8 @@ var HOOK_FILES = [
   "ensure-runner.sh"
 ];
 var ZERO_SANDBOX_DOMAIN2 = "*.zero.xyz";
+var CLAUDE_SETTINGS_PATH2 = ".claude/settings.json";
+var CODEX_HOOKS_PATH2 = ".codex/hooks.json";
 var LEGACY_SKILL_NAMES = ["zero"];
 var removeSkills = (home, verbose = false) => {
   const skillNames = LEGACY_SKILL_NAMES;
@@ -148459,30 +148854,17 @@ var removeSkills = (home, verbose = false) => {
   return removed;
 };
 var removeHooks = (home, verbose = false) => {
-  let settingsChanged = false;
-  const settingsPath = join(home, ".claude", "settings.json");
-  if (!existsSync(settingsPath)) {
-    if (verbose) stepInfo(`${settingsPath} not found \u2014 no settings to clean`);
-  } else {
-    let settings = null;
-    try {
-      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
-    } catch {
-      if (verbose) {
-        stepInfo(`${settingsPath} was unparseable JSON \u2014 leaving it untouched`);
-      }
-    }
-    if (settings) {
-      settingsChanged = stripZeroFromSettings(settings, verbose);
-      if (settingsChanged) {
-        writeFileSync(settingsPath, `${JSON.stringify(settings, null, 2)}
-`);
-        if (verbose) stepInfo(`rewrote ${settingsPath} without Zero entries`);
-      } else if (verbose) {
-        stepInfo(`no Zero entries found in ${settingsPath}`);
-      }
-    }
-  }
+  const claudeSettingsChanged = stripZeroFromJsonFile(
+    join(home, CLAUDE_SETTINGS_PATH2),
+    verbose,
+    true
+  );
+  const codexHooksChanged = stripZeroFromJsonFile(
+    join(home, CODEX_HOOKS_PATH2),
+    verbose,
+    false
+  );
+  const settingsChanged = claudeSettingsChanged || codexHooksChanged;
   let scriptsRemoved = 0;
   const zeroHooksDir = join(home, ".zero", "hooks");
   if (existsSync(zeroHooksDir)) {
@@ -148502,7 +148884,29 @@ var removeHooks = (home, verbose = false) => {
   }
   return { settingsChanged, scriptsRemoved };
 };
-var stripZeroFromSettings = (settings, verbose) => {
+var stripZeroFromJsonFile = (settingsPath, verbose, removeSandboxAllowlist) => {
+  const result = updateJsonConfigFile(
+    settingsPath,
+    (settings) => stripZeroFromSettings(settings, verbose, removeSandboxAllowlist)
+  );
+  if (result.status === "missing") {
+    if (verbose) stepInfo(`${settingsPath} not found \u2014 no settings to clean`);
+    return false;
+  }
+  if (result.status === "unparseable") {
+    if (verbose) {
+      stepInfo(`${settingsPath} was unparseable JSON \u2014 leaving it untouched`);
+    }
+    return false;
+  }
+  if (result.status === "updated") {
+    if (verbose) stepInfo(`rewrote ${settingsPath} without Zero entries`);
+    return true;
+  }
+  if (verbose) stepInfo(`no Zero entries found in ${settingsPath}`);
+  return false;
+};
+var stripZeroFromSettings = (settings, verbose, removeSandboxAllowlist) => {
   let changed = false;
   const hooks = settings.hooks && typeof settings.hooks === "object" ? settings.hooks : null;
   if (hooks) {
@@ -148515,24 +148919,26 @@ var stripZeroFromSettings = (settings, verbose) => {
     }
     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((d3) => d3 !== ZERO_SANDBOX_DOMAIN2);
-    if (next.length !== domains.length) {
-      changed = true;
-      if (verbose) {
-        stepInfo(`sandbox.network.allowedDomains -= ${ZERO_SANDBOX_DOMAIN2}`);
-      }
-      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;
+  if (removeSandboxAllowlist) {
+    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((d3) => d3 !== ZERO_SANDBOX_DOMAIN2);
+      if (next.length !== domains.length) {
+        changed = true;
+        if (verbose) {
+          stepInfo(`sandbox.network.allowedDomains -= ${ZERO_SANDBOX_DOMAIN2}`);
+        }
+        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;
+        }
       }
     }
   }
@@ -153656,105 +154062,6 @@ var AnalyticsService = class {
   }
 };
 
-// src/services/state-service.ts
-init_esm_shims();
-var RECENT_SEARCH_LIMIT = 10;
-var StateService = class {
-  constructor(zeroDir) {
-    this.zeroDir = zeroDir;
-    this.lastSearchPath = join(zeroDir, "last_search.json");
-    this.recentSearchesPath = join(zeroDir, "recent_searches.json");
-  }
-  lastSearchPath;
-  recentSearchesPath;
-  saveLastSearch = (data) => {
-    mkdirSync(this.zeroDir, { recursive: true });
-    writeFileSync(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);
-    writeFileSync(
-      this.recentSearchesPath,
-      JSON.stringify({ searches: next }, null, 2)
-    );
-  };
-  loadLastSearch = () => {
-    try {
-      if (!existsSync(this.lastSearchPath)) return null;
-      const raw = readFileSync(this.lastSearchPath, "utf8");
-      return JSON.parse(raw);
-    } catch {
-      return null;
-    }
-  };
-  loadRecentSearches = () => {
-    try {
-      if (!existsSync(this.recentSearchesPath)) {
-        const last = this.loadLastSearch();
-        return { searches: last ? [last] : [] };
-      }
-      const raw = readFileSync(this.recentSearchesPath, "utf8");
-      const parsed = JSON.parse(raw);
-      return { searches: parsed.searches ?? [] };
-    } catch {
-      return { searches: [] };
-    }
-  };
-  // Walk recent searches newest-first, returning the first one whose
-  // results contain `capabilityRef` (matches against uid OR slug).
-  // Preferred over "loadLastSearch" for attributing rank — handles the
-  // parallel-search case where the most recent search isn't the one being
-  // fetched.
-  findSearchContextByCapability = (capabilityRef) => {
-    const recent = this.loadRecentSearches();
-    for (const search of recent.searches) {
-      const entry = search.capabilities.find(
-        (c) => c.id === capabilityRef || c.slug === capabilityRef
-      );
-      if (entry) {
-        return {
-          searchId: search.searchId,
-          resultRank: entry.position,
-          capabilityId: entry.id,
-          capabilityUid: entry.id,
-          capabilitySlug: entry.slug ?? null,
-          url: entry.url,
-          displayCostAmount: entry.displayCostAmount
-        };
-      }
-    }
-    return null;
-  };
-  // URL-based attribution for `zero fetch <url>`. Matches by URL prefix
-  // (some capabilities accept query params or path tails the agent appends)
-  // across the recent ring, newest match wins. Falls back to a caller-
-  // supplied urlTemplate matcher (ADS-509 path-parameterized URLs).
-  findSearchContextByUrl = (url4, options) => {
-    const recent = this.loadRecentSearches();
-    for (const search of recent.searches) {
-      const prefixHit = search.capabilities.find((c) => url4.startsWith(c.url));
-      const templateHit = prefixHit ?? search.capabilities.find(
-        (c) => c.urlTemplate && options?.matchTemplate ? options.matchTemplate(c.urlTemplate) : false
-      );
-      const entry = templateHit;
-      if (entry) {
-        return {
-          searchId: search.searchId,
-          resultRank: entry.position,
-          capabilityId: entry.id,
-          capabilityUid: entry.id,
-          capabilitySlug: entry.slug ?? null,
-          url: entry.url,
-          displayCostAmount: entry.displayCostAmount
-        };
-      }
-    }
-    return null;
-  };
-};
-
 // src/services/wallet-migration-service.ts
 init_esm_shims();
 var USDC_BASE3 = "0x833589fcd6edb6e08f4c7c32d4f71b54bda02913";
@@ -154038,7 +154345,6 @@ var getServices = async (env) => {
   const walletMigrationService = new WalletMigrationService(
     byoAccount ?? legacyAccount
   );
-  const stateService = new StateService(zeroDir);
   const analyticsService = new AnalyticsService({
     walletAddress: account?.address ?? null,
     configPath,
@@ -154051,7 +154357,6 @@ var getServices = async (env) => {
     analyticsService,
     client,
     walletMigrationService,
-    stateService,
     lowBalanceWarning,
     // Canonical resolved wallet address across the CLI — covers BYO,
     // managed (Privy embedded) and legacy paths via the precedence above.