viveworker 0.8.5 → 0.8.7

package/scripts/viveworker-bridge.mjs

@@ -37,6 +37,7 @@ const {
   bootstrapPasskeyAccount,
   completePasskeyAssertion,
   completePasskeyRegistration,
+  listPasskeyDevices,
   listSupportedChains,
   requestEmailOtp: requestHazbaseEmailOtp,
   requestPasskeyAssertionChallenge,
@@ -65,12 +66,21 @@ const REMOTE_PAIRING_RELAY_TOKEN_ROTATION_MS = 30 * 24 * 60 * 60 * 1000;
 const DEFAULT_COMPLETION_REPLY_IMAGE_MAX_BYTES = 15 * 1024 * 1024;
 const DEFAULT_COMPLETION_REPLY_UPLOAD_TTL_MS = 24 * 60 * 60 * 1000;
 const DEFAULT_COMPLETION_REPLY_ACK_TIMEOUT_MS = 1200;
+const DEFAULT_COMPLETION_REPLY_THREAD_REOPEN_WAIT_MS = 1800;
 const MAX_COMPLETION_REPLY_IMAGE_COUNT = 4;
 const COMPLETION_PUSH_CONTENT_DEDUPE_WINDOW_MS = 2 * 60 * 1000;
 const HAZBASE_METADATA_TIMEOUT_MS = 1500;
 const NPM_VERSION_CHECK_TIMEOUT_MS = 2500;
 const NPM_VERSION_CHECK_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 const TIMELINE_ACTIVITY_TTL_MS = 2 * 60 * 1000;
+const PAYMENT_NETWORKS = {
+  base: { family: "evm", chainId: 8453, asset: "usdc", assets: ["usdc"], scheme: "exact", label: "Base", releaseStatus: "comingSoon" },
+  "base-sepolia": { family: "evm", chainId: 84532, asset: "usdc", assets: ["usdc"], scheme: "exact", label: "Base Sepolia" },
+  polygon: { family: "evm", chainId: 137, asset: "usdc", assets: ["usdc", "jpyc"], scheme: "exact", label: "Polygon", releaseStatus: "comingSoon" },
+  "polygon-amoy": { family: "evm", chainId: 80002, asset: "usdc", assets: ["usdc", "jpyc"], scheme: "exact", label: "Polygon Amoy" },
+  liquidtestnet: { family: "liquid", chainId: null, asset: "usdt", assets: ["usdt", "lbtc"], scheme: "exact-liquid-pset", label: "Liquid Testnet" },
+  liquidv1: { family: "liquid", chainId: null, asset: "usdt", assets: ["usdt", "lbtc"], scheme: "exact-liquid-pset", label: "Liquid", releaseStatus: "comingSoon" },
+};
 
 // Shared memo for buildDiffThreadGroups. Each call spawns 3 git subprocesses
 // per tracked repo (`git diff --name-status`, `git status --porcelain`,
@@ -806,7 +816,7 @@ function localizedMcpApprovalPushContent(locale, approval) {
 
 function localizedPaymentApprovalPushContent(locale, approval) {
   const payment = isPlainObject(approval?.rawParams) ? approval.rawParams : {};
-  const amount = cleanText(payment.amountUsdc || payment.amountAtomic || "");
+  const amount = cleanText(`${payment.amountUsdc || payment.amountAtomic || ""} ${payment.assetLabel || ""}`.trim());
   const network = cleanText(payment.network || "");
   const resource = cleanText(payment.resource || payment.url || "");
   const titleKey = cleanText(approval?.kind || "") === "hazbase_wallet_payment"
@@ -1540,11 +1550,19 @@ function normalizeTrustedReadTokens(tokens) {
   }
   if (strippedTokens.some((token) => {
     const value = String(token || "");
-    return (
-      ["||", "&&", ";", "&"].includes(value) ||
-      value.includes("`") ||
-      value.includes("$(")
-    );
+    if (value === "|") {
+      // A standalone pipe is the only operator allowed here; the pipe-stage
+      // split below validates that each downstream stage is an allow-listed
+      // post-processor (head/tail/wc).
+      return false;
+    }
+    // Reject any token that *contains* a command separator or command
+    // substitution, not just tokens that equal one. The whitespace tokenizer
+    // keeps separators attached to adjacent text (e.g. "README.md;id" or
+    // "README.md|sh"), so a whole-token equality check let the shell run an
+    // injected second command the classifier never saw. A substring check on
+    // ; & | and backtick (plus "$(") closes that gap.
+    return /[;&|`]/u.test(value) || value.includes("$(");
   })) {
     return null;
   }
@@ -1578,6 +1596,14 @@ function evaluateTrustedReadCommandPolicy({ commandText, cwd, workspaceRoot }) {
   const normalizedCwd = cleanText(cwd || "");
   const normalizedWorkspaceRoot = cleanText(workspaceRoot || normalizedCwd);
   const normalizedCommandText = unwrapShellCommand(commandText);
+  // A literal newline or carriage return is a shell command separator, but
+  // tokenizeShellWords() treats it as ordinary whitespace — so an injected
+  // second command (e.g. "rg foo\ntouch evil") would be split into harmless
+  // looking word tokens and misclassified as a single safe read. Refuse to
+  // auto-classify anything carrying these so it falls back to manual approval.
+  if (/[\n\r]/u.test(normalizedCommandText)) {
+    return null;
+  }
   const rawTokens = tokenizeShellWords(normalizedCommandText);
   if (!normalizedCommandText || !normalizedCwd || !normalizedWorkspaceRoot || rawTokens.length === 0) {
     return null;
@@ -7962,7 +7988,7 @@ function createX402PaymentApproval({ config, body, now = Date.now() }) {
   const requestId = cleanText(body.paymentRequestId || body.requestId || crypto.randomUUID());
   const requestKey = `payment:${requestId}`;
   const title = payment.amountUsdc
-    ? `Payment approval — ${payment.amountUsdc} USDC`
+    ? `Payment approval — ${payment.amountUsdc} ${payment.assetLabel || "USDC"}`
     : "Payment approval";
   return {
     token,
@@ -8001,7 +8027,7 @@ function createHazbaseWalletPaymentApproval({ config, body, now = Date.now() })
   const token = crypto.randomBytes(18).toString("hex");
   const requestKey = `hazbase_wallet_payment:${paymentRequestId}`;
   const title = payment.amountUsdc
-    ? `Hazbase wallet payment — ${payment.amountUsdc} USDC`
+    ? `Hazbase wallet payment — ${payment.amountUsdc} ${payment.assetLabel || "USDC"}`
     : "Hazbase wallet payment";
   return {
     token,
@@ -8036,7 +8062,7 @@ function formatHazbaseWalletPaymentApprovalMessage(payment) {
   const lines = [
     "Hazbase Smart Wallet payment requested.",
     "",
-    `Amount: ${payment.amountUsdc || payment.amountAtomic} USDC`,
+    `Amount: ${payment.amountUsdc || payment.amountAtomic} ${payment.assetLabel || "USDC"}`,
     `Network: ${payment.network} (chainId ${payment.chainId})`,
     `Pay to: ${payment.payTo}`,
     `Asset: ${payment.asset}`,
@@ -8053,15 +8079,16 @@ function normalizeX402PaymentApprovalBody(body) {
   if (!isPlainObject(body)) return null;
   const payment = isPlainObject(body.payment) ? body.payment : {};
   const network = cleanText(payment.network || "");
-  const chainId = Number(payment.chainId) || 0;
+  const chainId = payment.chainId === null ? null : Number(payment.chainId) || 0;
   const amountAtomic = cleanText(payment.amountAtomic || "");
-  const amountUsdc = cleanText(payment.amountUsdc || "");
+  const amountUsdc = cleanText(payment.amountUsdc || payment.amount || "");
+  const assetLabel = cleanText(payment.assetLabel || "");
   const payTo = cleanText(payment.payTo || "");
   const asset = cleanText(payment.asset || "");
   const resource = cleanText(payment.resource || body.url || "");
   const description = cleanText(payment.description || "");
   const url = cleanText(body.url || resource);
-  if (!network || !chainId || !amountAtomic || !payTo || !asset || !resource) {
+  if (!network || (chainId !== null && !chainId) || !amountAtomic || !payTo || !asset || !resource) {
     return null;
   }
   return {
@@ -8070,6 +8097,7 @@ function normalizeX402PaymentApprovalBody(body) {
     chainId,
     amountAtomic,
     amountUsdc,
+    assetLabel,
     payTo,
     asset,
     resource,
@@ -8081,8 +8109,8 @@ function formatX402PaymentApprovalMessage(payment) {
   const lines = [
     "x402 payment approval requested.",
     "",
-    `Amount: ${payment.amountUsdc || payment.amountAtomic} USDC`,
-    `Network: ${payment.network} (chainId ${payment.chainId})`,
+    `Amount: ${payment.amountUsdc || payment.amountAtomic} ${payment.assetLabel || "USDC"}`,
+    `Network: ${payment.network}${payment.chainId === null ? "" : ` (chainId ${payment.chainId})`}`,
     `Pay to: ${payment.payTo}`,
     `Asset: ${payment.asset}`,
     `Resource: ${payment.resource}`,
@@ -9640,6 +9668,50 @@ function isIpcNoClientFoundError(errorValue) {
     message.includes("client not found");
 }
 
+function codexThreadDeepLink(conversationId) {
+  const id = cleanText(conversationId || "");
+  if (!id || !/^[0-9a-z-]{16,}$/iu.test(id)) {
+    return "";
+  }
+  return `codex://local/${encodeURIComponent(id)}`;
+}
+
+function openCodexThreadBestEffort(conversationId) {
+  if (process.platform !== "darwin") {
+    return false;
+  }
+  const url = codexThreadDeepLink(conversationId);
+  if (!url) {
+    return false;
+  }
+  try {
+    const child = spawn("open", [url], {
+      detached: true,
+      stdio: "ignore",
+    });
+    child.unref?.();
+    console.log(`[completion-reply] reopened Codex thread via ${url}`);
+    return true;
+  } catch (error) {
+    console.warn(
+      `[completion-reply] failed to reopen Codex thread=${cleanText(conversationId || "") || "unknown"} ` +
+      `error=${cleanText(error?.message || error || "") || "unknown"}`
+    );
+    return false;
+  }
+}
+
+async function waitForCodexThreadOwner(runtime, conversationId, timeoutMs) {
+  const deadline = Date.now() + Math.max(0, Number(timeoutMs) || 0);
+  while (Date.now() <= deadline) {
+    if (runtime.threadOwnerClientIds.has(conversationId)) {
+      return true;
+    }
+    await sleep(100);
+  }
+  return false;
+}
+
 function buildDefaultCollaborationMode(threadState) {
   // Fallback turns must leave Plan mode unless the caller explicitly opts in.
   return buildRequestedCollaborationMode(threadState, "default");
@@ -10431,6 +10503,45 @@ function isHiddenCodexApprovalAssessmentText(text) {
   return /\bThe following is the Codex agent history(?: added since your last approval assessment)?\b/iu.test(single);
 }
 
+function isHiddenCodexApprovalDecisionJsonText(text) {
+  const single = cleanText(stripNotificationMarkup(stripEnvironmentContextBlocks(text || "")));
+  if (!single || !single.startsWith("{") || !single.endsWith("}")) {
+    return false;
+  }
+
+  const parsed = safeJsonParse(single);
+  if (!isPlainObject(parsed)) {
+    return false;
+  }
+
+  const allowedKeys = new Set(["risk_level", "user_authorization", "outcome", "rationale"]);
+  const keys = Object.keys(parsed);
+  if (!keys.includes("outcome") || keys.some((key) => !allowedKeys.has(key))) {
+    return false;
+  }
+
+  const outcome = cleanText(parsed.outcome || "");
+  if (outcome !== "allow" && outcome !== "deny") {
+    return false;
+  }
+
+  const riskLevel = cleanText(parsed.risk_level || "");
+  if (riskLevel && !["low", "medium", "high", "critical"].includes(riskLevel)) {
+    return false;
+  }
+
+  const userAuthorization = cleanText(parsed.user_authorization || "");
+  if (userAuthorization && !["unknown", "low", "medium", "high"].includes(userAuthorization)) {
+    return false;
+  }
+
+  if (parsed.rationale != null && typeof parsed.rationale !== "string") {
+    return false;
+  }
+
+  return keys.length === 1 || keys.some((key) => key === "risk_level" || key === "user_authorization" || key === "rationale");
+}
+
 function shouldHideInternalTimelineItem(item) {
   return shouldHideClaudeInternalItem(item) || shouldHideCodexInternalApprovalItem(item) || shouldHideMoltbookHarnessItem(item);
 }
@@ -10508,14 +10619,23 @@ function shouldHideCodexInternalApprovalItem(item) {
 
   const title = cleanText(item.title ?? "");
   const threadLabel = cleanText(item.threadLabel ?? "");
-  if (isHiddenCodexApprovalAssessmentText(title) || isHiddenCodexApprovalAssessmentText(threadLabel)) {
+  if (
+    isHiddenCodexApprovalAssessmentText(title) ||
+    isHiddenCodexApprovalAssessmentText(threadLabel) ||
+    isHiddenCodexApprovalDecisionJsonText(title) ||
+    isHiddenCodexApprovalDecisionJsonText(threadLabel)
+  ) {
     return true;
   }
   return (
     isHiddenCodexApprovalAssessmentText(item.messageText) ||
     isHiddenCodexApprovalAssessmentText(item.summary) ||
     isHiddenCodexApprovalAssessmentText(item.detailText) ||
-    isHiddenCodexApprovalAssessmentText(item.message)
+    isHiddenCodexApprovalAssessmentText(item.message) ||
+    isHiddenCodexApprovalDecisionJsonText(item.messageText) ||
+    isHiddenCodexApprovalDecisionJsonText(item.summary) ||
+    isHiddenCodexApprovalDecisionJsonText(item.detailText) ||
+    isHiddenCodexApprovalDecisionJsonText(item.message)
   );
 }
 
@@ -14344,7 +14464,6 @@ async function handleCompletionReply({
     stagedWorkspaceImagePaths
   );
   let lastError = null;
-  const ownerClientId = runtime.threadOwnerClientIds.get(conversationId) ?? null;
   const finalizeReplyAccepted = async () => {
     if (timelineImageAliases.length > 0) {
       const aliases = isPlainObject(state.timelineImagePathAliases)
@@ -14357,46 +14476,76 @@ async function handleCompletionReply({
     }
     scheduleBestEffortFileCleanup(stagedWorkspaceImagePaths);
   };
+  const sendReplyCandidate = async (candidate, attemptLabel = "initial") => {
+    const currentOwnerClientId = runtime.threadOwnerClientIds.get(conversationId) ?? null;
+    console.log(
+      `[completion-reply] try candidate=${candidate.name} attempt=${attemptLabel} transport=${cleanText(candidate.transport || "thread-follower")} owner=${cleanText(currentOwnerClientId || "") || "none"} images=${normalizedLocalImagePaths.length} workspaceImages=${stagedWorkspaceImagePaths.length} cwd=${cleanText(resolvedCwd || "") || "none"}`
+    );
+    if (candidate.transport === "direct-turn-start" && currentOwnerClientId) {
+      return runtime.ipcClient.startTurnDirect(
+        conversationId,
+        candidate.turnStartParams,
+        currentOwnerClientId,
+        { timeoutMs: config.completionReplyAckTimeoutMs }
+      );
+    }
+    return runtime.ipcClient.startTurn(
+      conversationId,
+      candidate.turnStartParams,
+      currentOwnerClientId,
+      { timeoutMs: config.completionReplyAckTimeoutMs }
+    );
+  };
+  let reopenedCodexThread = false;
 
   for (const candidate of turnCandidates) {
     try {
-      console.log(
-        `[completion-reply] try candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")} owner=${cleanText(ownerClientId || "") || "none"} images=${normalizedLocalImagePaths.length} workspaceImages=${stagedWorkspaceImagePaths.length} cwd=${cleanText(resolvedCwd || "") || "none"}`
-      );
-      if (candidate.transport === "direct-turn-start" && ownerClientId) {
-        await runtime.ipcClient.startTurnDirect(
-          conversationId,
-          candidate.turnStartParams,
-          ownerClientId,
-          { timeoutMs: config.completionReplyAckTimeoutMs }
-        );
-      } else {
-        await runtime.ipcClient.startTurn(
-          conversationId,
-          candidate.turnStartParams,
-          ownerClientId,
-          { timeoutMs: config.completionReplyAckTimeoutMs }
-        );
-      }
+      await sendReplyCandidate(candidate);
       console.log(
         `[completion-reply] success at=${new Date().toISOString()} candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")}`
       );
       await finalizeReplyAccepted();
       return { alreadyAccepted: false };
     } catch (error) {
-      if (isStartTurnAckTimeout(error)) {
+      let candidateError = error;
+      if (isIpcNoClientFoundError(candidateError) && !reopenedCodexThread) {
+        reopenedCodexThread = true;
+        runtime.threadOwnerClientIds.delete(conversationId);
+        const reopened = openCodexThreadBestEffort(conversationId);
+        if (reopened) {
+          const ownerReady = await waitForCodexThreadOwner(
+            runtime,
+            conversationId,
+            config.completionReplyThreadReopenWaitMs
+          );
+          console.log(
+            `[completion-reply] retry after Codex thread reopen candidate=${candidate.name} ownerReady=${ownerReady ? 1 : 0}`
+          );
+          try {
+            await sendReplyCandidate(candidate, "after-reopen");
+            console.log(
+              `[completion-reply] success at=${new Date().toISOString()} candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")} reopened=1`
+            );
+            await finalizeReplyAccepted();
+            return { alreadyAccepted: false, reopenedCodexThread: true };
+          } catch (retryError) {
+            candidateError = retryError;
+          }
+        }
+      }
+      if (isStartTurnAckTimeout(candidateError)) {
         // Codex can create the turn but fail to send the bridge an ACK before
         // its internal follower timeout fires. Retrying risks duplicate user
         // turns, so treat this as accepted and let the timeline catch up.
         console.log(
-          `[completion-reply] accepted at=${new Date().toISOString()} candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")} ack-timeout=${normalizeIpcErrorMessage(error)}`
+          `[completion-reply] accepted at=${new Date().toISOString()} candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")} ack-timeout=${normalizeIpcErrorMessage(candidateError)}`
         );
         await finalizeReplyAccepted();
         return { alreadyAccepted: false, ackTimeout: true };
       }
-      lastError = error;
+      lastError = candidateError;
       console.log(
-        `[completion-reply] failed candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")} error=${normalizeIpcErrorMessage(error)} raw=${inspect(error?.ipcError ?? error, { depth: 6, breakLength: 160 })}`
+        `[completion-reply] failed candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")} error=${normalizeIpcErrorMessage(candidateError)} raw=${inspect(candidateError?.ipcError ?? candidateError, { depth: 6, breakLength: 160 })}`
       );
     }
   }
@@ -15572,7 +15721,7 @@ function resolveManifestPairingToken({ config, state, requestedToken }) {
   if (!isPairingAvailable(config)) {
     return "";
   }
-  return cleanText(config.pairingToken) === token ? token : "";
+  return constantTimeStringEqual(cleanText(config.pairingToken), token) ? token : "";
 }
 
 function buildWebManifest({ pairToken }) {
@@ -15607,7 +15756,7 @@ function buildWebManifest({ pairToken }) {
   );
 }
 
-function buildWebAppHtml({ pairToken }) {
+function buildWebAppHtml({ pairToken, nonce }) {
   const manifestHref = pairToken
     ? `/manifest.webmanifest?pairToken=${encodeURIComponent(pairToken)}`
     : "/manifest.webmanifest";
@@ -15730,7 +15879,7 @@ function buildWebAppHtml({ pairToken }) {
       </div>
     </div>
     <div id="app"></div>
-    <script>
+    <script nonce="${nonce}">
       (() => {
         const isJa = (navigator.language || "").toLowerCase().startsWith("ja");
         const message = isJa ? "同じWi-Fi内のPCを確認中..." : "Checking your trusted Wi-Fi...";
@@ -16015,10 +16164,22 @@ function createNativeApprovalServer({ config, runtime, state }) {
           state,
           requestedToken: url.searchParams.get("pairToken"),
         });
+        const cspNonce = crypto.randomBytes(16).toString("base64url");
         res.statusCode = 200;
         res.setHeader("Content-Type", "text/html; charset=utf-8");
         res.setHeader("Cache-Control", "no-store, max-age=0");
-        res.end(buildWebAppHtml({ pairToken }));
+        // Defense-in-depth against XSS in the control-plane PWA: this document
+        // renders server-built HTML that can contain untrusted agent content,
+        // so lock script execution to same-origin plus the single nonce'd inline
+        // boot script. Without 'unsafe-inline', an injected <script>, onerror=
+        // handler, or javascript: URL cannot run even if it slips past the
+        // markdown sanitizer. img/style/connect are intentionally left to the
+        // browser default so remote connection, wallet, and images keep working.
+        res.setHeader(
+          "Content-Security-Policy",
+          `script-src 'self' 'nonce-${cspNonce}'; object-src 'none'; base-uri 'self'; frame-ancestors 'none'`
+        );
+        res.end(buildWebAppHtml({ pairToken, nonce: cspNonce }));
         return;
       }
 
@@ -16149,7 +16310,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
       const apiA2ATaskStatus = url.pathname.match(/^\/api\/providers\/a2a\/tasks\/([^/]+)\/status$/u);
       if (apiA2ATaskStatus && req.method === "GET") {
         const apiKey = req.headers["x-a2a-key"] || "";
-        if (!config.a2aApiKey || apiKey !== config.a2aApiKey) {
+        if (!config.a2aApiKey || !constantTimeStringEqual(apiKey, config.a2aApiKey)) {
           return writeJson(res, 401, { error: "unauthorized" });
         }
         const token = decodeURIComponent(apiA2ATaskStatus[1]);
@@ -16618,7 +16779,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
 
 if (url.pathname === "/api/hazbase/status" && req.method === "GET") {
   const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-  const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+  const hookAuth = config.sessionSecret && constantTimeStringEqual(hookSecret, config.sessionSecret);
   if (!hookAuth) {
     const session = requireApiSession(req, res, config, state);
     if (!session) return;
@@ -16627,12 +16788,20 @@ if (url.pathname === "/api/hazbase/status" && req.method === "GET") {
     return writeJson(res, 200, { enabled: false });
   }
   const hazbase = normalizeHazbaseState(state.hazbase);
-  const [paymentsResult, chainsResult] = await Promise.allSettled([
+  const localPasskeyRegistered = Boolean(hazbase.deviceBindingId || hazbase.credentialId);
+  const devicesPromise = hazbase.accessToken && !hazbase.sessionInvalid && !localPasskeyRegistered
+    ? listPasskeyDevices({ emailSession: hazbase.accessToken })
+    : Promise.resolve(null);
+  const [paymentsResult, chainsResult, devicesResult] = await Promise.allSettled([
     fetchHazbaseMetadata(config, "/api/meta/payments"),
     fetchHazbaseMetadata(config, "/api/meta/chains"),
+    devicesPromise,
   ]);
   const payments = paymentsResult.status === "fulfilled" ? paymentsResult.value : null;
   const chains = chainsResult.status === "fulfilled" ? chainsResult.value : null;
+  const passkeyDevices = devicesResult.status === "fulfilled" && Array.isArray(devicesResult.value?.devices)
+    ? devicesResult.value.devices
+    : [];
   const errors = [];
   if (paymentsResult.status === "rejected") {
     errors.push(paymentsResult.reason?.message || String(paymentsResult.reason || "payments metadata unavailable"));
@@ -16640,13 +16809,31 @@ if (url.pathname === "/api/hazbase/status" && req.method === "GET") {
   if (chainsResult.status === "rejected") {
     errors.push(chainsResult.reason?.message || String(chainsResult.reason || "chains metadata unavailable"));
   }
+  if (devicesResult.status === "rejected") {
+    if (await maybeWriteHazbaseSessionExpiredResponse({ error: devicesResult.reason, config, state, res })) return;
+    errors.push(devicesResult.reason?.message || String(devicesResult.reason || "passkey devices unavailable"));
+  }
   const supportedChains = Array.isArray(chains?.chains)
-    ? chains.chains.filter((entry) => Number(entry.chainId) === 8453 || Number(entry.chainId) === 84532)
+    ? chains.chains.filter((entry) => Boolean(paymentNetworkForChainId(Number(entry.chainId))))
+        .filter((entry) => isPaymentNetworkAvailable(paymentNetworkForChainId(Number(entry.chainId))))
     : [];
   const payoutAddresses = {
-    8453: resolveHazbaseAccountForChain(hazbase.accounts, 8453)?.smartAccountAddress || "",
     84532: resolveHazbaseAccountForChain(hazbase.accounts, 84532)?.smartAccountAddress || "",
+    80002: resolveHazbaseAccountForChain(hazbase.accounts, 80002)?.smartAccountAddress || "",
   };
+  const rawPaymentCapabilities = buildPaymentCapabilities({ hazbase, payments });
+  const paymentCapabilities = applyAgentPaymentDefaults(rawPaymentCapabilities, hazbase.agentPaymentDefaults);
+  const agentPaymentDefaults = agentPaymentDefaultsStatus(hazbase.agentPaymentDefaults, rawPaymentCapabilities);
+  const supportedPayments = (Array.isArray(payments?.networks) ? payments.networks : [])
+    .filter((entry) => isPaymentNetworkAvailable(normalizePaymentNetworkKey(entry?.network || entry?.id || "")));
+  const defaultPaymentNetwork = isPaymentNetworkAvailable(normalizePaymentNetworkKey(payments?.defaultNetwork || ""))
+    ? payments.defaultNetwork
+    : "base-sepolia";
+  for (const capability of paymentCapabilities) {
+    if (capability.payTo) {
+      payoutAddresses[capability.network] = capability.payTo;
+    }
+  }
   const signedIn = Boolean(hazbase.accessToken) && !hazbase.sessionInvalid;
   return writeJson(res, 200, {
     enabled: true,
@@ -16661,11 +16848,15 @@ if (url.pathname === "/api/hazbase/status" && req.method === "GET") {
     sessionId: hazbase.sessionId,
     deviceBindingId: hazbase.deviceBindingId,
     credentialId: hazbase.credentialId,
+    passkeyRegistered: Boolean(localPasskeyRegistered || passkeyDevices.length),
+    passkeyDeviceCount: passkeyDevices.length,
     highTrustExpiresAt: hazbase.highTrustExpiresAt,
     accounts: hazbase.accounts,
-    supportedPayments: payments?.networks || [],
+    paymentCapabilities,
+    agentPaymentDefaults,
+    supportedPayments,
     supportedChains,
-    defaultPaymentNetwork: payments?.defaultNetwork || "base-sepolia",
+    defaultPaymentNetwork,
     payoutAddresses,
     error: errors.join(" | "),
   });
@@ -16673,23 +16864,55 @@ if (url.pathname === "/api/hazbase/status" && req.method === "GET") {
 
 if (url.pathname === "/api/hazbase/payout-address" && req.method === "GET") {
   const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-  const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+  const hookAuth = config.sessionSecret && constantTimeStringEqual(hookSecret, config.sessionSecret);
   if (!hookAuth) {
     const session = requireApiSession(req, res, config, state);
     if (!session) return;
   }
   const hazbase = normalizeHazbaseState(state.hazbase);
   if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
-  const chainId = Number(url.searchParams.get("chainId") || 0);
-  if (chainId !== 8453 && chainId !== 84532) {
+  const networkParam = normalizePaymentNetworkKey(url.searchParams.get("network") || "");
+  if (networkParam && PAYMENT_NETWORKS[networkParam]?.family === "liquid") {
+    if (!isPaymentNetworkAvailable(networkParam)) {
+      return writeJson(res, 409, { error: "payment-network-coming-soon" });
+    }
+    const capability = resolvePaymentCapability(
+      buildPaymentCapabilities({ hazbase, payments: null }),
+      networkParam,
+      url.searchParams.get("asset") || "usdt",
+    );
+    if (!capability?.payTo) return writeJson(res, 409, { error: "hazbase-wallet-account-missing" });
+    return writeJson(res, 200, {
+      chainId: null,
+      network: networkParam,
+      asset: capability.asset,
+      scheme: capability.scheme,
+      payoutMethod: "external_liquid",
+      payoutAddress: capability.payTo,
+      payTo: capability.payTo,
+      issuer: capability.issuer || "external",
+    });
+  }
+  const chainId = networkParam && PAYMENT_NETWORKS[networkParam]?.family === "evm"
+    ? Number(PAYMENT_NETWORKS[networkParam].chainId || 0)
+    : Number(url.searchParams.get("chainId") || 0);
+  if (!paymentNetworkForChainId(chainId)) {
     return writeJson(res, 400, { error: "unsupported-chain" });
   }
+  if (!isPaymentNetworkAvailable(paymentNetworkForChainId(chainId))) {
+    return writeJson(res, 409, { error: "payment-network-coming-soon" });
+  }
+  const evmNetwork = paymentNetworkForChainId(chainId);
+  const asset = normalizePaymentAssetKey(url.searchParams.get("asset") || PAYMENT_NETWORKS[evmNetwork]?.asset, evmNetwork);
+  if (!asset) return writeJson(res, 400, { error: "unsupported-payment-asset" });
   const account = resolveHazbaseAccountForChain(hazbase.accounts, chainId);
   if (!account?.smartAccountAddress) {
     return writeJson(res, 409, { error: "hazbase-wallet-account-missing" });
   }
   return writeJson(res, 200, {
     chainId,
+    network: evmNetwork,
+    asset,
     payoutMethod: "hazbase_wallet",
     payoutAddress: account.smartAccountAddress,
     smartAccountAddress: account.smartAccountAddress,
@@ -16867,9 +17090,12 @@ if (url.pathname === "/api/hazbase/account/bootstrap" && req.method === "POST")
   }
   const body = await parseJsonBody(req);
   const chainId = Number(body?.chainId || 0);
-  if (chainId !== 8453 && chainId !== 84532) {
+  if (!paymentNetworkForChainId(chainId)) {
     return writeJson(res, 400, { error: "unsupported-chain" });
   }
+  if (!isPaymentNetworkAvailable(paymentNetworkForChainId(chainId))) {
+    return writeJson(res, 409, { error: "payment-network-coming-soon" });
+  }
   let result;
   try {
     result = await bootstrapPasskeyAccount({
@@ -16900,9 +17126,91 @@ if (url.pathname === "/api/hazbase/account/bootstrap" && req.method === "POST")
   return writeJson(res, 200, result);
 }
 
+if (url.pathname === "/api/hazbase/payment-capability" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
+  const body = await parseJsonBody(req);
+  const network = normalizePaymentNetworkKey(body?.network);
+  if (!network || PAYMENT_NETWORKS[network]?.family !== "liquid") {
+    return writeJson(res, 400, { error: "unsupported-payment-network" });
+  }
+  if (!isPaymentNetworkAvailable(network)) {
+    return writeJson(res, 409, { error: "payment-network-coming-soon" });
+  }
+  const asset = normalizePaymentAssetKey(body?.asset || "usdt", network);
+  if (!asset) return writeJson(res, 400, { error: "unsupported-payment-asset" });
+  const payTo = cleanText(body?.payTo || body?.payoutAddress || "").toLowerCase();
+  if (!isValidLiquidAddressForNetwork(payTo, network)) {
+    return writeJson(res, 400, { error: "invalid-liquid-address" });
+  }
+  const nextCapability = {
+    network,
+    asset,
+    scheme: PAYMENT_NETWORKS[network].scheme,
+    payoutMethod: "external_liquid",
+    payTo,
+    configured: true,
+    issuer: "external",
+  };
+  const existing = normalizeStoredPaymentCapabilities(hazbase.paymentCapabilities)
+    .filter((entry) => !(entry.network === network && entry.asset === asset));
+  state.hazbase = {
+    ...hazbase,
+    paymentCapabilities: [...existing, nextCapability],
+    sessionInvalid: false,
+    sessionInvalidReason: "",
+    sessionInvalidAt: "",
+  };
+  await saveState(config.stateFile, state);
+  return writeJson(res, 200, { ok: true, capability: nextCapability });
+}
+
+if (url.pathname === "/api/hazbase/agent-payment-defaults" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  const body = await parseJsonBody(req);
+  const mode = cleanText(body?.mode || "").toLowerCase() === "configured" ? "configured" : "custom";
+  let nextDefaults;
+  if (mode === "configured") {
+    nextDefaults = { mode: "configured", accepts: [] };
+  } else {
+    const capabilities = buildPaymentCapabilities({ hazbase, payments: null });
+    const configuredKeys = new Set(
+      capabilities
+        .filter((entry) => entry?.configured && entry?.enabled !== false && isPaymentNetworkAvailable(entry.network))
+        .map((entry) => paymentCapabilityKey(entry))
+        .filter(Boolean)
+    );
+    const rawAccepts = Array.isArray(body?.accepts) ? body.accepts : [];
+    const accepts = [];
+    const seen = new Set();
+    for (const entry of rawAccepts) {
+      const ref = paymentCapabilityRef(entry);
+      if (!ref) return writeJson(res, 400, { error: "unsupported-payment-capability" });
+      const key = `${ref.network}:${ref.asset}`;
+      if (!configuredKeys.has(key)) {
+        return writeJson(res, 409, { error: "payment-capability-not-configured", network: ref.network, asset: ref.asset });
+      }
+      if (seen.has(key)) continue;
+      seen.add(key);
+      accepts.push(ref);
+    }
+    nextDefaults = { mode: "custom", accepts };
+  }
+  state.hazbase = {
+    ...hazbase,
+    agentPaymentDefaults: nextDefaults,
+  };
+  await saveState(config.stateFile, state);
+  return writeJson(res, 200, { ok: true, agentPaymentDefaults: nextDefaults });
+}
+
 if (url.pathname === "/api/hazbase/session/refresh" && req.method === "POST") {
   const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-  const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+  const hookAuth = config.sessionSecret && constantTimeStringEqual(hookSecret, config.sessionSecret);
   if (!hookAuth) {
     const session = requireMutatingApiSession(req, res, config, state);
     if (!session) return;
@@ -17511,7 +17819,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
       // List known threads (active + registry) for the share target picker.
       if (url.pathname === "/api/threads/list" && req.method === "GET") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+        const hookAuth = config.sessionSecret && constantTimeStringEqual(hookSecret, config.sessionSecret);
         if (!hookAuth) { const session = requireApiSession(req, res, config, state); if (!session) return; }
         const codexConnected = Boolean(runtime.ipcClient?.clientId);
         const activeIds = new Set();
@@ -17555,7 +17863,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
       // Submit a thread share request (creates an approval item on the phone).
       if (url.pathname === "/api/threads/share" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+        const hookAuth = config.sessionSecret && constantTimeStringEqual(hookSecret, config.sessionSecret);
         if (!hookAuth) { const session = requireApiSession(req, res, config, state); if (!session) return; }
         const body = await parseJsonBody(req);
         const shareType = cleanText(body?.shareType || "message");
@@ -17805,7 +18113,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
       // time-slot-based compose.  Defaults to full-day today.
       if (url.pathname === "/api/providers/moltbook/activity-summary" && req.method === "GET") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+        if (!config.sessionSecret || !constantTimeStringEqual(hookSecret, config.sessionSecret)) {
           return writeJson(res, 403, { error: "forbidden" });
         }
         const slot = String(url.searchParams.get("slot") || "").toLowerCase();
@@ -17980,7 +18288,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
 
       if (url.pathname === "/api/payments/x402/hazbase-wallet" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+        if (!config.sessionSecret || !constantTimeStringEqual(hookSecret, config.sessionSecret)) {
           return writeJson(res, 401, { error: "unauthorized" });
         }
 
@@ -18070,7 +18378,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
 
       if (url.pathname === "/api/payments/x402/approval" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+        if (!config.sessionSecret || !constantTimeStringEqual(hookSecret, config.sessionSecret)) {
           return writeJson(res, 401, { error: "unauthorized" });
         }
 
@@ -18138,7 +18446,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
 
       if (url.pathname === "/api/providers/mcp/events" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+        if (!config.sessionSecret || !constantTimeStringEqual(hookSecret, config.sessionSecret)) {
           return writeJson(res, 401, { error: "unauthorized" });
         }
 
@@ -18154,7 +18462,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
 
       if (url.pathname === "/api/providers/claude/events" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+        if (!config.sessionSecret || !constantTimeStringEqual(hookSecret, config.sessionSecret)) {
           return writeJson(res, 401, { error: "unauthorized" });
         }
 
@@ -18518,7 +18826,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
 
       if (url.pathname === "/api/providers/moltbook/events" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+        if (!config.sessionSecret || !constantTimeStringEqual(hookSecret, config.sessionSecret)) {
           return writeJson(res, 401, { error: "unauthorized" });
         }
         let body;
@@ -18670,7 +18978,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
 
       if (url.pathname === "/api/providers/moltbook/draft" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+        if (!config.sessionSecret || !constantTimeStringEqual(hookSecret, config.sessionSecret)) {
           return writeJson(res, 401, { error: "unauthorized" });
         }
         let body;
@@ -18797,7 +19105,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
       );
       if (apiMoltbookDraftDecisionGet && req.method === "GET") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
-        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+        if (!config.sessionSecret || !constantTimeStringEqual(hookSecret, config.sessionSecret)) {
           return writeJson(res, 401, { error: "unauthorized" });
         }
         const token = decodeURIComponent(apiMoltbookDraftDecisionGet[1]);
@@ -21246,6 +21554,10 @@ function buildConfig(cli) {
       "COMPLETION_REPLY_ACK_TIMEOUT_MS",
       DEFAULT_COMPLETION_REPLY_ACK_TIMEOUT_MS
     ),
+    completionReplyThreadReopenWaitMs: numberEnv(
+      "COMPLETION_REPLY_THREAD_REOPEN_WAIT_MS",
+      DEFAULT_COMPLETION_REPLY_THREAD_REOPEN_WAIT_MS
+    ),
     choicePageSize: numberEnv("CHOICE_PAGE_SIZE", 5),
     completionReplyImageMaxBytes: numberEnv(
       "COMPLETION_REPLY_IMAGE_MAX_BYTES",
@@ -21291,6 +21603,8 @@ function normalizeHazbaseState(raw) {
     highTrustToken: cleanText(value.highTrustToken ?? ""),
     highTrustExpiresAt: cleanText(value.highTrustExpiresAt ?? ""),
     accounts,
+    paymentCapabilities: normalizeStoredPaymentCapabilities(value.paymentCapabilities),
+    agentPaymentDefaults: normalizeAgentPaymentDefaults(value.agentPaymentDefaults),
     sessionInvalid: value.sessionInvalid === true,
     sessionInvalidReason: cleanText(value.sessionInvalidReason ?? ""),
     sessionInvalidAt: cleanText(value.sessionInvalidAt ?? ""),
@@ -21551,6 +21865,202 @@ function resolveHazbaseAccountForChain(accounts, chainId) {
   return list.find((entry) => Number(entry?.chainId) === normalizedChainId && cleanText(entry?.smartAccountAddress || "")) || null;
 }
 
+function normalizePaymentNetworkKey(raw) {
+  const value = cleanText(raw || "").toLowerCase();
+  if (value === "basesepolia") return "base-sepolia";
+  if (value === "polygonamoy" || value === "amoy") return "polygon-amoy";
+  if (value === "matic") return "polygon";
+  if (value === "liquid" || value === "liquid-mainnet") return "liquidv1";
+  return PAYMENT_NETWORKS[value] ? value : "";
+}
+
+function isPaymentNetworkAvailable(network) {
+  return PAYMENT_NETWORKS[network]?.releaseStatus !== "comingSoon";
+}
+
+function paymentNetworkForChainId(chainId) {
+  const id = Number(chainId || 0);
+  return Object.entries(PAYMENT_NETWORKS).find(([, entry]) => entry.chainId === id)?.[0] || "";
+}
+
+function normalizePaymentAssetKey(raw, network) {
+  const networkInfo = PAYMENT_NETWORKS[network] || null;
+  const value = cleanText(raw || networkInfo?.asset || "").toLowerCase();
+  if (value === "usd-t" || value === "tether") return "usdt";
+  if (value === "jpy" || value === "jpy-coin") return "jpyc";
+  if (value === "bitcoin" || value === "btc") return "lbtc";
+  const allowed = Array.isArray(networkInfo?.assets) ? networkInfo.assets : [networkInfo?.asset].filter(Boolean);
+  if ((value === "usdc" || value === "jpyc" || value === "usdt" || value === "lbtc") && allowed.includes(value)) return value;
+  return "";
+}
+
+function isValidLiquidAddressForNetwork(address, network) {
+  const value = cleanText(address || "").toLowerCase();
+  if (network === "liquidtestnet") return /^(tlq1|tex1)[0-9a-z]{20,}$/u.test(value);
+  if (network === "liquidv1") return /^(lq1|ex1)[0-9a-z]{20,}$/u.test(value);
+  return false;
+}
+
+function normalizeStoredPaymentCapabilities(value) {
+  const list = Array.isArray(value) ? value : [];
+  const out = [];
+  for (const entry of list) {
+    const network = normalizePaymentNetworkKey(entry?.network);
+    if (!network || PAYMENT_NETWORKS[network]?.family !== "liquid") continue;
+    const asset = normalizePaymentAssetKey(entry?.asset, network);
+    const payTo = cleanText(entry?.payTo || entry?.payoutAddress || "").toLowerCase();
+    if (!asset || !isValidLiquidAddressForNetwork(payTo, network)) continue;
+    out.push({
+      network,
+      asset,
+      scheme: PAYMENT_NETWORKS[network].scheme,
+      payoutMethod: "external_liquid",
+      payTo,
+      configured: true,
+      issuer: cleanText(entry?.issuer || "external") || "external",
+    });
+  }
+  return out;
+}
+
+function paymentCapabilityRef(entry) {
+  const network = normalizePaymentNetworkKey(entry?.network);
+  const asset = normalizePaymentAssetKey(entry?.asset, network);
+  if (!network || !asset) return null;
+  return { network, asset };
+}
+
+function paymentCapabilityKey(entry) {
+  const ref = paymentCapabilityRef(entry);
+  return ref ? `${ref.network}:${ref.asset}` : "";
+}
+
+function normalizeAgentPaymentDefaults(value) {
+  const raw = value && typeof value === "object" ? value : {};
+  const mode = cleanText(raw.mode || "").toLowerCase() === "custom" ? "custom" : "configured";
+  const list = Array.isArray(raw.accepts) ? raw.accepts : Array.isArray(value) ? value : [];
+  const accepts = [];
+  const seen = new Set();
+  for (const entry of list) {
+    const ref = paymentCapabilityRef(entry);
+    if (!ref || !isPaymentNetworkAvailable(ref.network)) continue;
+    const key = `${ref.network}:${ref.asset}`;
+    if (seen.has(key)) continue;
+    seen.add(key);
+    accepts.push(ref);
+  }
+  return { mode, accepts };
+}
+
+function effectiveAgentPaymentDefaultRefs(defaults, capabilities) {
+  const normalized = normalizeAgentPaymentDefaults(defaults);
+  const configured = (Array.isArray(capabilities) ? capabilities : [])
+    .filter((entry) => entry?.configured && entry?.enabled !== false && isPaymentNetworkAvailable(entry.network))
+    .map((entry) => paymentCapabilityRef(entry))
+    .filter(Boolean);
+  if (normalized.mode !== "custom") {
+    return configured;
+  }
+  const configuredKeys = new Set(configured.map((entry) => `${entry.network}:${entry.asset}`));
+  return normalized.accepts.filter((entry) => configuredKeys.has(`${entry.network}:${entry.asset}`));
+}
+
+function applyAgentPaymentDefaults(capabilities, defaults) {
+  const effective = effectiveAgentPaymentDefaultRefs(defaults, capabilities);
+  const enabledKeys = new Set(effective.map((entry) => `${entry.network}:${entry.asset}`));
+  return (Array.isArray(capabilities) ? capabilities : []).map((entry) => ({
+    ...entry,
+    agentEnabled: enabledKeys.has(paymentCapabilityKey(entry)),
+  }));
+}
+
+function agentPaymentDefaultsStatus(defaults, capabilities) {
+  const normalized = normalizeAgentPaymentDefaults(defaults);
+  return {
+    mode: normalized.mode,
+    accepts: normalized.accepts,
+    effectiveAccepts: effectiveAgentPaymentDefaultRefs(normalized, capabilities),
+  };
+}
+
+function liquidCapabilityFromEnv(network) {
+  if (!isPaymentNetworkAvailable(network)) return null;
+  const suffix = network === "liquidtestnet" ? "LIQUIDTESTNET" : "LIQUIDV1";
+  const payTo = cleanText(process.env[`VIVEWORKER_${suffix}_PAYOUT_ADDRESS`] || process.env[`VIVEWORKER_${suffix}_PAY_TO`] || "").toLowerCase();
+  if (!isValidLiquidAddressForNetwork(payTo, network)) return null;
+  return {
+    network,
+    asset: "usdt",
+    scheme: PAYMENT_NETWORKS[network].scheme,
+    payoutMethod: "external_liquid",
+    payTo,
+    configured: true,
+    issuer: "env",
+  };
+}
+
+function buildPaymentCapabilities({ hazbase, payments }) {
+  const supported = Array.isArray(payments?.networks) ? payments.networks : [];
+  const supportedByNetwork = new Map(supported.map((entry) => [cleanText(entry?.network || entry?.id || ""), entry]));
+  const capabilities = [];
+  for (const network of ["base-sepolia", "base", "polygon-amoy", "polygon"]) {
+    const meta = PAYMENT_NETWORKS[network];
+    const paymentMeta = supportedByNetwork.get(network) || null;
+    const supportedAssets = Array.isArray(paymentMeta?.assets) && paymentMeta.assets.length > 0
+      ? paymentMeta.assets.map((entry) => normalizePaymentAssetKey(entry?.asset, network)).filter(Boolean)
+      : meta.assets || [meta.asset];
+    const account = resolveHazbaseAccountForChain(hazbase.accounts, meta.chainId);
+    const available = isPaymentNetworkAvailable(network);
+    for (const asset of [...new Set(supportedAssets)]) {
+      capabilities.push({
+        network,
+        family: "evm",
+        chainId: meta.chainId,
+        asset,
+        scheme: "exact",
+        payoutMethod: "hazbase_wallet",
+        payTo: account?.smartAccountAddress || "",
+        smartAccountAddress: account?.smartAccountAddress || "",
+        configured: Boolean(account?.smartAccountAddress),
+        enabled: available && (supportedByNetwork.has(network) || supported.length === 0),
+        label: meta.label,
+        issuer: "hazbase",
+        releaseStatus: meta.releaseStatus || "available",
+      });
+    }
+  }
+  const stored = normalizeStoredPaymentCapabilities(hazbase.paymentCapabilities);
+  for (const network of ["liquidtestnet", "liquidv1"]) {
+    const meta = PAYMENT_NETWORKS[network];
+    const existing = stored.find((entry) => entry.network === network) || liquidCapabilityFromEnv(network);
+    const available = isPaymentNetworkAvailable(network);
+    capabilities.push({
+      network,
+      family: "liquid",
+      chainId: null,
+      asset: existing?.asset || meta.asset,
+      scheme: meta.scheme,
+      payoutMethod: "external_liquid",
+      payTo: existing?.payTo || "",
+      configured: Boolean(existing?.payTo),
+      enabled: available && (supportedByNetwork.has(network) || supported.length === 0),
+      label: meta.label,
+      issuer: existing?.issuer || "external",
+      releaseStatus: meta.releaseStatus || "available",
+    });
+  }
+  return capabilities;
+}
+
+function resolvePaymentCapability(capabilities, network, asset = "") {
+  const normalizedNetwork = normalizePaymentNetworkKey(network);
+  const normalizedAsset = normalizePaymentAssetKey(asset, normalizedNetwork);
+  return capabilities.find((entry) => (
+    normalizePaymentNetworkKey(entry.network) === normalizedNetwork &&
+    (!normalizedAsset || normalizePaymentAssetKey(entry.asset, normalizedNetwork) === normalizedAsset)
+  )) || null;
+}
+
 
 async function finalizeHazbaseWalletPaymentFailure({ config, runtime, state, approval, error }) {
   const errorCode = cleanText(error?.code || error?.message || "hazbase-wallet-payment-failed") || "hazbase-wallet-payment-failed";
@@ -22020,8 +22530,13 @@ async function saveState(stateFile, state) {
   // single newline at the end keeps diffs/hexdumps working on the off chance
   // someone cats the file.
   const output = JSON.stringify(state);
-  await fs.mkdir(path.dirname(stateFile), { recursive: true });
-  await fs.writeFile(stateFile, `${output}\n`, "utf8");
+  await fs.mkdir(path.dirname(stateFile), { recursive: true, mode: 0o700 });
+  // state.json holds hazbase wallet tokens, push subscriptions, and device
+  // records — keep it owner-only so other local users can't read it. writeFile's
+  // mode only applies on create, so chmod explicitly to also tighten any file
+  // that was previously written world-readable.
+  await fs.writeFile(stateFile, `${output}\n`, { mode: 0o600 });
+  await fs.chmod(stateFile, 0o600).catch(() => {});
 }
 
 // ---------------------------------------------------------------------------