viveworker 0.7.0-beta.2 → 0.7.0

package/scripts/viveworker-bridge.mjs

@@ -56,6 +56,8 @@ const DEFAULT_COMPLETION_REPLY_IMAGE_MAX_BYTES = 15 * 1024 * 1024;
 const DEFAULT_COMPLETION_REPLY_UPLOAD_TTL_MS = 24 * 60 * 60 * 1000;
 const MAX_COMPLETION_REPLY_IMAGE_COUNT = 4;
 const HAZBASE_METADATA_TIMEOUT_MS = 1500;
+const NPM_VERSION_CHECK_TIMEOUT_MS = 2500;
+const NPM_VERSION_CHECK_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
 
 // Shared memo for buildDiffThreadGroups. Each call spawns 3 git subprocesses
 // per tracked repo (`git diff --name-status`, `git status --porcelain`,
@@ -265,6 +267,11 @@ const runtime = {
   // deliberately NOT persisted via `state` since the cache is worthless after
   // a restart and would just bloat the state file.
   a2aShareStatusCache: null,
+  // Latest npm version cache. Checked only from the technical settings page
+  // and cached here so a weak network or repeated settings renders never
+  // hammer registry.npmjs.org.
+  npmVersionStatusCache: null,
+  npmVersionStatusPending: null,
 };
 const state = await loadState(config.stateFile);
 runtime.threadRegistry = await loadThreadRegistry(config.threadRegistryFile);
