viveworker 0.7.0-beta.3 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.7.0-beta.3",
+  "version": "0.7.0",
   "description": "Open mobile control surface for Codex, Claude, Thread Sharing, File Share, Moltbook, and A2A tasks on your trusted LAN.",
   "author": "Yuta Hoshino <hoshino.lireneo@gmail.com>",
   "license": "MIT",

package/scripts/viveworker-bridge.mjs

@@ -680,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
     : "";
 }
@@ -2993,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;
@@ -3158,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;
@@ -3205,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) {
@@ -3257,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) {
@@ -3353,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;
@@ -3784,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;
@@ -4122,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 });
@@ -4133,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
@@ -11294,6 +11331,7 @@ function buildPendingApprovalDetail(runtime, state, approval, locale) {
       : 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: {} },
@@ -13480,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>
@@ -15028,9 +15150,13 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           const result = await completeHazbaseWalletPaymentApproval({ config, runtime, state, approval });
           return writeJson(res, 200, result);
         } catch (error) {
-          approval.resolving = false;
+          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: error?.code || error?.message || "hazbase-wallet-payment-failed" });
+          return writeJson(res, Number(error?.statusCode) || 500, {
+            error: failure.error,
+            approvalFinalized: true,
+            retryable: true,
+          });
         }
       }
 
@@ -15922,7 +16048,7 @@ 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") {
+        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" });
         }
@@ -15936,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 });
         }
       }
@@ -16520,7 +16650,7 @@ 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") {
+      if (approval.kind === "hazbase_wallet_payment" && decision !== "decline") {
         console.warn(`[hazbase-wallet-payment-native-decision-blocked] ${approval.requestKey} | ${decision}`);
         if (requestWantsHtml(req)) {
           return writeHtml(
@@ -16559,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,
@@ -16573,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,
@@ -17969,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),
@@ -18012,18 +18155,31 @@ 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 ?? ""),
@@ -18032,19 +18188,30 @@ function normalizeHazbaseState(raw) {
 
 function isHazbaseInvalidAppSessionError(error) {
   const details = error?.details && typeof error.details === "object" ? error.details : {};
-  const statusCode = Number(error?.statusCode || error?.status || details.statusCode || 0);
-  const text = [
+  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");
+  return statusCode === 401 && (
+    text.includes("invalid app session") ||
+    text.includes("invalid_app_session")
+  );
 }
 
 function markHazbaseSessionInvalid(state, reason = "invalid_app_session") {
@@ -18274,6 +18441,51 @@ function resolveHazbaseAccountForChain(accounts, chainId) {
 }
 
 
+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);
@@ -19183,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;
@@ -19225,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;
@@ -19261,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;
@@ -19697,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(