@@ -673,7 +680,7 @@ function withNotificationIcon(kind, title) {
 
 function normalizeTimelineOutcome(value) {
   const normalized = cleanText(value || "").toLowerCase();
-  return ["pending", "approved", "rejected", "implemented", "dismissed", "submitted"].includes(normalized)
+  return ["pending", "approved", "rejected", "failed", "implemented", "dismissed", "submitted"].includes(normalized)
     ? normalized
     : "";
 }
@@ -2809,6 +2816,7 @@ function providerDisplayName(locale, provider) {
   if (p === "claude") return t(locale, "common.claude");
   if (p === "moltbook") return "Moltbook";
   if (p === "a2a") return "A2A";
+  if (p === "viveworker") return t(locale, "common.appName");
   return t(locale, "common.codex");
 }
 
@@ -2848,7 +2856,7 @@ function normalizeHistoryItem(raw) {
   if (!isPlainObject(raw)) {
     return null;
   }
-  if (shouldHideClaudeInternalItem(raw)) {
+  if (shouldHideInternalTimelineItem(raw)) {
     return null;
   }
 
@@ -2903,7 +2911,7 @@ function normalizeHistoryItem(raw) {
     ...(raw.instruction != null ? { instruction: cleanText(raw.instruction) } : {}),
     ...(raw.taskStatus != null ? { taskStatus: cleanText(raw.taskStatus) } : {}),
   };
-  return shouldHideClaudeInternalItem(normalized) ? null : normalized;
+  return shouldHideInternalTimelineItem(normalized) ? null : normalized;
 }
 
 function historyToken(stableId) {
@@ -2985,6 +2993,70 @@ function normalizeTimelineEntries(rawItems, maxItems) {
   return deduped;
 }
 
+// Cheap structural diff used by record* helpers to decide whether a rebuilt
+// timeline / history / code-events array actually changed in a way worth
+// persisting. The previous implementation `JSON.stringify(a) !== JSON.stringify(b)`
+// allocated several megabytes of intermediate strings on every call when the
+// projection included `diffText` (5+ KB per file_event × ~250 entries × 2
+// sides), which dominated scavenger GC time in busy sessions and showed up as
+// a 25% CPU sink in `JsonStringifier::Serialize_*` under V8 sampling. Walking
+// the arrays in lockstep and bailing on the first mismatched primitive lets
+// the common "fresh entry prepended" case exit on the very first stableId
+// compare with zero allocations.
+//
+// Field semantics:
+// - String / number / boolean fields use value-equality via `===` (works
+//   across object reconstruction by `normalizeTimelineEntry`).
+// - `Array` fields (e.g. `previousFileRefs`) shallow-compare lengths and the
+//   `path` of each element rather than serializing.
+// - `null` / `undefined` are treated as equal to each other but distinct from
+//   any defined value.
+function timelineProjectionChanged(nextItems, previousItems, fieldKeys) {
+  const a = Array.isArray(nextItems) ? nextItems : [];
+  const b = Array.isArray(previousItems) ? previousItems : [];
+  if (a.length !== b.length) {
+    return true;
+  }
+  for (let i = 0; i < a.length; i++) {
+    const ai = a[i];
+    const bi = b[i];
+    if (ai === bi) continue;
+    if (!ai || !bi) return true;
+    for (let k = 0; k < fieldKeys.length; k++) {
+      const key = fieldKeys[k];
+      const av = ai[key];
+      const bv = bi[key];
+      if (av === bv) continue;
+      if (av == null && bv == null) continue;
+      if (Array.isArray(av) && Array.isArray(bv)) {
+        if (av.length !== bv.length) return true;
+        let arrayDiffers = false;
+        for (let j = 0; j < av.length; j++) {
+          const aj = av[j];
+          const bj = bv[j];
+          if (aj === bj) continue;
+          if (!aj || !bj) {
+            arrayDiffers = true;
+            break;
+          }
+          // Most array-of-object fields here are fileRef-shaped: identity is
+          // captured by `path`. Falling back to JSON for unrecognised shapes
+          // is unnecessary — a path mismatch (or a null path either side) is
+          // sufficient to mark the projection changed.
+          if (aj.path !== bj.path) {
+            arrayDiffers = true;
+            break;
+          }
+        }
+        if (arrayDiffers) return true;
+        continue;
+      }
+      return true;
+    }
+  }
+  return false;
+}
+
 function isCodeEventEntry(raw) {
   if (!isPlainObject(raw)) {
     return false;
@@ -3043,7 +3115,7 @@ function normalizeTimelineEntry(raw) {
   if (!isPlainObject(raw)) {
     return null;
   }
-  if (shouldHideClaudeInternalItem(raw)) {
+  if (shouldHideInternalTimelineItem(raw)) {
     return null;
   }
 
@@ -3137,7 +3209,7 @@ function normalizeTimelineEntry(raw) {
     ...(raw.taskStatus != null ? { taskStatus: cleanText(raw.taskStatus) } : {}),
     ...(suggestions.length > 0 ? { suggestions } : {}),
   };
-  return shouldHideClaudeInternalItem(normalized) ? null : normalized;
+  return shouldHideInternalTimelineItem(normalized) ? null : normalized;
 }
 
 function recordTimelineEntry({ config, runtime, state, entry }) {
@@ -3150,35 +3222,21 @@ function recordTimelineEntry({ config, runtime, state, entry }) {
     [normalized, ...runtime.recentTimelineEntries.filter((item) => item.stableId !== normalized.stableId)],
     config.maxTimelineEntries
   );
-  const changed =
-    JSON.stringify(
-      nextItems.map((item) => [
-        item.stableId,
-        item.title,
-        item.createdAtMs,
-        item.diffAvailable,
-        item.diffSource,
-        item.diffAddedLines,
-        item.diffRemovedLines,
-        item.diffText,
-        item.previousFileRefs,
-        item.cwd,
-      ])
-    ) !==
-    JSON.stringify(
-      runtime.recentTimelineEntries.map((item) => [
-        item.stableId,
-        item.title,
-        item.createdAtMs,
-        item.diffAvailable,
-        item.diffSource,
-        item.diffAddedLines,
-        item.diffRemovedLines,
-        item.diffText,
-        item.previousFileRefs,
-        item.cwd,
-      ])
-    );
+  // Note: diffText is intentionally omitted from the projection — the
+  // line-count fields (`diffAddedLines` / `diffRemovedLines`) are a sufficient
+  // proxy for "diff content changed" and avoid materialising a megabyte-class
+  // intermediate string on every record call.
+  const changed = timelineProjectionChanged(nextItems, runtime.recentTimelineEntries, [
+    "stableId",
+    "title",
+    "createdAtMs",
+    "diffAvailable",
+    "diffSource",
+    "diffAddedLines",
+    "diffRemovedLines",
+    "previousFileRefs",
+    "cwd",
+  ]);
   runtime.recentTimelineEntries = nextItems;
   state.recentTimelineEntries = nextItems;
   return changed;
@@ -3197,35 +3255,19 @@ function recordCodeEvent({ config, runtime, state, entry }) {
     [normalized, ...runtime.recentCodeEvents.filter((item) => item.stableId !== normalized.stableId)],
     config.maxCodeEvents
   );
-  const changed =
-    JSON.stringify(
-      nextItems.map((item) => [
-        item.stableId,
-        item.title,
-        item.createdAtMs,
-        item.diffAvailable,
-        item.diffSource,
-        item.diffAddedLines,
-        item.diffRemovedLines,
-        item.diffText,
-        item.previousFileRefs,
-        item.cwd,
-      ])
-    ) !==
-    JSON.stringify(
-      runtime.recentCodeEvents.map((item) => [
-        item.stableId,
-        item.title,
-        item.createdAtMs,
-        item.diffAvailable,
-        item.diffSource,
-        item.diffAddedLines,
-        item.diffRemovedLines,
-        item.diffText,
-        item.previousFileRefs,
-        item.cwd,
-      ])
-    );
+  // See `recordTimelineEntry` for the rationale on dropping `diffText` from
+  // the projection — same megabyte-stringify hot path; same line-count proxy.
+  const changed = timelineProjectionChanged(nextItems, runtime.recentCodeEvents, [
+    "stableId",
+    "title",
+    "createdAtMs",
+    "diffAvailable",
+    "diffSource",
+    "diffAddedLines",
+    "diffRemovedLines",
+    "previousFileRefs",
+    "cwd",
+  ]);
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
   if (changed) {
@@ -3249,37 +3291,19 @@ function syncRecentCodeEventsFromTimeline({ config, runtime, state }) {
     ],
     config.maxCodeEvents
   );
-  const changed =
-    JSON.stringify(
-      nextItems.map((item) => [
-        item.stableId,
-        item.title,
-        item.createdAtMs,
-        item.threadLabel,
-        item.diffAvailable,
-        item.diffSource,
-        item.diffAddedLines,
-        item.diffRemovedLines,
-        item.diffText,
-        item.previousFileRefs,
-        item.cwd,
-      ])
-    ) !==
-    JSON.stringify(
-      runtime.recentCodeEvents.map((item) => [
-        item.stableId,
-        item.title,
-        item.createdAtMs,
-        item.threadLabel,
-        item.diffAvailable,
-        item.diffSource,
-        item.diffAddedLines,
-        item.diffRemovedLines,
-        item.diffText,
-        item.previousFileRefs,
-        item.cwd,
-      ])
-    );
+  // See `recordTimelineEntry` for the rationale on dropping `diffText`.
+  const changed = timelineProjectionChanged(nextItems, runtime.recentCodeEvents, [
+    "stableId",
+    "title",
+    "createdAtMs",
+    "threadLabel",
+    "diffAvailable",
+    "diffSource",
+    "diffAddedLines",
+    "diffRemovedLines",
+    "previousFileRefs",
+    "cwd",
+  ]);
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
   if (changed) {
@@ -3345,9 +3369,11 @@ function recordHistoryItem({ config, runtime, state, item }) {
     [normalized, ...runtime.recentHistoryItems.filter((entry) => entry.stableId !== normalized.stableId)],
     config.maxHistoryItems
   );
-  const changed =
-    JSON.stringify(nextItems.map((entry) => [entry.stableId, entry.title, entry.createdAtMs])) !==
-    JSON.stringify(runtime.recentHistoryItems.map((entry) => [entry.stableId, entry.title, entry.createdAtMs]));
+  const changed = timelineProjectionChanged(nextItems, runtime.recentHistoryItems, [
+    "stableId",
+    "title",
+    "createdAtMs",
+  ]);
   runtime.recentHistoryItems = nextItems;
   state.recentHistoryItems = nextItems;
   return changed;
@@ -3776,7 +3802,7 @@ async function scanOnce({ config, runtime, state }) {
   if (config.webUiEnabled) {
     let claudeTranscriptChanged = false;
     if (now - runtime.lastClaudeScanAt >= config.directoryScanIntervalMs) {
-      runtime.claudeKnownFiles = await listClaudeTranscriptFiles(config.claudeProjectsDir);
+      runtime.claudeKnownFiles = await listClaudeTranscriptFiles(config.claudeProjectsDir, config.claudeTranscriptMaxAgeMs);
       runtime.lastClaudeScanAt = now;
     }
     let claudeSessionTitlesChanged = false;
@@ -4114,7 +4140,16 @@ async function refreshClaudeSessionTitles(runtime) {
   return changed;
 }
 
-async function listClaudeTranscriptFiles(claudeProjectsDir) {
+async function listClaudeTranscriptFiles(claudeProjectsDir, maxAgeMs = 0) {
+  // ~/.claude/projects can accumulate thousands of .jsonl files (one per
+  // session, never garbage-collected by Claude Code itself). Returning all of
+  // them means processClaudeTranscriptFile fs.stat()s each every poll
+  // iteration — for a long-time user that's 3000+ stats every 2.5 s, all but
+  // a handful of which are guaranteed-cold. Filter by mtime here so the
+  // per-iteration working set tracks "active sessions", not "total sessions
+  // ever". maxAgeMs=0 disables filtering for callers who explicitly want
+  // everything (none in the bridge today).
+  const cutoffMs = maxAgeMs > 0 ? Date.now() - maxAgeMs : 0;
   try {
     const result = [];
     const entries = await fs.readdir(claudeProjectsDir, { withFileTypes: true });
@@ -4125,7 +4160,17 @@ async function listClaudeTranscriptFiles(claudeProjectsDir) {
         const files = await fs.readdir(projectPath, { withFileTypes: true });
         for (const file of files) {
           if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
-          result.push(path.join(projectPath, file.name));
+          const fullPath = path.join(projectPath, file.name);
+          if (cutoffMs > 0) {
+            try {
+              const stat = await fs.stat(fullPath);
+              if (stat.mtimeMs < cutoffMs) continue;
+            } catch {
+              // skip unreadable file (vanished or permissioned out)
+              continue;
+            }
+          }
+          result.push(fullPath);
         }
       } catch {
         // skip unreadable project dirs
@@ -5669,6 +5714,12 @@ async function processScannedEvent({ config, runtime, state, event }) {
     return false;
   }
 
+  if (shouldSuppressInternalScannedEvent(event)) {
+    state.seenEvents[event.id] = event.timestampMs || Date.now();
+    trimSeenEvents(state.seenEvents, config.maxSeenEvents);
+    return true;
+  }
+
   let dirty = false;
 
   if (event.kind === "task_complete") {
@@ -6528,6 +6579,150 @@ async function createNativeApproval({ config, runtime, conversationId, request,
   };
 }
 
+function createX402PaymentApproval({ config, body, now = Date.now() }) {
+  const payment = normalizeX402PaymentApprovalBody(body);
+  if (!payment) {
+    return null;
+  }
+  const token = crypto.randomBytes(18).toString("hex");
+  const requestId = cleanText(body.paymentRequestId || body.requestId || crypto.randomUUID());
+  const requestKey = `payment:${requestId}`;
+  const title = payment.amountUsdc
+    ? `Payment approval — ${payment.amountUsdc} USDC`
+    : "Payment approval";
+  return {
+    token,
+    requestKey,
+    conversationId: "payments",
+    requestId,
+    ownerClientId: null,
+    kind: "payment",
+    threadLabel: "x402 payment",
+    title,
+    messageText: formatX402PaymentApprovalMessage(payment),
+    reviewUrl: `${config.nativeApprovalPublicBaseUrl}/native-approvals/${token}`,
+    rawParams: payment,
+    cwd: "",
+    workspaceRoot: "",
+    fileRefs: [],
+    diffText: "",
+    diffAvailable: false,
+    diffSource: "",
+    diffAddedLines: 0,
+    diffRemovedLines: 0,
+    createdAtMs: now,
+    resolved: false,
+    resolving: false,
+    resolveClaudeWaiter: null,
+    provider: "viveworker",
+  };
+}
+
+
+function createHazbaseWalletPaymentApproval({ config, body, now = Date.now() }) {
+  const payment = normalizeX402PaymentApprovalBody(body);
+  if (!payment) return null;
+  const paymentRequestId = cleanText(body.paymentRequestId || body.requestId || "");
+  if (!/^[a-zA-Z0-9:_-]{8,160}$/u.test(paymentRequestId)) return null;
+  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";
+  return {
+    token,
+    requestKey,
+    conversationId: "payments",
+    requestId: paymentRequestId,
+    paymentRequestId,
+    ownerClientId: null,
+    kind: "hazbase_wallet_payment",
+    threadLabel: "x402 payment",
+    title,
+    messageText: formatHazbaseWalletPaymentApprovalMessage(payment),
+    reviewUrl: `${config.nativeApprovalPublicBaseUrl}/native-approvals/${token}`,
+    rawParams: payment,
+    cwd: "",
+    workspaceRoot: "",
+    fileRefs: [],
+    diffText: "",
+    diffAvailable: false,
+    diffSource: "",
+    diffAddedLines: 0,
+    diffRemovedLines: 0,
+    createdAtMs: now,
+    resolved: false,
+    resolving: false,
+    resolveClaudeWaiter: null,
+    provider: "viveworker",
+  };
+}
+
+function formatHazbaseWalletPaymentApprovalMessage(payment) {
+  const lines = [
+    "Hazbase Smart Wallet payment requested.",
+    "",
+    `Amount: ${payment.amountUsdc || payment.amountAtomic} USDC`,
+    `Network: ${payment.network} (chainId ${payment.chainId})`,
+    `Pay to: ${payment.payTo}`,
+    `Asset: ${payment.asset}`,
+    `Resource: ${payment.resource}`,
+    "",
+    "Approving will ask for your passkey, then hazBase will submit a gasless Smart Wallet payment.",
+  ];
+  if (payment.description) lines.splice(7, 0, `Description: ${payment.description}`);
+  if (payment.url && payment.url !== payment.resource) lines.splice(-1, 0, `URL: ${payment.url}`);
+  return lines.join("\n");
+}
+
+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 amountAtomic = cleanText(payment.amountAtomic || "");
+  const amountUsdc = cleanText(payment.amountUsdc || "");
+  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) {
+    return null;
+  }
+  return {
+    url,
+    network,
+    chainId,
+    amountAtomic,
+    amountUsdc,
+    payTo,
+    asset,
+    resource,
+    description,
+  };
+}
+
+function formatX402PaymentApprovalMessage(payment) {
+  const lines = [
+    "x402 payment approval requested.",
+    "",
+    `Amount: ${payment.amountUsdc || payment.amountAtomic} USDC`,
+    `Network: ${payment.network} (chainId ${payment.chainId})`,
+    `Pay to: ${payment.payTo}`,
+    `Asset: ${payment.asset}`,
+    `Resource: ${payment.resource}`,
+  ];
+  if (payment.description) {
+    lines.push(`Description: ${payment.description}`);
+  }
+  if (payment.url && payment.url !== payment.resource) {
+    lines.push(`URL: ${payment.url}`);
+  }
+  lines.push("", "Approve only if the amount, recipient, network, and resource match what you expect.");
+  return lines.join("\n");
+}
+
 async function buildNativeApprovalPayload({ config, runtime, conversationId, request, token }) {
   const kind = nativeApprovalKind(request.method);
   if (!kind) {
@@ -8767,6 +8962,18 @@ function isHiddenClaudeInternalScoringText(text) {
   return /^You are scoring Moltbook posts? for an AI agent\b/iu.test(single);
 }
 
+function isHiddenCodexApprovalAssessmentText(text) {
+  const single = cleanText(stripNotificationMarkup(stripEnvironmentContextBlocks(text || "")));
+  if (!single) {
+    return false;
+  }
+  return /\bThe following is the Codex agent history(?: added since your last approval assessment)?\b/iu.test(single);
+}
+
+function shouldHideInternalTimelineItem(item) {
+  return shouldHideClaudeInternalItem(item) || shouldHideCodexInternalApprovalItem(item);
+}
+
 function shouldHideClaudeInternalItem(item) {
   if (!isPlainObject(item)) {
     return false;
@@ -8786,6 +8993,48 @@ function shouldHideClaudeInternalItem(item) {
   );
 }
 
+function shouldSuppressInternalScannedEvent(event) {
+  if (!isPlainObject(event)) {
+    return false;
+  }
+  const provider = normalizeProvider(event.provider || "codex");
+  if (provider !== "codex") {
+    return false;
+  }
+
+  return shouldHideCodexInternalApprovalItem({
+    provider,
+    kind: cleanText(event.kind || ""),
+    title: event.title,
+    threadLabel: event.threadLabel,
+    summary: event.summary ?? event.message,
+    messageText: event.messageText ?? event.detailText ?? event.message,
+    detailText: event.detailText,
+    message: event.message,
+  });
+}
+
+function shouldHideCodexInternalApprovalItem(item) {
+  if (!isPlainObject(item)) {
+    return false;
+  }
+  if (normalizeProvider(item.provider) !== "codex") {
+    return false;
+  }
+
+  const title = cleanText(item.title ?? "");
+  const threadLabel = cleanText(item.threadLabel ?? "");
+  if (isHiddenCodexApprovalAssessmentText(title) || isHiddenCodexApprovalAssessmentText(threadLabel)) {
+    return true;
+  }
+  return (
+    isHiddenCodexApprovalAssessmentText(item.messageText) ||
+    isHiddenCodexApprovalAssessmentText(item.summary) ||
+    isHiddenCodexApprovalAssessmentText(item.detailText) ||
+    isHiddenCodexApprovalAssessmentText(item.message)
+  );
+}
+
 function threadStateArchiveStatus(threadState) {
   if (!isPlainObject(threadState)) {
     return "";
@@ -10499,7 +10748,9 @@ function buildPendingInboxItems(runtime, state, config, locale) {
       token: approval.token,
       threadId: cleanText(approval.conversationId || ""),
       threadLabel: approval.threadLabel || "",
-      title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
+      title: cleanText(approval.kind || "") === "payment"
+        ? cleanText(approval.title || "") || formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel)
+        : formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
       summary: formatNotificationBody(approval.messageText, 100) || approval.messageText,
       primaryLabel: t(locale, "server.action.review"),
       createdAtMs: Number(approval.createdAtMs) || now,
@@ -10851,7 +11102,9 @@ function buildOperationalTimelineEntries(runtime, state, config, locale) {
         kind: "approval",
         threadId: cleanText(approval.conversationId || ""),
         threadLabel: approval.threadLabel,
-        title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
+        title: cleanText(approval.kind || "") === "payment"
+          ? cleanText(approval.title || "") || formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel)
+          : formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
         summary: formatNotificationBody(approval.messageText, 180) || approval.messageText,
         messageText: approval.messageText,
         outcome: "pending",
@@ -11058,7 +11311,9 @@ function buildPendingApprovalDetail(runtime, state, approval, locale) {
     approvalKind,
     provider: normalizeProvider(approval.provider),
     token: approval.token,
-    title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
+    title: approvalKind === "payment"
+      ? cleanText(approval.title || "") || formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel)
+      : formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
     threadLabel: approval.threadLabel || "",
     createdAtMs: Number(approval.createdAtMs) || 0,
     messageHtml: renderMessageHtml(approval.messageText, `<p>${escapeHtml(t(locale, "detail.approvalRequested"))}</p>`),
@@ -11073,10 +11328,15 @@ function buildPendingApprovalDetail(runtime, state, approval, locale) {
     readOnly: approval.readOnly === true,
     actions: approval.readOnly === true
       ? []
-      : [
-          { label: t(locale, "server.action.approve"), tone: "primary", url: `/api/items/approval/${encodeURIComponent(approval.token)}/accept`, body: {} },
-          { label: t(locale, "server.action.reject"), tone: "danger", url: `/api/items/approval/${encodeURIComponent(approval.token)}/decline`, body: {} },
-        ],
+      : approvalKind === "hazbase_wallet_payment"
+        ? [
+            { label: t(locale, "server.action.payWithWallet"), tone: "primary", url: `/api/payments/x402/hazbase-wallet/${encodeURIComponent(approval.token)}/pay`, body: { hazbaseReauth: true } },
+            { label: t(locale, "server.action.reject"), tone: "danger", url: `/api/items/approval/${encodeURIComponent(approval.token)}/decline`, body: {} },
+          ]
+        : [
+            { label: t(locale, "server.action.approve"), tone: "primary", url: `/api/items/approval/${encodeURIComponent(approval.token)}/accept`, body: {} },
+            { label: t(locale, "server.action.reject"), tone: "danger", url: `/api/items/approval/${encodeURIComponent(approval.token)}/decline`, body: {} },
+          ],
   };
   if (approvalKind === "plan") {
     const planText = String(approval.planText || "");
@@ -13258,9 +13518,93 @@ function buildWebAppHtml({ pairToken }) {
     <link rel="apple-touch-icon" href="/icons/apple-touch-icon.png">
     <link rel="icon" type="image/png" sizes="192x192" href="/icons/viveworker-icon-192.png">
     <link rel="stylesheet" href="/app.css">
+    <style>
+      .boot-splash {
+        position: fixed;
+        inset: 0;
+        z-index: 9999;
+        display: grid;
+        place-items: center;
+        padding: max(1.2rem, env(safe-area-inset-top)) 1rem max(1.2rem, env(safe-area-inset-bottom));
+        color: #f5fbff;
+        background:
+          radial-gradient(circle at 50% 18%, rgba(47, 143, 103, 0.22), transparent 30%),
+          radial-gradient(circle at 78% 78%, rgba(79, 131, 216, 0.14), transparent 28%),
+          linear-gradient(180deg, #081015 0%, #091015 100%);
+        transition: opacity 220ms ease, visibility 220ms ease;
+      }
+      .boot-splash__card {
+        width: min(20rem, 82vw);
+        display: grid;
+        justify-items: center;
+        gap: 0.9rem;
+        text-align: center;
+      }
+      .boot-splash__logo {
+        width: clamp(5.4rem, 28vw, 7rem);
+        height: clamp(5.4rem, 28vw, 7rem);
+        border-radius: 28%;
+        background:
+          radial-gradient(circle at 76% 24%, rgba(125, 211, 252, 0.22), transparent 30%),
+          linear-gradient(180deg, rgba(23, 52, 72, 0.96), rgba(9, 17, 23, 0.96));
+        box-shadow: 0 24px 60px rgba(0, 0, 0, 0.32);
+      }
+      .boot-splash__title {
+        margin: 0.25rem 0 0;
+        font-family: "Avenir Next", "SF Pro Rounded", "SF Pro Text", "Helvetica Neue", sans-serif;
+        font-size: clamp(1.65rem, 8vw, 2.4rem);
+        line-height: 1;
+        letter-spacing: -0.04em;
+      }
+      .boot-splash__status {
+        margin: 0;
+        color: rgba(205, 220, 231, 0.72);
+        font-family: "Avenir Next", "SF Pro Rounded", "SF Pro Text", "Helvetica Neue", sans-serif;
+        font-size: 0.9rem;
+        letter-spacing: 0.02em;
+      }
+      .boot-splash__dots {
+        display: inline-grid;
+        grid-auto-flow: column;
+        gap: 0.34rem;
+        margin-top: 0.15rem;
+      }
+      .boot-splash__dots span {
+        width: 0.42rem;
+        height: 0.42rem;
+        border-radius: 999px;
+        background: rgba(142, 215, 255, 0.88);
+        animation: viveworker-boot-dot 980ms ease-in-out infinite;
+      }
+      .boot-splash__dots span:nth-child(2) { animation-delay: 140ms; }
+      .boot-splash__dots span:nth-child(3) { animation-delay: 280ms; }
+      .viveworker-ready .boot-splash {
+        opacity: 0;
+        visibility: hidden;
+      }
+      @keyframes viveworker-boot-dot {
+        0%, 80%, 100% { transform: translateY(0); opacity: 0.42; }
+        40% { transform: translateY(-0.28rem); opacity: 1; }
+      }
+      @media (prefers-reduced-motion: reduce) {
+        .boot-splash,
+        .boot-splash__dots span {
+          transition: none;
+          animation: none;
+        }
+      }
+    </style>
     <title>viveworker</title>
   </head>
   <body>
+    <div id="boot-splash" class="boot-splash" role="status" aria-live="polite" aria-label="viveworker is starting">
+      <div class="boot-splash__card">
+        <img class="boot-splash__logo" src="/icons/viveworker-v-pulse.svg" alt="" width="112" height="112" decoding="async">
+        <h1 class="boot-splash__title">viveworker</h1>
+        <p class="boot-splash__status">Starting</p>
+        <span class="boot-splash__dots" aria-hidden="true"><span></span><span></span><span></span></span>
+      </div>
+    </div>
     <div id="app"></div>
     <script type="module" src="/app.js"></script>
   </body>
@@ -13472,6 +13816,12 @@ function createNativeApprovalServer({ config, runtime, state }) {
         return writeJson(res, 200, buildSessionPayload({ config, state, session }));
       }
 
+      if (url.pathname === "/api/version/status" && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) return;
+        return writeJson(res, 200, await getNpmVersionStatus(runtime, config));
+      }
+
       // Collapses the PWA's boot-time fan-out (session + inbox + timeline
       // + devices) into a single HTTPS round-trip. iOS Safari tears down
       // connections aggressively, so each parallel fetch pays its own
@@ -13929,10 +14279,15 @@ if (url.pathname === "/api/hazbase/status" && req.method === "GET") {
     8453: resolveHazbaseAccountForChain(hazbase.accounts, 8453)?.smartAccountAddress || "",
     84532: resolveHazbaseAccountForChain(hazbase.accounts, 84532)?.smartAccountAddress || "",
   };
+  const signedIn = Boolean(hazbase.accessToken) && !hazbase.sessionInvalid;
   return writeJson(res, 200, {
     enabled: true,
     apiUrl: config.hazbaseApiUrl,
-    signedIn: Boolean(hazbase.accessToken),
+    signedIn,
+    sessionStatus: hazbase.sessionInvalid ? "expired" : signedIn ? "signed_in" : "signed_out",
+    sessionInvalid: hazbase.sessionInvalid,
+    sessionInvalidReason: hazbase.sessionInvalidReason,
+    sessionInvalidAt: hazbase.sessionInvalidAt,
     email: hazbase.email,
     userId: hazbase.userId,
     sessionId: hazbase.sessionId,
@@ -13995,15 +14350,19 @@ if (url.pathname === "/api/hazbase/verify-otp" && req.method === "POST") {
   const code = cleanText(body?.code || "");
   if (!email || !code) return writeJson(res, 400, { error: "otp-required" });
   const result = await verifyHazbaseEmailOtp({ email, code });
+  const previousHazbase = normalizeHazbaseState(state.hazbase);
   state.hazbase = {
-    ...normalizeHazbaseState(state.hazbase),
+    ...previousHazbase,
     email: result.email || email,
     accessToken: cleanText(result.accessToken || ""),
     sessionId: cleanText(result.sessionId || ""),
     userId: cleanText(result.userId || ""),
-    accounts: Array.isArray(result.accounts) ? result.accounts : [],
+    accounts: mergeHazbaseAccountSummaries(previousHazbase.accounts, Array.isArray(result.accounts) ? result.accounts : []),
     highTrustToken: "",
     highTrustExpiresAt: "",
+    sessionInvalid: false,
+    sessionInvalidReason: "",
+    sessionInvalidAt: "",
   };
   await saveState(config.stateFile, state);
   return writeJson(res, 200, result);
@@ -14024,11 +14383,17 @@ if (url.pathname === "/api/hazbase/passkey/register/challenge" && req.method ===
       message: error?.message || "Open viveworker on its .local hostname to use hazBase passkeys.",
     });
   }
-  const result = await requestPasskeyRegistrationChallenge({
-    emailSession: hazbase.accessToken,
-    deviceLabel: cleanText(body?.deviceLabel || config.hazbaseDeviceLabel || "") || undefined,
-    partnerOrigin,
-  });
+  let result;
+  try {
+    result = await requestPasskeyRegistrationChallenge({
+      emailSession: hazbase.accessToken,
+      deviceLabel: cleanText(body?.deviceLabel || config.hazbaseDeviceLabel || "") || undefined,
+      partnerOrigin,
+    });
+  } catch (error) {
+    if (await maybeWriteHazbaseSessionExpiredResponse({ error, config, state, res })) return;
+    throw error;
+  }
   return writeJson(res, 200, result);
 }
 
@@ -14038,16 +14403,25 @@ if (url.pathname === "/api/hazbase/passkey/register/complete" && req.method ===
   const hazbase = normalizeHazbaseState(state.hazbase);
   if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
   const body = await parseJsonBody(req);
-  const result = await completePasskeyRegistration({
-    emailSession: hazbase.accessToken,
-    challengeId: cleanText(body?.challengeId || ""),
-    credential: body?.credential,
-    deviceLabel: cleanText(body?.deviceLabel || config.hazbaseDeviceLabel || "") || undefined,
-  });
+  let result;
+  try {
+    result = await completePasskeyRegistration({
+      emailSession: hazbase.accessToken,
+      challengeId: cleanText(body?.challengeId || ""),
+      credential: body?.credential,
+      deviceLabel: cleanText(body?.deviceLabel || config.hazbaseDeviceLabel || "") || undefined,
+    });
+  } catch (error) {
+    if (await maybeWriteHazbaseSessionExpiredResponse({ error, config, state, res })) return;
+    throw error;
+  }
   state.hazbase = {
     ...hazbase,
     deviceBindingId: cleanText(result.deviceBindingId || hazbase.deviceBindingId || ""),
     credentialId: cleanText(result.credentialId || hazbase.credentialId || ""),
+    sessionInvalid: false,
+    sessionInvalidReason: "",
+    sessionInvalidAt: "",
   };
   await saveState(config.stateFile, state);
   return writeJson(res, 200, result);
@@ -14068,12 +14442,18 @@ if (url.pathname === "/api/hazbase/passkey/assert/challenge" && req.method === "
       message: error?.message || "Open viveworker on its .local hostname to use hazBase passkeys.",
     });
   }
-  const result = await requestPasskeyAssertionChallenge({
-    emailSession: hazbase.accessToken,
-    purpose: cleanText(body?.purpose || "bootstrap") || "bootstrap",
-    deviceBindingId: hazbase.deviceBindingId || undefined,
-    partnerOrigin,
-  });
+  let result;
+  try {
+    result = await requestPasskeyAssertionChallenge({
+      emailSession: hazbase.accessToken,
+      purpose: cleanText(body?.purpose || "bootstrap") || "bootstrap",
+      deviceBindingId: hazbase.deviceBindingId || undefined,
+      partnerOrigin,
+    });
+  } catch (error) {
+    if (await maybeWriteHazbaseSessionExpiredResponse({ error, config, state, res })) return;
+    throw error;
+  }
   return writeJson(res, 200, result);
 }
 
@@ -14083,19 +14463,28 @@ if (url.pathname === "/api/hazbase/passkey/assert/complete" && req.method === "P
   const hazbase = normalizeHazbaseState(state.hazbase);
   if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
   const body = await parseJsonBody(req);
-  const result = await completePasskeyAssertion({
-    emailSession: hazbase.accessToken,
-    challengeId: cleanText(body?.challengeId || ""),
-    credential: body?.credential,
-    purpose: cleanText(body?.purpose || "bootstrap") || "bootstrap",
-    deviceBindingId: hazbase.deviceBindingId || undefined,
-  });
+  let result;
+  try {
+    result = await completePasskeyAssertion({
+      emailSession: hazbase.accessToken,
+      challengeId: cleanText(body?.challengeId || ""),
+      credential: body?.credential,
+      purpose: cleanText(body?.purpose || "bootstrap") || "bootstrap",
+      deviceBindingId: hazbase.deviceBindingId || undefined,
+    });
+  } catch (error) {
+    if (await maybeWriteHazbaseSessionExpiredResponse({ error, config, state, res })) return;
+    throw error;
+  }
   state.hazbase = {
     ...hazbase,
     deviceBindingId: cleanText(result.deviceBindingId || hazbase.deviceBindingId || ""),
     credentialId: cleanText(result.credentialId || hazbase.credentialId || ""),
     highTrustToken: cleanText(result.highTrustToken || ""),
     highTrustExpiresAt: cleanText(result.highTrustExpiresAt || ""),
+    sessionInvalid: false,
+    sessionInvalidReason: "",
+    sessionInvalidAt: "",
   };
   await saveState(config.stateFile, state);
   return writeJson(res, 200, result);
@@ -14113,12 +14502,18 @@ if (url.pathname === "/api/hazbase/account/bootstrap" && req.method === "POST")
   if (chainId !== 8453 && chainId !== 84532) {
     return writeJson(res, 400, { error: "unsupported-chain" });
   }
-  const result = await bootstrapPasskeyAccount({
-    emailSession: hazbase.accessToken,
-    deviceBindingId: hazbase.deviceBindingId,
-    highTrustToken: hazbase.highTrustToken,
-    chainId,
-  });
+  let result;
+  try {
+    result = await bootstrapPasskeyAccount({
+      emailSession: hazbase.accessToken,
+      deviceBindingId: hazbase.deviceBindingId,
+      highTrustToken: hazbase.highTrustToken,
+      chainId,
+    });
+  } catch (error) {
+    if (await maybeWriteHazbaseSessionExpiredResponse({ error, config, state, res })) return;
+    throw error;
+  }
   const nextAccounts = mergeHazbaseAccountSummaries(hazbase.accounts, [{
     smartAccountAddress: result.smartAccountAddress,
     chainId: result.chainId,
@@ -14129,11 +14524,29 @@ if (url.pathname === "/api/hazbase/account/bootstrap" && req.method === "POST")
   state.hazbase = {
     ...hazbase,
     accounts: nextAccounts,
+    sessionInvalid: false,
+    sessionInvalidReason: "",
+    sessionInvalidAt: "",
   };
   await saveState(config.stateFile, state);
   return writeJson(res, 200, result);
 }
 
+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;
+  if (!hookAuth) {
+    const session = requireMutatingApiSession(req, res, config, state);
+    if (!session) return;
+  }
+  markHazbaseSessionInvalid(state, "manual_refresh_requested");
+  await saveState(config.stateFile, state);
+  return writeJson(res, 200, {
+    ok: true,
+    status: "session_refresh_required",
+  });
+}
+
 if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
   const session = requireMutatingApiSession(req, res, config, state);
   if (!session) return;
@@ -14656,6 +15069,168 @@ 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) {
+          return writeJson(res, 401, { error: "unauthorized" });
+        }
+
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+
+        const approval = createHazbaseWalletPaymentApproval({ config, body });
+        if (!approval) {
+          return writeJson(res, 400, { error: "invalid-hazbase-wallet-payment-request" });
+        }
+        if (runtime.nativeApprovalsByRequestKey.has(approval.requestKey)) {
+          return writeJson(res, 409, { error: "hazbase-wallet-payment-already-pending" });
+        }
+
+        runtime.nativeApprovalsByToken.set(approval.token, approval);
+        runtime.nativeApprovalsByRequestKey.set(approval.requestKey, approval);
+
+        deliverWebPushItem({
+          config,
+          state,
+          kind: "approval",
+          tab: "inbox",
+          subtab: "pending",
+          token: approval.token,
+          stableId: pendingApprovalStableId(approval),
+          title: approval.title,
+          body: approval.messageText,
+          buildLocalizedContent: () => ({ title: approval.title, body: approval.messageText }),
+        }).catch((error) => {
+          console.error(`[hazbase-wallet-payment-push] ${approval.requestKey} | ${error.message}`);
+        });
+
+        const waitMs = Math.max(10_000, Math.min(900_000, Number(body.timeoutMs) || 600_000));
+        const decisionPromise = new Promise((resolve) => {
+          approval.resolveClaudeWaiter = resolve;
+        });
+        const timeoutPromise = new Promise((resolve) => {
+          setTimeout(() => resolve({ paid: false, decision: "timeout", error: "hazbase-wallet-payment-timeout" }), waitMs);
+        });
+        const decision = await Promise.race([decisionPromise, timeoutPromise]);
+
+        if (!approval.resolved) {
+          approval.resolved = true;
+          approval.resolving = false;
+          runtime.nativeApprovalsByToken.delete(approval.token);
+          runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+        }
+
+        if (decision && typeof decision === "object" && decision.paid === true) {
+          return writeJson(res, 200, decision);
+        }
+        const error = decision?.error || decision?.decision || "hazbase-wallet-payment-declined";
+        const statusCode = error === "hazbase-wallet-payment-timeout" ? 408 : 403;
+        return writeJson(res, statusCode, { paid: false, error, decision: decision?.decision || "decline" });
+      }
+
+      const hazbaseWalletPayMatch = url.pathname.match(/^\/api\/payments\/x402\/hazbase-wallet\/([a-f0-9]+)\/pay$/u);
+      if (hazbaseWalletPayMatch && req.method === "POST") {
+        const session = requireMutatingApiSession(req, res, config, state);
+        if (!session) return;
+        const token = hazbaseWalletPayMatch[1];
+        const approval = runtime.nativeApprovalsByToken.get(token);
+        if (!approval || approval.kind !== "hazbase_wallet_payment") {
+          return writeJson(res, 404, { error: "approval-not-found" });
+        }
+        if (approval.resolved || approval.resolving) {
+          return writeJson(res, 409, { error: "approval-already-handled" });
+        }
+        approval.resolving = true;
+        try {
+          const result = await completeHazbaseWalletPaymentApproval({ config, runtime, state, approval });
+          return writeJson(res, 200, result);
+        } catch (error) {
+          const failure = await finalizeHazbaseWalletPaymentFailure({ config, runtime, state, approval, error });
+          console.error(`[hazbase-wallet-payment-error] ${approval.requestKey} | ${error?.stack || error?.message || error}`);
+          return writeJson(res, Number(error?.statusCode) || 500, {
+            error: failure.error,
+            approvalFinalized: true,
+            retryable: true,
+          });
+        }
+      }
+
+      if (url.pathname === "/api/payments/x402/approval" && req.method === "POST") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+          return writeJson(res, 401, { error: "unauthorized" });
+        }
+
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+
+        const approval = createX402PaymentApproval({ config, body });
+        if (!approval) {
+          return writeJson(res, 400, { error: "invalid-payment-approval-request" });
+        }
+        if (runtime.nativeApprovalsByRequestKey.has(approval.requestKey)) {
+          return writeJson(res, 409, { error: "payment-approval-already-pending" });
+        }
+
+        runtime.nativeApprovalsByToken.set(approval.token, approval);
+        runtime.nativeApprovalsByRequestKey.set(approval.requestKey, approval);
+
+        deliverWebPushItem({
+          config,
+          state,
+          kind: "approval",
+          tab: "inbox",
+          subtab: "pending",
+          token: approval.token,
+          stableId: pendingApprovalStableId(approval),
+          title: approval.title,
+          body: approval.messageText,
+          buildLocalizedContent: () => ({
+            title: approval.title,
+            body: approval.messageText,
+          }),
+        }).catch((error) => {
+          console.error(`[payment-approval-push] ${approval.requestKey} | ${error.message}`);
+        });
+
+        const waitMs = Math.max(10_000, Math.min(900_000, Number(body.timeoutMs) || 600_000));
+        const decisionPromise = new Promise((resolve) => {
+          approval.resolveClaudeWaiter = resolve;
+        });
+        const timeoutPromise = new Promise((resolve) => {
+          setTimeout(() => resolve("timeout"), waitMs);
+        });
+        const decision = await Promise.race([decisionPromise, timeoutPromise]);
+
+        if (!approval.resolved) {
+          approval.resolved = true;
+          approval.resolving = false;
+          runtime.nativeApprovalsByToken.delete(approval.token);
+          runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+        }
+
+        if (decision === "accept") {
+          return writeJson(res, 200, {
+            approved: true,
+            decision,
+            approvedPayment: approval.rawParams,
+          });
+        }
+        if (decision === "timeout") {
+          return writeJson(res, 408, { approved: false, decision, error: "payment-approval-timeout" });
+        }
+        return writeJson(res, 403, { approved: false, decision: "decline", error: "payment-approval-declined" });
+      }
+
       if (url.pathname === "/api/providers/claude/events" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
         if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
@@ -15473,6 +16048,10 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         if (approval.resolved || approval.resolving) {
           return writeJson(res, 409, { error: "approval-already-handled" });
         }
+        if (approval.kind === "hazbase_wallet_payment" && decision !== "decline") {
+          console.warn(`[hazbase-wallet-payment-generic-decision-blocked] ${approval.requestKey} | ${decision}`);
+          return writeJson(res, 409, { error: "hazbase-wallet-payment-requires-wallet-pay-route" });
+        }
 
         approval.resolving = true;
         try {
@@ -15483,6 +16062,10 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           return writeJson(res, 200, { ok: true, decision });
         } catch (error) {
           approval.resolving = false;
+          if (res.headersSent || res.writableEnded) {
+            console.error(`[approval-decision-post-write-error] ${approval.requestKey} | ${error.message}`);
+            return;
+          }
           return writeJson(res, 500, { error: error.message });
         }
       }
@@ -16067,6 +16650,21 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
       if (approval.resolved || approval.resolving) {
         return writeApprovalHandled(res, req, approval.title, 409, config.defaultLocale);
       }
+      if (approval.kind === "hazbase_wallet_payment" && decision !== "decline") {
+        console.warn(`[hazbase-wallet-payment-native-decision-blocked] ${approval.requestKey} | ${decision}`);
+        if (requestWantsHtml(req)) {
+          return writeHtml(
+            res,
+            409,
+            renderStatusPage({
+              title: approval.title,
+              body: "This approval must be completed from the viveworker app with the wallet payment button.",
+              tone: "warn",
+            })
+          );
+        }
+        return writeJson(res, 409, { error: "hazbase-wallet-payment-requires-wallet-pay-route" });
+      }
 
       approval.resolving = true;
       try {
@@ -16091,6 +16689,10 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         });
       } catch (error) {
         approval.resolving = false;
+        if (res.headersSent || res.writableEnded) {
+          console.error(`[native-approval-decision-post-write-error] ${approval.requestKey} | ${error.message}`);
+          return;
+        }
         if (requestWantsHtml(req)) {
           return writeHtml(
             res,
@@ -16105,6 +16707,9 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         return writeJson(res, 500, { error: error.message });
       }
     } catch (error) {
+      if (res.headersSent || res.writableEnded) {
+        return;
+      }
       if (requestWantsHtml(req)) {
         return writeHtml(
           res,
@@ -17453,6 +18058,9 @@ function buildConfig(cli) {
     hazbaseApiUrl: stripTrailingSlash(process.env.HAZBASE_API_URL || "https://api.hazbase.com"),
     hazbaseClientKey: cleanText(process.env.HAZBASE_CLIENT_KEY || "viveworker-internal"),
     hazbaseDeviceLabel: cleanText(process.env.HAZBASE_DEVICE_LABEL || "viveworker"),
+    npmPackageName: cleanText(process.env.VIVEWORKER_NPM_PACKAGE || "viveworker"),
+    npmDistTag: cleanText(process.env.VIVEWORKER_NPM_DIST_TAG || "latest"),
+    npmRegistryUrl: stripTrailingSlash(process.env.NPM_REGISTRY_URL || "https://registry.npmjs.org"),
     webUiEnabled: boolEnv("WEB_UI_ENABLED", true),
     authRequired: boolEnv("AUTH_REQUIRED", true),
     webPushEnabled: boolEnv("WEB_PUSH_ENABLED", false),
@@ -17498,6 +18106,12 @@ function buildConfig(cli) {
     maxCodeEvents: numberEnv("MAX_CODE_EVENTS", 1000),
     maxTimelineThreads: numberEnv("MAX_TIMELINE_THREADS", 20),
     maxReadBytes: numberEnv("MAX_READ_BYTES", 2 * 1024 * 1024),
+    // Cap how far back the bridge looks for Claude transcripts. Default 7 days
+    // covers a long pause without dragging the long tail of dead sessions
+    // (which can easily reach thousands of files) into the per-iteration
+    // stat loop. Set to 0 to disable filtering and scan everything (the
+    // legacy behavior).
+    claudeTranscriptMaxAgeMs: numberEnv("CLAUDE_TRANSCRIPT_MAX_AGE_DAYS", 7) * 24 * 60 * 60 * 1000,
     maxMessageChars: numberEnv("MAX_MESSAGE_CHARS", 320),
     maxCommandChars: numberEnv("MAX_COMMAND_CHARS", 220),
     maxJustificationChars: numberEnv("MAX_JUSTIFICATION_CHARS", 220),
@@ -17541,21 +18155,92 @@ function buildConfig(cli) {
 }
 
 
+function inferHazbaseDeviceBindingIdFromAccounts(accounts) {
+  const list = Array.isArray(accounts) ? accounts : [];
+  for (const entry of list) {
+    const deviceBindingId = cleanText(
+      entry?.primaryDeviceBindingId || entry?.deviceBindingId || entry?.ownerDeviceBindingId || ""
+    );
+    if (deviceBindingId) return deviceBindingId;
+  }
+  return "";
+}
+
 function normalizeHazbaseState(raw) {
   const value = raw && typeof raw === "object" ? raw : {};
+  const accounts = Array.isArray(value.accounts) ? value.accounts : [];
+  const deviceBindingId = cleanText(value.deviceBindingId ?? "") || inferHazbaseDeviceBindingIdFromAccounts(accounts);
   return {
     email: cleanText(value.email ?? ""),
     accessToken: cleanText(value.accessToken ?? ""),
     sessionId: cleanText(value.sessionId ?? ""),
     userId: cleanText(value.userId ?? ""),
-    deviceBindingId: cleanText(value.deviceBindingId ?? ""),
+    deviceBindingId,
     credentialId: cleanText(value.credentialId ?? ""),
     highTrustToken: cleanText(value.highTrustToken ?? ""),
     highTrustExpiresAt: cleanText(value.highTrustExpiresAt ?? ""),
-    accounts: Array.isArray(value.accounts) ? value.accounts : [],
+    accounts,
+    sessionInvalid: value.sessionInvalid === true,
+    sessionInvalidReason: cleanText(value.sessionInvalidReason ?? ""),
+    sessionInvalidAt: cleanText(value.sessionInvalidAt ?? ""),
   };
 }
 
+function isHazbaseInvalidAppSessionError(error) {
+  const details = error?.details && typeof error.details === "object" ? error.details : {};
+  const rawText = [
+    error?.code,
+    error?.message,
+    details.errorCode,
+    details.code,
+    details.error,
+    details.message,
+    typeof error?.details === "string" ? error.details : "",
+  ]
+    .map((entry) => cleanText(entry || ""))
+    .filter(Boolean)
+    .join(" ");
+  const statusCode = Number(error?.statusCode || error?.status || details.statusCode || 0) ||
+    (/statusCode["']?\s*[:=]\s*401/u.test(rawText) || /\b401\b/u.test(rawText) ? 401 : 0);
+  const text = [
+    rawText,
+  ]
+    .map((entry) => cleanText(entry || "").toLowerCase())
+    .filter(Boolean)
+    .join(" ");
+  return statusCode === 401 && (
+    text.includes("invalid app session") ||
+    text.includes("invalid_app_session")
+  );
+}
+
+function markHazbaseSessionInvalid(state, reason = "invalid_app_session") {
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  state.hazbase = {
+    ...hazbase,
+    accessToken: "",
+    sessionId: "",
+    highTrustToken: "",
+    highTrustExpiresAt: "",
+    sessionInvalid: true,
+    sessionInvalidReason: cleanText(reason || "invalid_app_session"),
+    sessionInvalidAt: new Date().toISOString(),
+  };
+  return state.hazbase;
+}
+
+async function maybeWriteHazbaseSessionExpiredResponse({ error, config, state, res }) {
+  if (!isHazbaseInvalidAppSessionError(error)) {
+    return false;
+  }
+  markHazbaseSessionInvalid(state);
+  await saveState(config.stateFile, state);
+  return writeJson(res, 401, {
+    error: "hazbase-session-expired",
+    message: "Hazbase wallet session expired. Sign in again from Wallet settings.",
+  });
+}
+
 function hazbasePasskeyLocalHostError() {
   const error = new Error("Open viveworker on its .local hostname to use hazBase passkeys.");
   error.code = "hazbase-passkey-local-host-required";
@@ -17627,6 +18312,117 @@ async function fetchHazbaseMetadata(config, endpoint, timeoutMs = HAZBASE_METADA
   }
 }
 
+async function getNpmVersionStatus(runtime, config) {
+  const now = Date.now();
+  const cached = runtime.npmVersionStatusCache;
+  if (cached && now - Number(cached.checkedAtMs || 0) < NPM_VERSION_CHECK_CACHE_TTL_MS) {
+    return cached;
+  }
+  if (runtime.npmVersionStatusPending) {
+    return runtime.npmVersionStatusPending;
+  }
+  runtime.npmVersionStatusPending = fetchNpmVersionStatus(config)
+    .then((status) => {
+      runtime.npmVersionStatusCache = status;
+      return status;
+    })
+    .catch((error) => {
+      const fallback = {
+        packageName: config.npmPackageName || "viveworker",
+        distTag: config.npmDistTag || "latest",
+        currentVersion: appPackageVersion,
+        latestVersion: "",
+        updateAvailable: false,
+        checkedAtMs: Date.now(),
+        error: cleanText(error?.message || "npm version check failed"),
+      };
+      runtime.npmVersionStatusCache = fallback;
+      return fallback;
+    })
+    .finally(() => {
+      runtime.npmVersionStatusPending = null;
+    });
+  return runtime.npmVersionStatusPending;
+}
+
+async function fetchNpmVersionStatus(config) {
+  const packageName = cleanText(config.npmPackageName || "viveworker") || "viveworker";
+  const distTag = cleanText(config.npmDistTag || "latest") || "latest";
+  const registryBaseUrl = stripTrailingSlash(config.npmRegistryUrl || "https://registry.npmjs.org");
+  const endpoint = `${registryBaseUrl}/${encodeURIComponent(packageName).replace(/^%40/u, "@")}/${encodeURIComponent(distTag)}`;
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), NPM_VERSION_CHECK_TIMEOUT_MS);
+  timer.unref?.();
+  try {
+    const response = await fetch(endpoint, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      throw new Error(`npm registry returned ${response.status}`);
+    }
+    const payload = await response.json().catch(() => null);
+    const latestVersion = cleanText(payload?.version || "");
+    if (!latestVersion) {
+      throw new Error("npm registry response did not include a version");
+    }
+    return {
+      packageName,
+      distTag,
+      currentVersion: appPackageVersion,
+      latestVersion,
+      updateAvailable: comparePackageVersions(latestVersion, appPackageVersion) > 0,
+      checkedAtMs: Date.now(),
+      error: "",
+    };
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      throw new Error("npm version check timed out");
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function comparePackageVersions(left, right) {
+  const a = parsePackageVersion(left);
+  const b = parsePackageVersion(right);
+  for (let index = 0; index < 3; index += 1) {
+    if (a.parts[index] !== b.parts[index]) return a.parts[index] > b.parts[index] ? 1 : -1;
+  }
+  if (!a.prerelease.length && b.prerelease.length) return 1;
+  if (a.prerelease.length && !b.prerelease.length) return -1;
+  const length = Math.max(a.prerelease.length, b.prerelease.length);
+  for (let index = 0; index < length; index += 1) {
+    const av = a.prerelease[index];
+    const bv = b.prerelease[index];
+    if (av == null && bv == null) return 0;
+    if (av == null) return -1;
+    if (bv == null) return 1;
+    const an = /^\d+$/u.test(av) ? Number(av) : null;
+    const bn = /^\d+$/u.test(bv) ? Number(bv) : null;
+    if (an != null && bn != null && an !== bn) return an > bn ? 1 : -1;
+    if (an != null && bn == null) return -1;
+    if (an == null && bn != null) return 1;
+    const cmp = av.localeCompare(bv);
+    if (cmp !== 0) return cmp > 0 ? 1 : -1;
+  }
+  return 0;
+}
+
+function parsePackageVersion(value) {
+  const normalized = cleanText(value || "").replace(/^v/iu, "").split("+")[0];
+  const [core, prerelease = ""] = normalized.split("-", 2);
+  const parts = core.split(".").map((part) => Number(part)).map((part) => (Number.isFinite(part) && part >= 0 ? part : 0));
+  while (parts.length < 3) parts.push(0);
+  return {
+    parts: parts.slice(0, 3),
+    prerelease: prerelease ? prerelease.split(".").map((part) => cleanText(part)).filter(Boolean) : [],
+  };
+}
+
 function mergeHazbaseAccountSummaries(existing, incoming) {
   const merged = new Map();
   for (const entry of [...(Array.isArray(existing) ? existing : []), ...(Array.isArray(incoming) ? incoming : [])]) {
@@ -17644,6 +18440,169 @@ function resolveHazbaseAccountForChain(accounts, chainId) {
   return list.find((entry) => Number(entry?.chainId) === normalizedChainId && cleanText(entry?.smartAccountAddress || "")) || null;
 }
 
+
+async function finalizeHazbaseWalletPaymentFailure({ config, runtime, state, approval, error }) {
+  const errorCode = cleanText(error?.code || error?.message || "hazbase-wallet-payment-failed") || "hazbase-wallet-payment-failed";
+  if (approval.resolved) {
+    return { paid: false, decision: "failed", error: errorCode };
+  }
+
+  const payload = {
+    paid: false,
+    decision: "failed",
+    error: errorCode,
+    paymentRequestId: approval.paymentRequestId || approval.requestId || "",
+  };
+
+  approval.resolved = true;
+  approval.resolving = false;
+  runtime.nativeApprovalsByToken.delete(approval.token);
+  runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+  approval.resolveClaudeWaiter?.(payload);
+
+  const statusMessage = t(config.defaultLocale, "server.message.paymentFailed", { reason: errorCode });
+  const stateChanged = recordActionHistoryItem({
+    config,
+    runtime,
+    state,
+    kind: "approval",
+    stableId: `approval:${approval.requestKey}:${Date.now()}`,
+    token: approval.token,
+    title: approval.title,
+    threadLabel: approval.threadLabel || "",
+    messageText: `${statusMessage}\n\n${approval.messageText}`,
+    summary: statusMessage,
+    fileRefs: [],
+    diffText: "",
+    diffSource: "",
+    diffAvailable: false,
+    diffAddedLines: 0,
+    diffRemovedLines: 0,
+    outcome: "failed",
+    provider: approval.provider || "viveworker",
+  });
+  if (stateChanged) await saveState(config.stateFile, state);
+  console.log(`[hazbase-wallet-payment-failed] ${approval.requestKey} | ${errorCode}`);
+  return payload;
+}
+
+async function completeHazbaseWalletPaymentApproval({ config, runtime, state, approval }) {
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  if (!hazbase.accessToken) throw codedError("hazbase-auth-required", 401);
+  if (!hazbase.deviceBindingId) throw codedError("hazbase-passkey-required", 409);
+  if (!hazbase.highTrustToken) throw codedError("hazbase-reauth-required", 409);
+  const chainId = Number(approval.rawParams?.chainId || 0);
+  const account = resolveHazbaseAccountForChain(hazbase.accounts, chainId);
+  if (!account?.smartAccountAddress) throw codedError("hazbase-wallet-account-missing", 409);
+
+  let result;
+  try {
+    result = await postHazbaseJson(config, "/api/payments/x402/hazbase-wallet/pay", {
+      paymentRequestId: approval.paymentRequestId,
+      deviceBindingId: hazbase.deviceBindingId,
+      highTrustToken: hazbase.highTrustToken,
+      smartAccountAddress: account.smartAccountAddress,
+      waitForReceipt: true,
+    }, hazbase.accessToken, 130_000);
+  } catch (error) {
+    if (isHazbaseInvalidAppSessionError(error)) {
+      markHazbaseSessionInvalid(state);
+      await saveState(config.stateFile, state);
+      throw codedError("hazbase-session-expired", 401, {
+        message: "Hazbase wallet session expired. Sign in again from Wallet settings.",
+      });
+    }
+    throw error;
+  }
+
+  if (!result?.xPayment) {
+    throw codedError(result?.errorCode || result?.error || "hazbase-wallet-payment-failed", 502);
+  }
+
+  const payload = {
+    paid: true,
+    decision: "accept",
+    paymentRequestId: approval.paymentRequestId,
+    xPayment: cleanText(result.xPayment || ""),
+    payer: cleanText(result.payer || account.smartAccountAddress || ""),
+    chainId: Number(result.chainId || chainId),
+    network: cleanText(result.network || approval.rawParams?.network || ""),
+    relayMode: cleanText(result.relayMode || ""),
+    submittedUserOpHash: cleanText(result.submittedUserOpHash || ""),
+    transactionHash: cleanText(result.transactionHash || ""),
+    payment: result,
+  };
+
+  approval.resolved = true;
+  approval.resolving = false;
+  runtime.nativeApprovalsByToken.delete(approval.token);
+  runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+  approval.resolveClaudeWaiter?.(payload);
+  const stateChanged = recordActionHistoryItem({
+    config,
+    runtime,
+    state,
+    kind: "approval",
+    stableId: `approval:${approval.requestKey}:${Date.now()}`,
+    token: approval.token,
+    title: approval.title,
+    threadLabel: approval.threadLabel || "",
+    messageText: `${approvalDecisionMessage("accept", config.defaultLocale, approval.provider)}\n\n${approval.messageText}\n\nTransaction: ${payload.transactionHash || payload.submittedUserOpHash}`,
+    summary: formatNotificationBody(approval.messageText, 160) || approvalDecisionMessage("accept", config.defaultLocale, approval.provider),
+    fileRefs: [],
+    diffText: "",
+    diffSource: "",
+    diffAvailable: false,
+    diffAddedLines: 0,
+    diffRemovedLines: 0,
+    outcome: "approved",
+    provider: approval.provider || "viveworker",
+  });
+  if (stateChanged) await saveState(config.stateFile, state);
+  console.log(`[hazbase-wallet-payment] ${approval.requestKey} | ${payload.transactionHash || payload.submittedUserOpHash}`);
+  return { ok: true, ...payload };
+}
+
+async function postHazbaseJson(config, endpoint, body, bearerToken, timeoutMs = 30_000) {
+  const baseUrl = stripTrailingSlash(config?.hazbaseApiUrl || "");
+  if (!baseUrl) throw codedError("hazbase-api-not-configured", 503);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  timer.unref?.();
+  try {
+    const response = await fetch(`${baseUrl}${endpoint}`, {
+      method: "POST",
+      headers: {
+        "content-type": "application/json",
+        accept: "application/json",
+        authorization: `Bearer ${bearerToken}`,
+        "x-request-id": `viveworker_${crypto.randomUUID()}`,
+      },
+      body: JSON.stringify(body),
+      signal: controller.signal,
+    });
+    const payload = await response.json().catch(() => null);
+    const data = payload?.data || payload || {};
+    if (!response.ok) {
+      throw codedError(data?.errorCode || data?.code || data?.error || `hazbase-api-${response.status}`, response.status, data);
+    }
+    return data;
+  } catch (error) {
+    if (error?.name === "AbortError") throw codedError("hazbase-api-timeout", 504);
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+function codedError(code, statusCode = 500, details = null) {
+  const error = new Error(code);
+  error.code = code;
+  error.statusCode = statusCode;
+  error.details = details;
+  return error;
+}
+
 function validateConfig(config) {
   let publicBaseUrl = null;
   try {
@@ -18436,8 +19395,11 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
   );
 
   if (
-    JSON.stringify(nextHistoryItems.map((item) => [item.stableId, item.title, item.threadLabel])) !==
-    JSON.stringify(runtime.recentHistoryItems.map((item) => [item.stableId, item.title, item.threadLabel]))
+    timelineProjectionChanged(nextHistoryItems, runtime.recentHistoryItems, [
+      "stableId",
+      "title",
+      "threadLabel",
+    ])
   ) {
     runtime.recentHistoryItems = nextHistoryItems;
     state.recentHistoryItems = nextHistoryItems;
@@ -18478,8 +19440,11 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
   );
 
   if (
-    JSON.stringify(nextTimelineEntries.map((entry) => [entry.stableId, entry.title, entry.threadLabel])) !==
-    JSON.stringify(runtime.recentTimelineEntries.map((entry) => [entry.stableId, entry.title, entry.threadLabel]))
+    timelineProjectionChanged(nextTimelineEntries, runtime.recentTimelineEntries, [
+      "stableId",
+      "title",
+      "threadLabel",
+    ])
   ) {
     runtime.recentTimelineEntries = nextTimelineEntries;
     state.recentTimelineEntries = nextTimelineEntries;
@@ -18514,8 +19479,11 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
   );
 
   if (
-    JSON.stringify(nextCodeEvents.map((entry) => [entry.stableId, entry.title, entry.threadLabel])) !==
-    JSON.stringify(runtime.recentCodeEvents.map((entry) => [entry.stableId, entry.title, entry.threadLabel]))
+    timelineProjectionChanged(nextCodeEvents, runtime.recentCodeEvents, [
+      "stableId",
+      "title",
+      "threadLabel",
+    ])
   ) {
     runtime.recentCodeEvents = nextCodeEvents;
     state.recentCodeEvents = nextCodeEvents;
@@ -18950,6 +19918,37 @@ async function main() {
   process.on("SIGINT", handleSignal);
   process.on("SIGTERM", handleSignal);
 
+  // Belt-and-suspenders: a stray ERR_HTTP_HEADERS_SENT inside an async
+  // request handler used to escape as an UnhandledPromiseRejection and crash
+  // the process under launchd, triggering a restart loop that then re-ran all
+  // the startup backfills (state.json parse, rollout/transcript replay) and
+  // burned CPU + memory for ~30s per cycle. The targeted catch-handler guards
+  // around handleNativeApprovalDecision cover the known sites; this top-level
+  // filter swallows the same class of error from any new site we haven't
+  // audited yet so the process keeps serving instead of dying.
+  const isBenignHttpError = (err) =>
+    err && typeof err === "object" && (
+      err.code === "ERR_HTTP_HEADERS_SENT" ||
+      err.code === "ERR_STREAM_WRITE_AFTER_END" ||
+      err.code === "ERR_STREAM_DESTROYED" ||
+      err.code === "ECONNRESET" ||
+      err.code === "EPIPE"
+    );
+  process.on("uncaughtException", (err) => {
+    if (isBenignHttpError(err)) {
+      console.warn(`[uncaught-http] ${err.code} ${err.message}`);
+      return;
+    }
+    console.error(`[uncaught] ${err?.stack || err}`);
+  });
+  process.on("unhandledRejection", (reason) => {
+    if (isBenignHttpError(reason)) {
+      console.warn(`[unhandled-http] ${reason.code} ${reason.message}`);
+      return;
+    }
+    console.error(`[unhandled] ${reason?.stack || reason}`);
+  });
+
   try {
     if (config.webPushEnabled) {
       webPush.setVapidDetails(