viveworker 0.7.0-beta.1 → 0.7.0-beta.3

package/scripts/viveworker-bridge.mjs

@@ -12,7 +12,9 @@ import process from "node:process";
 import { createInterface } from "node:readline";
 import { inspect } from "node:util";
 import { fileURLToPath } from "node:url";
+import zlib from "node:zlib";
 import webPush from "web-push";
+import * as hazbaseAuth from "@hazbase/auth";
 import { DEFAULT_LOCALE, SUPPORTED_LOCALES, localeDisplayName, normalizeLocale, resolveLocalePreference, t } from "../web/i18n.js";
 import { generatePairingCredentials, shouldRotatePairing, upsertEnvText } from "./lib/pairing.mjs";
 import { renderMarkdownHtml } from "./lib/markdown-render.mjs";
@@ -24,6 +26,21 @@ const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
 const workspaceRoot = path.resolve(__dirname, "..");
 const webRoot = path.join(workspaceRoot, "web");
+const {
+  bootstrapPasskeyAccount,
+  completePasskeyAssertion,
+  completePasskeyRegistration,
+  listSupportedChains,
+  requestEmailOtp: requestHazbaseEmailOtp,
+  requestPasskeyAssertionChallenge,
+  requestPasskeyRegistrationChallenge,
+  setApiEndpoint: setHazbaseApiEndpoint,
+  setClientKey: setHazbaseClientKey,
+  verifyEmailOtp: verifyHazbaseEmailOtp,
+} = hazbaseAuth;
+const listSupportedPayments = typeof hazbaseAuth.listSupportedPayments === "function"
+  ? hazbaseAuth.listSupportedPayments.bind(hazbaseAuth)
+  : async () => ({ networks: [], defaultNetwork: "base-sepolia" });
 const appPackageVersion = readPackageVersion();
 const sessionCookieName = "viveworker_session";
 const deviceCookieName = "viveworker_device";
@@ -38,6 +55,155 @@ const PAIRING_RATE_LIMIT_MAX_ATTEMPTS = 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`,
+// `git diff`) plus a `git rev-parse` per unique dir — roughly 10+ subprocess
+// spawns for a typical multi-repo state. Both /api/inbox/diff and
+// /api/items/diff_thread/:token call this function; when the user taps a
+// detail right after the inbox finished loading, the computation is
+// duplicated unnecessarily. Short TTL + explicit invalidation when
+// recentCodeEvents mutates keeps the result fresh without the recompute cost.
+// Hoisted here so code-event migration at startup can call
+// invalidateDiffThreadGroupsCache() before any of the use sites below
+// execute, avoiding a temporal-dead-zone ReferenceError on `let`.
+const DIFF_THREAD_GROUPS_CACHE_TTL_MS = 3000;
+let diffThreadGroupsCache = null;
+let diffThreadGroupsPending = null;
+
+function invalidateDiffThreadGroupsCache() {
+  diffThreadGroupsCache = null;
+  // Don't touch diffThreadGroupsPending — an in-flight build reflects the
+  // state at the time it started, and callers racing the rebuild would
+  // otherwise pile up their own subprocess spawns.
+}
+
+async function getDiffThreadGroupsCached(runtime, state, config) {
+  const now = Date.now();
+  if (
+    diffThreadGroupsCache &&
+    now - diffThreadGroupsCache.computedAtMs < DIFF_THREAD_GROUPS_CACHE_TTL_MS
+  ) {
+    return diffThreadGroupsCache.groups;
+  }
+  if (diffThreadGroupsPending) {
+    return diffThreadGroupsPending;
+  }
+  diffThreadGroupsPending = (async () => {
+    try {
+      const groups = await buildDiffThreadGroups(runtime, state, config);
+      diffThreadGroupsCache = { groups, computedAtMs: Date.now() };
+      return groups;
+    } finally {
+      diffThreadGroupsPending = null;
+    }
+  })();
+  return diffThreadGroupsPending;
+}
+
+// Coalesced state persistence. The full state JSON is ~8 MB on disk (dominated
+// by `recentCodeEvents` and `recentTimelineEntries` caches); JSON.stringify
+// blocks the event loop ~70 ms and fs.writeFile takes another ~80 ms. Before
+// this helper, every tiny mutation (push subscribe/unsubscribe/test, locale
+// change, claude-away toggle, A2A toggles, …) awaited a ~150 ms
+// serialize+write before the HTTP response fired — and the event-loop block
+// delayed every concurrent request on the same server too. That's what made
+// the settings/notification buttons feel sluggish: the click → visible
+// response round-trip paid the cost of re-serializing 5 MB of code-event
+// history every time.
+//
+// `scheduleSaveState` queues a write within SAVE_STATE_DEBOUNCE_MS and returns
+// synchronously, so HTTP handlers can respond immediately after mutating
+// in-memory state. Multiple mutations within the window coalesce into one
+// write. `flushPendingStateWrite` drains on graceful shutdown.
+//
+// Durability trade-off: at most ~SAVE_STATE_MAX_DELAY_MS of in-memory
+// mutations can be lost on a hard crash. Callers that require stronger
+// guarantees (pairing, revocation, the periodic scan loop) still `await
+// saveState(...)` directly — only the hot settings/notification paths opt in
+// to the coalescer.
+const SAVE_STATE_DEBOUNCE_MS = 500;
+const SAVE_STATE_MAX_DELAY_MS = 1500;
+let saveStateTimer = null;
+let saveStateFirstScheduleAtMs = 0;
+let saveStateInFlight = null;
+let saveStateDirty = false;
+
+function scheduleSaveState(config, state) {
+  if (!config?.stateFile) return;
+  if (saveStateInFlight) {
+    // An in-flight write already reflects the current (or earlier) state.
+    // Mark dirty so the .finally handler starts another write when it
+    // finishes — overlapping writes would just stomp on each other.
+    saveStateDirty = true;
+    return;
+  }
+  const now = Date.now();
+  if (!saveStateFirstScheduleAtMs) {
+    saveStateFirstScheduleAtMs = now;
+  }
+  if (saveStateTimer) {
+    clearTimeout(saveStateTimer);
+  }
+  const elapsed = now - saveStateFirstScheduleAtMs;
+  const remaining = SAVE_STATE_MAX_DELAY_MS - elapsed;
+  const delay = Math.max(0, Math.min(SAVE_STATE_DEBOUNCE_MS, remaining));
+  saveStateTimer = setTimeout(() => {
+    saveStateTimer = null;
+    saveStateFirstScheduleAtMs = 0;
+    startSaveStateFlush(config, state);
+  }, delay);
+}
+
+function startSaveStateFlush(config, state) {
+  saveStateDirty = false;
+  const promise = (async () => {
+    try {
+      await saveState(config.stateFile, state);
+    } catch (error) {
+      console.error(`[save-state-error] ${error.message}`);
+    }
+  })();
+  saveStateInFlight = promise;
+  promise.finally(() => {
+    if (saveStateInFlight === promise) {
+      saveStateInFlight = null;
+    }
+    if (saveStateDirty) {
+      // A mutation arrived mid-flight. Start the follow-up write
+      // synchronously — we've already held the original debounce window,
+      // so tacking on another 500 ms would defeat coalescing. Going
+      // through scheduleSaveState() instead would also introduce a timer
+      // that flushPendingStateWrite() would have to know about.
+      saveStateDirty = false;
+      startSaveStateFlush(config, state);
+    }
+  });
+}
+
+async function flushPendingStateWrite(config, state) {
+  // Promote any pending debounce timer to an immediate flush.
+  if (saveStateTimer) {
+    clearTimeout(saveStateTimer);
+    saveStateTimer = null;
+    saveStateFirstScheduleAtMs = 0;
+    startSaveStateFlush(config, state);
+  }
+  // Drain the in-flight write plus any cascades triggered by saveStateDirty.
+  // Bounded so a pathological re-entrancy bug can't hang shutdown.
+  for (let iter = 0; iter < 4 && (saveStateInFlight || saveStateDirty); iter += 1) {
+    if (saveStateInFlight) {
+      await saveStateInFlight.catch(() => {});
+    }
+    if (saveStateDirty && !saveStateInFlight) {
+      saveStateDirty = false;
+      startSaveStateFlush(config, state);
+    }
+  }
+}
 
 const cli = parseCliArgs(process.argv.slice(2));
 const envFile = resolveEnvFile(cli.envFile);
@@ -47,6 +213,7 @@ await maybeRotateStartupPairingEnv(envFile);
 
 const config = buildConfig(cli);
 validateConfig(config);
+configureHazbaseClient(config);
 
 const runtime = {
   fileStates: new Map(),
@@ -100,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);
@@ -165,6 +337,7 @@ const backfilledAmbientSuggestionsStateChanged = backfillAmbientSuggestionsState
 const migratedRecentCodeEventsStateChanged = migrateRecentCodeEventsState({ config, runtime, state });
 const restoredTimelineImagePathsStateChanged = await backfillPersistedTimelineImagePaths({ config, runtime, state });
 const backfilledMoltbookInboxChanged = await backfillMoltbookInboxHistory({ config, runtime, state });
+const recoveredMissingProviderStateChanged = await recoverMissingProviderStateFromBackup({ config, runtime, state });
 runtime.historyFileState.offset = Number(state.historyFileOffset) || 0;
 runtime.historyFileState.sourceFile = cleanText(state.historyFileSourceFile ?? "");
 
@@ -263,8 +436,23 @@ function clearDeviceLocaleOverride(state, deviceId) {
   return true;
 }
 
+function autoPilotWriteLaneState(state) {
+  return {
+    content: state?.autoPilotWriteLaneContent === true,
+    uiTests: state?.autoPilotWriteLaneUiTests === true,
+    source: state?.autoPilotWriteLaneSource === true,
+  };
+}
+
+function hasAnyAutoPilotWriteLaneEnabled(state) {
+  const lanes = autoPilotWriteLaneState(state);
+  return lanes.content || lanes.uiTests || lanes.source;
+}
+
 function buildSessionLocalePayload(config, state, deviceId) {
   const resolved = resolveDeviceLocaleInfo(config, state, deviceId);
+  const writeLanes = autoPilotWriteLaneState(state);
+  const trustedWritesEnabled = hasAnyAutoPilotWriteLaneEnabled(state);
   return {
     locale: resolved.locale,
     localeSource: resolved.source,
@@ -273,6 +461,12 @@ function buildSessionLocalePayload(config, state, deviceId) {
     deviceDetectedLocale: resolved.detectedLocale || null,
     deviceOverrideLocale: resolved.overrideLocale || null,
     claudeAwayMode: state?.claudeAwayMode === true,
+    autoPilotTrustedReads: state?.autoPilotTrustedReads === true,
+    autoPilotTrustedWrites: trustedWritesEnabled,
+    autoPilotTrustedWritesShadow: false,
+    autoPilotWriteLaneContent: writeLanes.content,
+    autoPilotWriteLaneUiTests: writeLanes.uiTests,
+    autoPilotWriteLaneSource: writeLanes.source,
     moltbookEnabled: Boolean(config.moltbookApiKey),
     a2aEnabled: Boolean(config.a2aApiKey),
     a2aRelayEnabled: Boolean(config.a2aRelayUrl && config.a2aRelayUserId),
@@ -770,6 +964,425 @@ function tokenizeShellWords(commandText) {
   return tokens;
 }
 
+function isPathWithinRoot(rootPath, candidatePath) {
+  const normalizedRoot = cleanText(rootPath || "");
+  const normalizedCandidate = cleanText(candidatePath || "");
+  if (!normalizedRoot || !normalizedCandidate) {
+    return false;
+  }
+  const relativePath = path.relative(normalizedRoot, normalizedCandidate);
+  return relativePath === "" || (!relativePath.startsWith("..") && !path.isAbsolute(relativePath));
+}
+
+function isSensitiveCommandPath(candidatePath) {
+  const normalized = cleanText(candidatePath || "");
+  if (!normalized) {
+    return true;
+  }
+  const lower = normalized.toLowerCase();
+  const segments = lower.split(/[\\/]+/u).filter(Boolean);
+  const basename = segments[segments.length - 1] || "";
+  if (segments.some((segment) => [".ssh", ".aws", ".gnupg", ".azure", ".kube"].includes(segment))) {
+    return true;
+  }
+  if (basename === ".npmrc" || basename === ".netrc" || basename === ".env" || basename.startsWith(".env.")) {
+    return true;
+  }
+  if (basename.endsWith(".pem") || basename.endsWith(".key") || basename.endsWith(".p12") || basename.endsWith(".pfx")) {
+    return true;
+  }
+  if (/^id_[a-z0-9._-]+$/iu.test(basename) || basename.includes("secret") || basename.includes("credential")) {
+    return true;
+  }
+  return false;
+}
+
+function resolveTrustedReadTargetPath({ token, cwd, workspaceRoot }) {
+  const rawToken = cleanText(token || "");
+  const normalizedCwd = cleanText(cwd || "");
+  const normalizedWorkspaceRoot = cleanText(workspaceRoot || normalizedCwd);
+  if (!rawToken || !normalizedCwd || !normalizedWorkspaceRoot) {
+    return null;
+  }
+  if (rawToken === "-" || rawToken.startsWith("~") || rawToken.startsWith("http://") || rawToken.startsWith("https://")) {
+    return null;
+  }
+  const resolved = path.resolve(normalizedCwd, rawToken);
+  if (!isPathWithinRoot(normalizedWorkspaceRoot, resolved)) {
+    return null;
+  }
+  if (isSensitiveCommandPath(resolved)) {
+    return null;
+  }
+  return resolved;
+}
+
+function isGitObjectPathToken(token) {
+  const normalized = cleanText(token || "");
+  if (!normalized || normalized.startsWith("-")) {
+    return false;
+  }
+  return /^[^:\s][^:\s]*:.+/u.test(normalized);
+}
+
+function isLiteralGitPathspecToken(token) {
+  const normalized = cleanText(token || "");
+  if (!normalized || normalized === "--" || normalized.startsWith(":(") || normalized.startsWith(":/")) {
+    return false;
+  }
+  if (/[*?[\]{}]/u.test(normalized)) {
+    return false;
+  }
+  return !isGitObjectPathToken(normalized);
+}
+
+function isAllowedGitMetadataOnlyFlag(token) {
+  const normalized = cleanText(token || "");
+  if (!normalized) {
+    return false;
+  }
+  return [
+    "--stat",
+    "--shortstat",
+    "--numstat",
+    "--name-only",
+    "--name-status",
+    "--summary",
+    "--compact-summary",
+    "--oneline",
+    "--no-patch",
+    "-s",
+  ].includes(normalized);
+}
+
+function hasDisallowedGitPatchOutput(tokens) {
+  return tokens.some((token) => {
+    const normalized = cleanText(token || "");
+    if (!normalized) {
+      return false;
+    }
+    return (
+      normalized === "-p" ||
+      normalized === "--patch" ||
+      normalized === "--patch-with-stat" ||
+      normalized === "--raw" ||
+      normalized === "--cc" ||
+      normalized === "--combined-all-paths" ||
+      normalized === "--binary" ||
+      normalized === "--word-diff" ||
+      normalized.startsWith("--word-diff=") ||
+      normalized === "-U" ||
+      normalized.startsWith("-U") ||
+      normalized === "--unified" ||
+      normalized.startsWith("--unified=")
+    );
+  });
+}
+
+function extractGitPathspecTokens(tokens) {
+  const separatorIndex = tokens.indexOf("--");
+  if (separatorIndex < 0) {
+    return [];
+  }
+  return tokens.slice(separatorIndex + 1).filter(Boolean);
+}
+
+function resolveTrustedDiffSectionPath({ token, cwd, workspaceRoot }) {
+  const normalizedToken = cleanText(token || "");
+  if (!normalizedToken) {
+    return null;
+  }
+  const preferredWorkspace = resolveTrustedReadTargetPath({
+    token: normalizedToken,
+    cwd: workspaceRoot,
+    workspaceRoot,
+  });
+  if (preferredWorkspace) {
+    return preferredWorkspace;
+  }
+  return resolveTrustedReadTargetPath({
+    token: normalizedToken,
+    cwd,
+    workspaceRoot,
+  });
+}
+
+function extractTrustedReadFileRefs(command, tokens, cwd, workspaceRoot) {
+  const normalizedCommand = cleanText(command || "");
+  if (!normalizedCommand) {
+    return null;
+  }
+
+  if (normalizedCommand === "pwd" || (normalizedCommand === "git" && cleanText(tokens[1] || "") === "status")) {
+    const resolved = resolveTrustedReadTargetPath({ token: ".", cwd, workspaceRoot });
+    return resolved ? normalizeTimelineFileRefs([resolved]) : null;
+  }
+
+  if (normalizedCommand === "git") {
+    const gitSubcommand = cleanText(tokens[1] || "");
+    if (!["diff", "show"].includes(gitSubcommand)) {
+      return null;
+    }
+    if (tokens.some((token) => token === "-C" || token.startsWith("-C") || token === "--output" || token.startsWith("--output="))) {
+      return null;
+    }
+    const commandArgs = tokens.slice(2);
+    if (commandArgs.some((token) => isGitObjectPathToken(token))) {
+      return null;
+    }
+    const explicitPathspecs = extractGitPathspecTokens(tokens);
+    if (explicitPathspecs.length > 0) {
+      if (explicitPathspecs.some((token) => !isLiteralGitPathspecToken(token))) {
+        return null;
+      }
+      const resolvedPaths = explicitPathspecs
+        .map((token) => resolveTrustedReadTargetPath({ token, cwd, workspaceRoot }))
+        .filter(Boolean);
+      return resolvedPaths.length === explicitPathspecs.length ? normalizeTimelineFileRefs(resolvedPaths) : null;
+    }
+    if (hasDisallowedGitPatchOutput(commandArgs)) {
+      return null;
+    }
+    const metadataOnly = commandArgs.some((token) => isAllowedGitMetadataOnlyFlag(token));
+    if (!metadataOnly) {
+      return null;
+    }
+    const resolved = resolveTrustedReadTargetPath({ token: ".", cwd, workspaceRoot });
+    return resolved ? normalizeTimelineFileRefs([resolved]) : null;
+  }
+
+  if (normalizedCommand === "ls") {
+    const pathArgs = tokens.slice(1).filter((token) => !String(token || "").startsWith("-"));
+    if (pathArgs.length === 0) {
+      const resolved = resolveTrustedReadTargetPath({ token: ".", cwd, workspaceRoot });
+      return resolved ? normalizeTimelineFileRefs([resolved]) : null;
+    }
+    const resolvedPaths = pathArgs
+      .map((token) => resolveTrustedReadTargetPath({ token, cwd, workspaceRoot }))
+      .filter(Boolean);
+    return resolvedPaths.length === pathArgs.length ? normalizeTimelineFileRefs(resolvedPaths) : null;
+  }
+
+  if (normalizedCommand === "find") {
+    if (tokens.some((token) => ["-exec", "-execdir", "-ok", "-okdir", "-delete", "-fprint", "-fprintf", "-fls"].includes(token))) {
+      return null;
+    }
+    const pathArgs = [];
+    for (const token of tokens.slice(1)) {
+      if (!token || token === "--") continue;
+      if (token === "!" || token === "(" || token === ")") break;
+      if (token.startsWith("-")) break;
+      pathArgs.push(token);
+    }
+    const effectivePaths = pathArgs.length ? pathArgs : ["."];
+    const resolvedPaths = effectivePaths
+      .map((token) => resolveTrustedReadTargetPath({ token, cwd, workspaceRoot }))
+      .filter(Boolean);
+    return resolvedPaths.length === effectivePaths.length ? normalizeTimelineFileRefs(resolvedPaths) : null;
+  }
+
+  if (normalizedCommand === "sed") {
+    if (!tokens.includes("-n") || tokens.includes("-i") || tokens.includes("--in-place")) {
+      return null;
+    }
+    let script = "";
+    const fileArgs = [];
+    for (let index = 1; index < tokens.length; index += 1) {
+      const token = tokens[index];
+      if (!token) continue;
+      if (!script) {
+        if (token === "-e") {
+          script = tokens[index + 1] || "";
+          index += 1;
+          continue;
+        }
+        if (token.startsWith("-")) {
+          continue;
+        }
+        script = token;
+        continue;
+      }
+      if (!token.startsWith("-")) {
+        fileArgs.push(token);
+      }
+    }
+    if (!script || !/^[0-9,$; p-]+$/u.test(script) || fileArgs.length === 0) {
+      return null;
+    }
+    const resolvedPaths = fileArgs
+      .map((token) => resolveTrustedReadTargetPath({ token, cwd, workspaceRoot }))
+      .filter(Boolean);
+    return resolvedPaths.length === fileArgs.length ? normalizeTimelineFileRefs(resolvedPaths) : null;
+  }
+
+  if (normalizedCommand === "rg") {
+    let seenPattern = false;
+    const fileArgs = [];
+    for (const token of tokens.slice(1)) {
+      if (!seenPattern) {
+        if (token === "--") {
+          seenPattern = true;
+          continue;
+        }
+        if (String(token || "").startsWith("-")) {
+          continue;
+        }
+        seenPattern = true;
+        continue;
+      }
+      if (!String(token || "").startsWith("-")) {
+        fileArgs.push(token);
+      }
+    }
+    const effectivePaths = fileArgs.length ? fileArgs : ["."];
+    const resolvedPaths = effectivePaths
+      .map((token) => resolveTrustedReadTargetPath({ token, cwd, workspaceRoot }))
+      .filter(Boolean);
+    return resolvedPaths.length === effectivePaths.length ? normalizeTimelineFileRefs(resolvedPaths) : null;
+  }
+
+  if (["cat", "nl", "head", "tail", "wc"].includes(normalizedCommand)) {
+    const fileArgs = tokens.slice(1).filter((token) => !String(token || "").startsWith("-"));
+    if (fileArgs.length === 0) {
+      return null;
+    }
+    const resolvedPaths = fileArgs
+      .map((token) => resolveTrustedReadTargetPath({ token, cwd, workspaceRoot }))
+      .filter(Boolean);
+    return resolvedPaths.length === fileArgs.length ? normalizeTimelineFileRefs(resolvedPaths) : null;
+  }
+
+  return null;
+}
+
+function stripAllowedTrustedReadRedirections(tokens) {
+  const filtered = [];
+  for (let index = 0; index < tokens.length; index += 1) {
+    const token = String(tokens[index] || "");
+    if (!token) {
+      continue;
+    }
+    if (token === "2>" || token === "2>>") {
+      const target = String(tokens[index + 1] || "");
+      if (target !== "/dev/null") {
+        return null;
+      }
+      index += 1;
+      continue;
+    }
+    if (/^2>>?\/dev\/null$/u.test(token)) {
+      continue;
+    }
+    if (token.includes(">") || token.includes("<")) {
+      return null;
+    }
+    filtered.push(token);
+  }
+  return filtered;
+}
+
+function isAllowedTrustedReadPostProcessStage(stageTokens) {
+  if (!Array.isArray(stageTokens) || stageTokens.length === 0) {
+    return false;
+  }
+  const [command, ...args] = stageTokens.map((token) => cleanText(token || ""));
+  if (!command) {
+    return false;
+  }
+  if (command === "head" || command === "tail") {
+    if (args.length === 0) {
+      return true;
+    }
+    if (args.length === 1 && /^-\d+$/u.test(args[0])) {
+      return true;
+    }
+    if (args.length === 2 && args[0] === "-n" && /^\d+$/u.test(args[1])) {
+      return true;
+    }
+    return false;
+  }
+  if (command === "wc") {
+    return args.length === 0 || (args.length === 1 && args[0] === "-l");
+  }
+  return false;
+}
+
+function normalizeTrustedReadTokens(tokens) {
+  const strippedTokens = stripAllowedTrustedReadRedirections(tokens);
+  if (!strippedTokens || strippedTokens.length === 0) {
+    return null;
+  }
+  if (strippedTokens.some((token) => {
+    const value = String(token || "");
+    return (
+      ["||", "&&", ";", "&"].includes(value) ||
+      value.includes("`") ||
+      value.includes("$(")
+    );
+  })) {
+    return null;
+  }
+  const stages = [];
+  let currentStage = [];
+  for (const token of strippedTokens) {
+    if (token === "|") {
+      if (currentStage.length === 0) {
+        return null;
+      }
+      stages.push(currentStage);
+      currentStage = [];
+      continue;
+    }
+    currentStage.push(token);
+  }
+  if (currentStage.length === 0) {
+    return null;
+  }
+  stages.push(currentStage);
+  if (stages.length === 0) {
+    return null;
+  }
+  if (stages.slice(1).some((stageTokens) => !isAllowedTrustedReadPostProcessStage(stageTokens))) {
+    return null;
+  }
+  return stages[0];
+}
+
+function evaluateTrustedReadCommandPolicy({ commandText, cwd, workspaceRoot }) {
+  const normalizedCwd = cleanText(cwd || "");
+  const normalizedWorkspaceRoot = cleanText(workspaceRoot || normalizedCwd);
+  const normalizedCommandText = unwrapShellCommand(commandText);
+  const rawTokens = tokenizeShellWords(normalizedCommandText);
+  if (!normalizedCommandText || !normalizedCwd || !normalizedWorkspaceRoot || rawTokens.length === 0) {
+    return null;
+  }
+
+  if (!isPathWithinRoot(normalizedWorkspaceRoot, path.resolve(normalizedCwd))) {
+    return null;
+  }
+
+  const tokens = normalizeTrustedReadTokens(rawTokens);
+  if (!tokens || tokens.length === 0) {
+    return null;
+  }
+
+  const command = cleanText(tokens[0]);
+  if (!command || /^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(command)) {
+    return null;
+  }
+
+  const fileRefs = extractTrustedReadFileRefs(command, tokens, normalizedCwd, normalizedWorkspaceRoot);
+  if (!fileRefs) {
+    return null;
+  }
+
+  return {
+    command,
+    commandText: normalizedCommandText,
+    fileRefs,
+  };
+}
+
 function unwrapShellCommand(commandText) {
   const normalized = String(commandText || "").trim();
   if (!normalized) {
@@ -848,6 +1461,14 @@ function extractReadFileRefsFromCommand(commandText) {
   return [];
 }
 
+function autoPilotApprovalMessage(locale, commandText) {
+  const prefix = t(locale, "server.message.autoPilotTrustedReadApproved");
+  const commandBlock = cleanText(commandText || "")
+    ? `${t(locale, "server.message.commandLabel")}\n\`\`\`sh\n${cleanText(commandText || "")}\n\`\`\``
+    : "";
+  return [prefix, commandBlock].filter(Boolean).join("\n\n");
+}
+
 function extractUpdatedFileRefsByType(outputText, patchText = "") {
   const parsedSections = parseApplyPatchSections(patchText);
   if (parsedSections.length > 0) {
@@ -2195,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");
 }
 
@@ -2209,15 +2831,23 @@ function normalizeHistoryItems(rawItems, maxItems) {
     .sort((left, right) => Number(right.createdAtMs ?? 0) - Number(left.createdAtMs ?? 0));
   const deduped = [];
   const seen = new Set();
+  const perProviderCount = {};
+  const knownProviders = new Set(["codex", "claude", "moltbook", "a2a", "viveworker"]);
   for (const item of normalized) {
     if (seen.has(item.stableId)) {
       continue;
     }
+    const provider = normalizeProvider(item.provider);
+    if (!knownProviders.has(provider)) {
+      knownProviders.add(provider);
+    }
+    const providerCount = perProviderCount[provider] ?? 0;
+    if (providerCount >= maxItems) {
+      continue;
+    }
     seen.add(item.stableId);
     deduped.push(item);
-    if (deduped.length >= maxItems) {
-      break;
-    }
+    perProviderCount[provider] = providerCount + 1;
   }
   return deduped;
 }
@@ -2226,6 +2856,9 @@ function normalizeHistoryItem(raw) {
   if (!isPlainObject(raw)) {
     return null;
   }
+  if (shouldHideInternalTimelineItem(raw)) {
+    return null;
+  }
 
   const stableId = cleanText(raw.stableId ?? raw.id ?? "");
   const kind = cleanText(raw.kind ?? "");
@@ -2237,8 +2870,10 @@ function normalizeHistoryItem(raw) {
   const threadLabel = skipHistoryThreadLabelRewrite
     ? rawThreadLabel
     : preferTitleOnlyJsonThreadLabel(rawThreadLabel, threadId, raw.messageText, raw.summary, raw.detailText, raw.message);
+  const rawTitle = cleanText(raw.title ?? "");
   const title =
-    cleanText(raw.title ?? "") || (threadLabel ? formatTitle(kindTitle(DEFAULT_LOCALE, kind), threadLabel) : kindTitle(DEFAULT_LOCALE, kind));
+    (!isFallbackTimelineTitle(rawTitle, kind, threadId) ? rawTitle : "") ||
+    (threadLabel ? formatTitle(kindTitle(DEFAULT_LOCALE, kind), threadLabel) : kindTitle(DEFAULT_LOCALE, kind));
   const messageText = normalizeTimelineMessageText(raw.messageText ?? "");
   const summary = normalizeNotificationText(raw.summary ?? "") || formatNotificationBody(messageText, 100) || "";
   const createdAtMs = Number(raw.createdAtMs) || Date.now();
@@ -2248,7 +2883,7 @@ function normalizeHistoryItem(raw) {
 
   const outcome = normalizeTimelineOutcome(raw.outcome ?? "") || inferTimelineOutcome(kind, summary, messageText);
 
-  return {
+  const normalized = {
     stableId,
     token: cleanText(raw.token ?? "") || historyToken(stableId),
     kind,
@@ -2276,6 +2911,7 @@ function normalizeHistoryItem(raw) {
     ...(raw.instruction != null ? { instruction: cleanText(raw.instruction) } : {}),
     ...(raw.taskStatus != null ? { taskStatus: cleanText(raw.taskStatus) } : {}),
   };
+  return shouldHideInternalTimelineItem(normalized) ? null : normalized;
 }
 
 function historyToken(stableId) {
@@ -2305,10 +2941,41 @@ function normalizeTimelineEntries(rawItems, maxItems) {
   const perProviderCount = {};
   const knownProviders = new Set(["codex", "claude", "moltbook", "a2a", "viveworker"]);
   const saturatedProviders = new Set();
+  // Content-based dedup for user_message entries: the same logical user turn
+  // can surface through two independent readers (rollout session files and
+  // ~/.codex/history.jsonl) that compute different stableIds
+  // (`user_message:<threadId>:<turn_id|ISO-ts>` vs
+  // `user_message:<threadId>:<integer-id|unix-seconds>`), so the stableId-only
+  // filter above doesn't catch them. Collapse entries with the same
+  // (threadId, messageText) pair when their createdAtMs are within 60 s —
+  // wide enough to absorb rollout-vs-history-file flush skew (we've seen
+  // several seconds in the wild) but narrow enough not to collapse a genuine
+  // repeat (e.g. user retries the same "run tests" command minutes apart).
+  // Literal here rather than a named const because this function is first
+  // called at top-level module init (line ~302) which runs before any const
+  // declared below would leave the TDZ.
+  const userMessageDedupWindowMs = 60_000;
+  const userMessageIndex = new Map();
   for (const item of normalized) {
     if (seen.has(item.stableId)) {
       continue;
     }
+    if (item.kind === "user_message") {
+      const threadKey = cleanText(item.threadId || "");
+      const textKey = cleanText(item.messageText || "");
+      if (threadKey && textKey) {
+        const key = `${threadKey}\u0001${textKey}`;
+        const existingMs = userMessageIndex.get(key);
+        const itemMs = Number(item.createdAtMs || 0);
+        if (
+          existingMs !== undefined &&
+          Math.abs(existingMs - itemMs) <= userMessageDedupWindowMs
+        ) {
+          continue;
+        }
+        userMessageIndex.set(key, itemMs);
+      }
+    }
     const prov = item.provider || "codex";
     if (saturatedProviders.has(prov)) {
       continue;
@@ -2352,6 +3019,7 @@ function migrateRecentCodeEventsState({ config, runtime, state }) {
   const previousItems = Array.isArray(state.recentCodeEvents) ? normalizeCodeEvents(state.recentCodeEvents, config.maxCodeEvents) : [];
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
+  invalidateDiffThreadGroupsCache();
   return JSON.stringify(nextItems) !== JSON.stringify(previousItems);
 }
 
@@ -2383,6 +3051,9 @@ function normalizeTimelineEntry(raw) {
   if (!isPlainObject(raw)) {
     return null;
   }
+  if (shouldHideInternalTimelineItem(raw)) {
+    return null;
+  }
 
   const stableId = cleanText(raw.stableId ?? raw.id ?? "");
   const kind = cleanText(raw.kind ?? "");
@@ -2420,14 +3091,15 @@ function normalizeTimelineEntry(raw) {
           raw.detailText,
           raw.message
         );
+  const rawTitle = cleanText(raw.title ?? "");
   const title =
-    cleanText(raw.title ?? "") ||
+    (!isFallbackTimelineTitle(rawTitle, kind, threadId) ? rawTitle : "") ||
     (kind === "file_event" ? fileEventTitle(DEFAULT_LOCALE, fileEventType) : "") ||
     threadLabel ||
     kindTitle(DEFAULT_LOCALE, kind);
   const outcome = normalizeTimelineOutcome(raw.outcome ?? "") || inferTimelineOutcome(kind, summary, messageText);
 
-  return {
+  const normalized = {
     stableId,
     token: cleanText(raw.token ?? "") || historyToken(stableId),
     kind,
@@ -2473,6 +3145,7 @@ function normalizeTimelineEntry(raw) {
     ...(raw.taskStatus != null ? { taskStatus: cleanText(raw.taskStatus) } : {}),
     ...(suggestions.length > 0 ? { suggestions } : {}),
   };
+  return shouldHideInternalTimelineItem(normalized) ? null : normalized;
 }
 
 function recordTimelineEntry({ config, runtime, state, entry }) {
@@ -2563,6 +3236,9 @@ function recordCodeEvent({ config, runtime, state, entry }) {
     );
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
+  if (changed) {
+    invalidateDiffThreadGroupsCache();
+  }
   return changed;
 }
 
@@ -2614,6 +3290,9 @@ function syncRecentCodeEventsFromTimeline({ config, runtime, state }) {
     );
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
+  if (changed) {
+    invalidateDiffThreadGroupsCache();
+  }
   return changed;
 }
 
@@ -2840,13 +3519,21 @@ function pendingChoiceStableId(userInputRequest) {
   return `choice:${userInputRequest.requestKey}`;
 }
 
-function buildAppItemUrl(config, kind, token) {
+function buildAppItemUrl(config, kind, token, options = {}) {
   const url = new URL(`${config.nativeApprovalPublicBaseUrl}/app`);
   url.searchParams.set("item", `${kind}:${token}`);
+  const tab = cleanText(options.tab || "");
+  const subtab = cleanText(options.subtab || "");
+  if (tab) {
+    url.searchParams.set("tab", tab);
+  }
+  if (subtab) {
+    url.searchParams.set("subtab", subtab);
+  }
   return url.toString();
 }
 
-function buildPushPayload({ config, kind, token, stableId, title, body }) {
+function buildPushPayload({ config, kind, token, stableId, title, body, tab = "", subtab = "" }) {
   return {
     title: withNotificationIcon(kind, title),
     body: formatNotificationBody(body, config.completionDetailThresholdChars) || body || title,
@@ -2855,7 +3542,7 @@ function buildPushPayload({ config, kind, token, stableId, title, body }) {
       kind,
       token,
       stableId,
-      url: buildAppItemUrl(config, kind, token),
+      url: buildAppItemUrl(config, kind, token, { tab, subtab }),
     },
   };
 }
@@ -2975,7 +3662,7 @@ function pushDeliveryKey(deviceId, stableId) {
   return `${cleanText(deviceId || "")}:${cleanText(stableId || "")}`;
 }
 
-async function deliverWebPushItem({ config, state, kind, token, stableId, title, body, buildLocalizedContent = null }) {
+async function deliverWebPushItem({ config, state, kind, token, stableId, title, body, tab = "", subtab = "", buildLocalizedContent = null }) {
   if (!config.webPushEnabled || config.dryRun) {
     return false;
   }
@@ -3010,6 +3697,8 @@ async function deliverWebPushItem({ config, state, kind, token, stableId, title,
           stableId,
           title: localizedContent?.title || title,
           body: localizedContent?.body || body,
+          tab,
+          subtab,
         })
       );
       await webPush.sendNotification(
@@ -3093,18 +3782,24 @@ 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.lastClaudeScanAt = now;
     }
+    let claudeSessionTitlesChanged = false;
     if (now - runtime.lastClaudeSessionTitleScanAt >= config.directoryScanIntervalMs) {
-      await refreshClaudeSessionTitles(runtime);
+      claudeSessionTitlesChanged = await refreshClaudeSessionTitles(runtime);
       runtime.lastClaudeSessionTitleScanAt = now;
     }
     for (const filePath of runtime.claudeKnownFiles) {
       const changed = await processClaudeTranscriptFile({ filePath, config, runtime, state, now });
+      claudeTranscriptChanged = claudeTranscriptChanged || changed;
       dirty = dirty || changed;
     }
+    if (claudeTranscriptChanged || claudeSessionTitlesChanged) {
+      dirty = refreshResolvedThreadLabels({ config, runtime, state }) || dirty;
+    }
   }
 
   if (config.webUiEnabled) {
@@ -3330,6 +4025,7 @@ function fileEventCallIdFromStableId(stableId) {
 }
 
 async function refreshClaudeSessionTitles(runtime) {
+  let changed = false;
   // Read ~/Library/Application Support/Claude/claude-code-sessions/*/*/local_*.json
   // Each file maps cliSessionId → title (auto-generated by Claude Desktop).
   const baseDir = path.join(
@@ -3367,7 +4063,10 @@ async function refreshClaudeSessionTitles(runtime) {
             const cliSessionId = cleanText(data?.cliSessionId || "");
             const title = cleanText(data?.title || "");
             if (cliSessionId && title) {
-              runtime.claudeSessionTitles.set(cliSessionId, title);
+              if (runtime.claudeSessionTitles.get(cliSessionId) !== title) {
+                runtime.claudeSessionTitles.set(cliSessionId, title);
+                changed = true;
+              }
             }
           } catch {
             // skip unreadable/invalid
@@ -3378,6 +4077,49 @@ async function refreshClaudeSessionTitles(runtime) {
   } catch {
     // base dir missing — Claude Desktop not installed
   }
+
+  for (const filePath of runtime.claudeKnownFiles ?? []) {
+    let lines;
+    try {
+      const raw = await fs.readFile(filePath, "utf8");
+      lines = raw.split("\n");
+    } catch {
+      continue;
+    }
+    for (const rawLine of lines) {
+      const trimmed = rawLine.trim();
+      if (!trimmed) continue;
+      let record;
+      try {
+        record = JSON.parse(trimmed);
+      } catch {
+        continue;
+      }
+      if (record?.entrypoint !== "sdk-cli" || record?.type !== "user") {
+        continue;
+      }
+      const threadId = cleanText(record?.sessionId || "");
+      const message = record?.message || {};
+      let text = "";
+      if (typeof message.content === "string") {
+        text = message.content;
+      } else if (Array.isArray(message.content)) {
+        for (const block of message.content) {
+          if (block?.type === "text" && block.text) {
+            text += block.text;
+          }
+        }
+      }
+      const derivedTitle = deriveClaudeSdkCliThreadLabel(text, threadId);
+      if (threadId && derivedTitle && runtime.claudeSessionTitles.get(threadId) !== derivedTitle) {
+        runtime.claudeSessionTitles.set(threadId, derivedTitle);
+        changed = true;
+      }
+      break;
+    }
+  }
+
+  return changed;
 }
 
 async function listClaudeTranscriptFiles(claudeProjectsDir) {
@@ -3497,8 +4239,10 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
       fileState.threadLabel = path.basename(record.cwd);
     }
 
-    // Only process Claude Desktop sessions
-    if (record.entrypoint !== "claude-desktop") continue;
+    // Accept both Claude Desktop sessions and the current sdk-cli sessions
+    // that Claude emits for agent-driven work. The latter regressed the
+    // timeline/completed views because they were silently skipped here.
+    if (record.entrypoint !== "claude-desktop" && record.entrypoint !== "sdk-cli") continue;
 
     const type = record.type;
     if (type !== "user" && type !== "assistant") continue;
@@ -3526,6 +4270,15 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
     }
     text = cleanText(text);
     if (!text) continue;
+    if (type === "user" && record.entrypoint === "sdk-cli") {
+      const derivedThreadLabel = deriveClaudeSdkCliThreadLabel(text, threadId);
+      if (derivedThreadLabel) {
+        fileState.threadLabel = derivedThreadLabel;
+        if (threadId) {
+          runtime.claudeSessionTitles.set(threadId, derivedThreadLabel);
+        }
+      }
+    }
     // Skip Claude Code internal system messages (task notifications, system
     // reminders, etc.) — these are XML-like tags injected into the
     // conversation that should not appear on the user-facing timeline.
@@ -3587,6 +4340,7 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
             config,
             state,
             kind: "assistant_final",
+            tab: "timeline",
             token: entry.token,
             stableId: entry.stableId,
             title: threadLabel || "Claude",
@@ -3608,6 +4362,129 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
   return dirty;
 }
 
+async function loadRecoveryBackupState(stateFile) {
+  const dir = path.dirname(stateFile);
+  const base = path.basename(stateFile);
+  let entries;
+  try {
+    entries = await fs.readdir(dir, { withFileTypes: true });
+  } catch {
+    return null;
+  }
+
+  const candidates = [];
+  for (const entry of entries) {
+    if (!entry.isFile()) continue;
+    if (!entry.name.startsWith(`${base}.bak-`)) continue;
+    const filePath = path.join(dir, entry.name);
+    try {
+      const stat = await fs.stat(filePath);
+      candidates.push({ filePath, mtimeMs: Number(stat.mtimeMs) || 0 });
+    } catch {
+      // ignore unreadable backup
+    }
+  }
+
+  candidates.sort((left, right) => right.mtimeMs - left.mtimeMs);
+  for (const candidate of candidates) {
+    try {
+      const raw = await fs.readFile(candidate.filePath, "utf8");
+      return JSON.parse(raw);
+    } catch {
+      // try next backup
+    }
+  }
+  return null;
+}
+
+function providerSetForItems(items) {
+  return new Set(
+    (Array.isArray(items) ? items : [])
+      .map((item) => normalizeProvider(item?.provider))
+      .filter(Boolean)
+  );
+}
+
+function missingRecoveryProviders(items) {
+  const present = providerSetForItems(items);
+  return ["claude", "a2a"].filter((provider) => !present.has(provider));
+}
+
+function selectRecoveryItems(items, missingProviders) {
+  const wanted = new Set(missingProviders);
+  return (Array.isArray(items) ? items : []).filter((item) => wanted.has(normalizeProvider(item?.provider)));
+}
+
+async function recoverMissingProviderStateFromBackup({ config, runtime, state }) {
+  const missingHistoryProviders = missingRecoveryProviders(state.recentHistoryItems ?? runtime.recentHistoryItems);
+  const missingTimelineProviders = missingRecoveryProviders(state.recentTimelineEntries ?? runtime.recentTimelineEntries);
+  const shouldRecoverCodeEvents = !Array.isArray(state.recentCodeEvents) || state.recentCodeEvents.length === 0;
+
+  if (missingHistoryProviders.length === 0 && missingTimelineProviders.length === 0 && !shouldRecoverCodeEvents) {
+    return false;
+  }
+
+  const backup = await loadRecoveryBackupState(config.stateFile);
+  if (!backup) {
+    return false;
+  }
+
+  let changed = false;
+
+  if (missingHistoryProviders.length > 0) {
+    const mergedHistory = normalizeHistoryItems(
+      [
+        ...(state.recentHistoryItems ?? runtime.recentHistoryItems ?? []),
+        ...selectRecoveryItems(backup.recentHistoryItems, missingHistoryProviders),
+      ],
+      config.maxHistoryItems
+    );
+    if (JSON.stringify(mergedHistory) !== JSON.stringify(state.recentHistoryItems ?? runtime.recentHistoryItems ?? [])) {
+      state.recentHistoryItems = mergedHistory;
+      runtime.recentHistoryItems = mergedHistory;
+      changed = true;
+    }
+  }
+
+  if (missingTimelineProviders.length > 0) {
+    const mergedTimeline = normalizeTimelineEntries(
+      [
+        ...(state.recentTimelineEntries ?? runtime.recentTimelineEntries ?? []),
+        ...selectRecoveryItems(backup.recentTimelineEntries, missingTimelineProviders),
+      ],
+      config.maxTimelineEntries
+    );
+    if (JSON.stringify(mergedTimeline) !== JSON.stringify(state.recentTimelineEntries ?? runtime.recentTimelineEntries ?? [])) {
+      state.recentTimelineEntries = mergedTimeline;
+      runtime.recentTimelineEntries = mergedTimeline;
+      changed = true;
+    }
+  }
+
+  if (shouldRecoverCodeEvents) {
+    const mergedCodeEvents = normalizeCodeEvents(
+      [
+        ...(state.recentCodeEvents ?? runtime.recentCodeEvents ?? []),
+        ...(Array.isArray(backup.recentCodeEvents) ? backup.recentCodeEvents : []),
+      ],
+      config.maxCodeEvents
+    );
+    if (JSON.stringify(mergedCodeEvents) !== JSON.stringify(state.recentCodeEvents ?? runtime.recentCodeEvents ?? [])) {
+      state.recentCodeEvents = mergedCodeEvents;
+      runtime.recentCodeEvents = mergedCodeEvents;
+      invalidateDiffThreadGroupsCache();
+      changed = true;
+    }
+  }
+
+  if (changed) {
+    console.log(
+      `[state-recovery] recovered history=${missingHistoryProviders.join(",") || "none"} timeline=${missingTimelineProviders.join(",") || "none"} code=${shouldRecoverCodeEvents ? "yes" : "no"}`
+    );
+  }
+  return changed;
+}
+
 async function processSqliteCompletionLog({ config, runtime, state, now }) {
   const logsDbFile = cleanText(runtime.logsDbFile || config.codexLogsDbFile || "");
   if (!logsDbFile) {
@@ -4800,6 +5677,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") {
@@ -4826,6 +5709,8 @@ async function processScannedEvent({ config, runtime, state, event }) {
         config,
         state,
         kind: "completion",
+        tab: "inbox",
+        subtab: "completed",
         token: historyToken(event.id),
         stableId: event.id,
         title: event.title,
@@ -5134,6 +6019,28 @@ async function syncNativeApprovals({ config, runtime, state, conversationId, pre
         request,
         approval: existing,
       });
+      const existingAutoPilotWriteCandidate =
+        existing.kind === "file"
+          ? maybeAutoApproveTrustedWriteCandidate({ runtime, state, approval: existing })
+          : null;
+      if (existingAutoPilotWriteCandidate) {
+        try {
+          await autoApproveTrustedWrite({
+            config,
+            runtime,
+            state,
+            approval: existing,
+            candidate: existingAutoPilotWriteCandidate,
+          });
+          continue;
+        } catch (error) {
+          existing.resolved = false;
+          existing.resolving = false;
+          runtime.nativeApprovalsByRequestKey.set(requestKey, existing);
+          runtime.nativeApprovalsByToken.set(existing.token, existing);
+          console.error(`[auto-pilot-write-error] ${requestKey} | ${error.message}`);
+        }
+      }
       if (changed) {
         const fileKeys = isPlainObject(existing.rawParams) ? Object.keys(existing.rawParams).join(",") : "";
         console.log(
@@ -5156,6 +6063,57 @@ async function syncNativeApprovals({ config, runtime, state, conversationId, pre
     runtime.nativeApprovalsByRequestKey.set(requestKey, approval);
     runtime.nativeApprovalsByToken.set(approval.token, approval);
 
+    const nativeAutoPilotMatch =
+      approval.kind === "command"
+        ? maybeAutoApproveTrustedRead({
+            state,
+            commandText: approval.rawParams?.command ?? approval.rawParams?.cmd ?? "",
+            cwd: approval.rawParams?.cwd ?? approval.rawParams?.grantRoot ?? "",
+            workspaceRoot: approval.rawParams?.grantRoot ?? approval.rawParams?.cwd ?? "",
+          })
+        : null;
+    if (nativeAutoPilotMatch) {
+      try {
+        await autoApproveTrustedRead({
+          config,
+          runtime,
+          state,
+          approval,
+          policyMatch: nativeAutoPilotMatch,
+        });
+        continue;
+      } catch (error) {
+        approval.resolved = false;
+        approval.resolving = false;
+        runtime.nativeApprovalsByRequestKey.set(requestKey, approval);
+        runtime.nativeApprovalsByToken.set(approval.token, approval);
+        console.error(`[auto-pilot-error] ${requestKey} | ${error.message}`);
+      }
+    }
+
+    const nativeAutoPilotWriteCandidate =
+      approval.kind === "file"
+        ? maybeAutoApproveTrustedWriteCandidate({ runtime, state, approval })
+        : null;
+    if (nativeAutoPilotWriteCandidate) {
+      try {
+        await autoApproveTrustedWrite({
+          config,
+          runtime,
+          state,
+          approval,
+          candidate: nativeAutoPilotWriteCandidate,
+        });
+        continue;
+      } catch (error) {
+        approval.resolved = false;
+        approval.resolving = false;
+        runtime.nativeApprovalsByRequestKey.set(requestKey, approval);
+        runtime.nativeApprovalsByToken.set(approval.token, approval);
+        console.error(`[auto-pilot-write-error] ${requestKey} | ${error.message}`);
+      }
+    }
+
     if (previousKeys.has(requestKey)) {
       const fileKeys = isPlainObject(approval.rawParams) ? Object.keys(approval.rawParams).join(",") : "";
       console.log(
@@ -5187,6 +6145,8 @@ async function syncNativeApprovals({ config, runtime, state, conversationId, pre
         config,
         state,
         kind: "approval",
+        tab: "inbox",
+        subtab: "pending",
         token: approval.token,
         stableId: pendingApprovalStableId(approval),
         title: approval.title,
@@ -5310,6 +6270,8 @@ async function syncPlanImplementationRequests({
           config,
           state,
           kind: "plan",
+          tab: "inbox",
+          subtab: "pending",
           token: planRequest.token,
           stableId: pendingPlanStableId(planRequest),
           title: planRequest.title,
@@ -5515,6 +6477,8 @@ async function syncGenericUserInputRequests({
           config,
           state,
           kind: "choice",
+          tab: "inbox",
+          subtab: "pending",
           token: userInputRequest.token,
           stableId: pendingChoiceStableId(userInputRequest),
           title: userInputRequest.title,
@@ -5578,6 +6542,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) {
@@ -5633,6 +6741,8 @@ async function buildNativeApprovalPayload({ config, runtime, conversationId, req
     ownerClientId: runtime.threadOwnerClientIds.get(conversationId) ?? null,
     approvalIds,
     rawParams,
+    cwd: cleanText(rawParams?.cwd ?? rawParams?.grantRoot ?? ""),
+    workspaceRoot: cleanText(rawParams?.grantRoot ?? rawParams?.cwd ?? ""),
     fileRefs: normalizeTimelineFileRefs(mergedDelta?.fileRefs ?? []),
     diffText: normalizeTimelineDiffText(mergedDelta?.diffText ?? ""),
     diffAvailable: Boolean(mergedDelta?.diffAvailable),
@@ -5669,6 +6779,8 @@ async function refreshNativeApprovalFromRequest({ config, runtime, conversationI
     ownerClientId: approval.ownerClientId,
     approvalIds: approval.approvalIds,
     rawParams: approval.rawParams,
+    cwd: approval.cwd,
+    workspaceRoot: approval.workspaceRoot,
     fileRefs: normalizeTimelineFileRefs(approval.fileRefs ?? []),
     diffText: normalizeTimelineDiffText(approval.diffText ?? ""),
     diffAvailable: Boolean(approval.diffAvailable),
@@ -5688,6 +6800,8 @@ async function refreshNativeApprovalFromRequest({ config, runtime, conversationI
   approval.ownerClientId = payload.ownerClientId;
   approval.approvalIds = payload.approvalIds;
   approval.rawParams = payload.rawParams;
+  approval.cwd = payload.cwd;
+  approval.workspaceRoot = payload.workspaceRoot;
   approval.fileRefs = payload.fileRefs;
   approval.diffText = payload.diffText;
   approval.diffAvailable = payload.diffAvailable;
@@ -5707,6 +6821,8 @@ async function refreshNativeApprovalFromRequest({ config, runtime, conversationI
     ownerClientId: approval.ownerClientId,
     approvalIds: approval.approvalIds,
     rawParams: approval.rawParams,
+    cwd: approval.cwd,
+    workspaceRoot: approval.workspaceRoot,
     fileRefs: normalizeTimelineFileRefs(approval.fileRefs ?? []),
     diffText: normalizeTimelineDiffText(approval.diffText ?? ""),
     diffAvailable: Boolean(approval.diffAvailable),
@@ -7767,6 +8883,121 @@ function getNativeThreadLabel({ runtime, conversationId, cwd }) {
   return shortId(normalizedConversationId) || t(DEFAULT_LOCALE, "server.fallback.codexTask", { provider: providerDisplayName(DEFAULT_LOCALE, "codex") });
 }
 
+function isFallbackConversationLabel(label, conversationId) {
+  const normalizedLabel = cleanText(label || "");
+  const normalizedConversationId = cleanText(conversationId || "");
+  if (!normalizedLabel) {
+    return true;
+  }
+  if (normalizedConversationId && normalizedLabel === shortId(normalizedConversationId)) {
+    return true;
+  }
+  return false;
+}
+
+function deriveClaudeSdkCliThreadLabel(messageText, conversationId = "") {
+  const cleaned = stripNotificationMarkup(stripEnvironmentContextBlocks(messageText || ""));
+  const single = cleanText(cleaned);
+  if (!single || /^\d+$/u.test(single)) {
+    return "";
+  }
+
+  if (/^You are scoring Moltbook posts? for an AI agent\b/iu.test(single)) {
+    return "Moltbook scoring";
+  }
+  if (/^Codex from another agent:/iu.test(single)) {
+    return truncate(cleanText(single.replace(/^Codex from another agent:\s*/iu, "")), 90) || "Cross-agent task";
+  }
+
+  const firstSentence = cleanText(single.split(/(?<=[.!?。！？])\s+/u)[0] || "");
+  const candidate = firstSentence || single;
+  if (!candidate || candidate === shortId(conversationId)) {
+    return "";
+  }
+  return truncate(candidate, 90);
+}
+
+function isHiddenClaudeInternalScoringText(text) {
+  const single = cleanText(stripNotificationMarkup(stripEnvironmentContextBlocks(text || "")));
+  if (!single) {
+    return false;
+  }
+  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;
+  }
+  if (normalizeProvider(item.provider) !== "claude") {
+    return false;
+  }
+  const threadLabel = cleanText(item.threadLabel ?? "");
+  if (threadLabel === "Moltbook scoring") {
+    return true;
+  }
+  return (
+    isHiddenClaudeInternalScoringText(item.messageText) ||
+    isHiddenClaudeInternalScoringText(item.summary) ||
+    isHiddenClaudeInternalScoringText(item.detailText) ||
+    isHiddenClaudeInternalScoringText(item.message)
+  );
+}
+
+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 "";
@@ -8724,6 +9955,8 @@ function markDevicePaired(state, config, deviceId, metadata = {}, now = Date.now
   return JSON.stringify(previous ?? null) !== JSON.stringify(next);
 }
 
+const TOUCH_DEVICE_TRUST_DEBOUNCE_MS = 60_000;
+
 function touchDeviceTrust(state, config, deviceId, now = Date.now()) {
   const normalizedDeviceId = cleanText(deviceId || "");
   const current = getActiveDeviceTrustRecord(state, config, normalizedDeviceId, now);
@@ -8731,6 +9964,20 @@ function touchDeviceTrust(state, config, deviceId, now = Date.now()) {
     return false;
   }
 
+  // Debounce: `lastAuthenticatedAtMs` is bumped to `now` on every
+  // authenticated request. Without this guard, every `/api/session`
+  // (and `/api/bootstrap`) call flags the record as "changed" and the
+  // caller runs a full `saveState`, which synchronously stringifies an
+  // 8+ MB state.json on the main thread and starves the event loop —
+  // driving TLS handshake latency for any in-flight connection into the
+  // seconds range. Skip the write when we've touched it recently; the
+  // next real change (pairing, revocation, locale update, etc.) still
+  // goes through unchanged.
+  const previousTouch = Number(current.lastAuthenticatedAtMs) || 0;
+  if (previousTouch > 0 && now - previousTouch < TOUCH_DEVICE_TRUST_DEBOUNCE_MS) {
+    return false;
+  }
+
   const next = {
     ...current,
     lastAuthenticatedAtMs: now,
@@ -8853,11 +10100,27 @@ function buildDeviceSummary({ config, state, deviceId, record, currentDeviceId,
   };
 }
 
-function buildDevicesResponse({ config, state, session, locale }) {
+// Shared between `/api/session` and `/api/bootstrap` so both return an
+// identical session shape.
+function buildSessionPayload({ config, state, session }) {
   return {
-    devices: activeTrustedDevices(state, config).map(({ deviceId, record }) =>
-      buildDeviceSummary({
-        config,
+    authenticated: Boolean(session.authenticated),
+    expiresAtMs: Number(session.expiresAtMs) || 0,
+    pairingAvailable: isPairingAvailableForState(config, state),
+    webPushEnabled: config.webPushEnabled,
+    httpsEnabled: config.nativeApprovalPublicBaseUrl.startsWith("https://"),
+    appVersion: appPackageVersion,
+    deviceId: session.deviceId || null,
+    temporaryPairing: session.temporaryPairing === true,
+    ...buildSessionLocalePayload(config, state, session.deviceId),
+  };
+}
+
+function buildDevicesResponse({ config, state, session, locale }) {
+  return {
+    devices: activeTrustedDevices(state, config).map(({ deviceId, record }) =>
+      buildDeviceSummary({
+        config,
         state,
         deviceId,
         record,
@@ -9448,7 +10711,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,
@@ -9608,7 +10873,7 @@ function buildCompletedInboxItems(runtime, state, config, locale) {
 }
 
 async function buildDiffInboxItems(runtime, state, config, locale) {
-  return (await buildDiffThreadGroups(runtime, state, config)).map((group) => ({
+  return (await getDiffThreadGroupsCached(runtime, state, config)).map((group) => ({
     kind: "diff_thread",
     token: group.token,
     threadId: group.threadId,
@@ -9767,14 +11032,24 @@ async function buildDiffThreadGroups(runtime, state, config) {
     .sort((left, right) => Number(right.latestChangedAtMs ?? 0) - Number(left.latestChangedAtMs ?? 0));
 }
 
-async function buildInboxResponse(runtime, state, config, locale) {
+// Split into two halves so `/api/inbox` (pending + completed) returns
+// without waiting on the diff build, which spawns `git` subprocesses per
+// tracked repo inside `buildCurrentUnstagedChangesForRepo`. The diff half
+// is served from `/api/inbox/diff` and fetched separately by the PWA so
+// it doesn't block first paint of the inbox/completed lists.
+function buildInboxFastResponse(runtime, state, config, locale) {
   return {
     pending: buildPendingInboxItems(runtime, state, config, locale),
-    diff: await buildDiffInboxItems(runtime, state, config, locale),
     completed: buildCompletedInboxItems(runtime, state, config, locale),
   };
 }
 
+async function buildInboxDiffResponse(runtime, state, config, locale) {
+  return {
+    diff: await buildDiffInboxItems(runtime, state, config, locale),
+  };
+}
+
 function buildOperationalTimelineEntries(runtime, state, config, locale) {
   const now = Date.now();
   const items = [];
@@ -9790,7 +11065,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",
@@ -9988,15 +11265,18 @@ function buildTimelineResponse(runtime, state, config, locale) {
   };
 }
 
-function buildPendingApprovalDetail(runtime, approval, locale) {
+function buildPendingApprovalDetail(runtime, state, approval, locale) {
   const previousContext = buildPreviousApprovalContext(runtime, approval);
   const approvalKind = cleanText(approval.kind || "");
+  const autoPilotReview = buildAutoPilotManualReview(runtime, state, approval, locale);
   const detail = {
     kind: "approval",
     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>`),
@@ -10007,13 +11287,18 @@ function buildPendingApprovalDetail(runtime, approval, locale) {
     diffAddedLines: Math.max(0, Number(approval.diffAddedLines) || 0),
     diffRemovedLines: Math.max(0, Number(approval.diffRemovedLines) || 0),
     previousContext,
+    autoPilotReview,
     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.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 || "");
@@ -10031,6 +11316,193 @@ function buildPendingApprovalDetail(runtime, approval, locale) {
   return detail;
 }
 
+function buildAutoPilotManualReview(runtime, state, approval, locale) {
+  if (!isPlainObject(approval) || approval.readOnly === true) {
+    return null;
+  }
+  if (cleanText(approval.kind || "") !== "file") {
+    return null;
+  }
+  return buildAutoPilotWriteManualReview(runtime, state, approval, locale);
+}
+
+function buildAutoPilotWriteManualReview(runtime, state, approval, locale) {
+  const writesEnabled = isAutoPilotTrustedWritesEnabled(state);
+  if (!writesEnabled) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDisabled"),
+    };
+  }
+
+  const cwd = cleanText(approval?.cwd || approval?.rawParams?.cwd || approval?.rawParams?.grantRoot || "");
+  const workspaceRoot = cleanText(approval?.workspaceRoot || approval?.rawParams?.grantRoot || cwd);
+  if (!cwd || !workspaceRoot) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingWorkspace"),
+    };
+  }
+
+  const diffText = normalizeTimelineDiffText(approval?.diffText ?? "");
+  if (!diffText) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingDiff"),
+    };
+  }
+
+  const rawFileRefs = normalizeTimelineFileRefs(approval?.fileRefs ?? []);
+  if (rawFileRefs.length === 0) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingFiles"),
+    };
+  }
+
+  const resolvedFileRefs = resolveTrustedWriteFileRefs({
+    fileRefs: approval?.fileRefs ?? [],
+    cwd,
+    workspaceRoot,
+  });
+  if (!resolvedFileRefs) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeInvalidFiles"),
+    };
+  }
+
+  const counts = diffLineCounts(diffText);
+  const totalChangedLines =
+    Math.max(0, Number(counts.addedLines) || 0) +
+    Math.max(0, Number(counts.removedLines) || 0);
+  if (totalChangedLines === 0) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingDiff"),
+    };
+  }
+  if (totalChangedLines > 120) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDiffTooLarge"),
+    };
+  }
+
+  const diffSections = splitUnifiedDiffTextByFile(diffText);
+  if (diffSections.length === 0) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDiffUnreadable"),
+    };
+  }
+  if (diffSections.length > 3) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDiffTooLarge"),
+    };
+  }
+
+  if (
+    /^(?:new file mode|deleted file mode|rename from|rename to|old mode|new mode|similarity index|dissimilarity index|GIT binary patch|Binary files )/mu.test(diffText)
+  ) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDangerousDiff"),
+    };
+  }
+
+  const diffSectionRefs = resolveTrustedWriteDiffSectionFileRefs({
+    diffSections,
+    cwd,
+    workspaceRoot,
+  });
+  if (!diffSectionRefs || !sameNormalizedFileRefSet(diffSectionRefs, resolvedFileRefs)) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDiffMismatch"),
+    };
+  }
+
+  const lanes = autoPilotWriteLaneState(state);
+  const isContentOnly = resolvedFileRefs.every((fileRef) => isAutoPilotContentWritePath(fileRef));
+  if (isContentOnly) {
+    if (!lanes.content) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeContentDisabled"),
+      };
+    }
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeNoLaneMatch"),
+    };
+  }
+
+  const isUiTestsOnly = resolvedFileRefs.every((fileRef) => isAutoPilotUiTestWritePath(fileRef));
+  if (isUiTestsOnly) {
+    if (!lanes.uiTests) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeUiDisabled"),
+      };
+    }
+    if (totalChangedLines > 80) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeUiTooLarge"),
+      };
+    }
+    if (hasUnsafeUiOrTestWriteDiff(diffText)) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeUiUnsafe"),
+      };
+    }
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeNoLaneMatch"),
+    };
+  }
+
+  const isSourceOnly = resolvedFileRefs.every((fileRef) => isAutoPilotSourceWritePath(fileRef));
+  if (isSourceOnly) {
+    if (!lanes.source) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeSourceDisabled"),
+      };
+    }
+    if (totalChangedLines > 40) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeSourceTooLarge"),
+      };
+    }
+    if (hasUnsafeSourceWriteDiff(diffText)) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeSourceUnsafe"),
+      };
+    }
+    if (!hasRecentSourceReadContinuity({ runtime, state, approval, resolvedFileRefs })) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeSourceContinuity"),
+      };
+    }
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeNoLaneMatch"),
+    };
+  }
+
+  return {
+    title: t(locale, "detail.autoPilot.manualTitle"),
+    body: t(locale, "detail.autoPilot.writeNoLaneMatch"),
+  };
+}
+
 function buildPreviousApprovalContext(runtime, approval) {
   const threadId = cleanText(approval?.conversationId || "");
   const approvalCreatedAtMs = Number(approval?.createdAtMs) || 0;
@@ -10993,142 +12465,668 @@ function findClaudePendingApprovalForTool(runtime, threadId, toolName, fingerpri
   return match;
 }
 
-async function handleNativeApprovalDecision({ config, runtime, state, approval, decision }) {
-  if (approval.resolveClaudeWaiter) {
-    if (approval.provider === "claude" && approval.kind === "plan") {
-      // ExitPlanMode cannot be truly auto-approved via permissionDecision: "allow"
-      // (Claude still shows the native PC plan dialog). Instead, deny the tool
-      // call with a reason that tells Claude the user already decided on mobile.
-      approval.resolveClaudeWaiter({
-        permissionDecision: "deny",
-        permissionDecisionReason:
-          decision === "accept"
-            ? "User approved the plan via the viveworker mobile app. Proceed with implementing the plan exactly as proposed and do not call ExitPlanMode again."
-            : "User rejected the plan via the viveworker mobile app. Revise the plan based on the conversation context before calling ExitPlanMode again.",
-      });
-    } else {
-      approval.resolveClaudeWaiter(decision);
-    }
-  } else if (approval.provider === "claude") {
-    // notifyOnly Claude approvals have no long-poll waiter and no ipcClient
-    // back-channel — the desktop user already answered. Nothing to send.
-  } else {
-    await runtime.ipcClient?.sendApprovalDecision(approval, decision);
-  }
-  approval.resolved = true;
-  approval.resolving = false;
-  runtime.nativeApprovalsByToken.delete(approval.token);
-  runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
-  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(decision, config.defaultLocale, approval.provider)}\n\n${approval.messageText}`,
-    summary: formatNotificationBody(approval.messageText, 160) || approvalDecisionMessage(decision, config.defaultLocale, approval.provider),
-    fileRefs: normalizeTimelineFileRefs(approval.fileRefs ?? []),
-    diffText: normalizeTimelineDiffText(approval.diffText ?? ""),
-    diffSource: normalizeTimelineDiffSource(approval.diffSource ?? ""),
-    diffAvailable: approval.diffAvailable === true || Boolean(approval.diffText),
-    diffAddedLines: Math.max(0, Number(approval.diffAddedLines) || 0),
-    diffRemovedLines: Math.max(0, Number(approval.diffRemovedLines) || 0),
-    outcome: decision === "accept" ? "approved" : "rejected",
-    provider: approval.provider || "codex",
-  });
-  if (stateChanged) {
-    await saveState(config.stateFile, state);
+function maybeAutoApproveTrustedRead({ state, commandText, cwd, workspaceRoot }) {
+  if (state?.autoPilotTrustedReads !== true) {
+    return null;
   }
-  console.log(`[native-decision] ${approval.requestKey} | ${decision}`);
+  return evaluateTrustedReadCommandPolicy({ commandText, cwd, workspaceRoot });
 }
 
-async function buildApiItemDetail({ config, runtime, state, kind, token, locale }) {
-  if (kind === "diff_thread") {
-    const group = (await buildDiffThreadGroups(runtime, state, config)).find((entry) => entry.token === token);
-    return group ? buildDiffThreadDetail(group, locale) : null;
+function isAutoPilotTrustedWritesEnabled(state) {
+  return hasAnyAutoPilotWriteLaneEnabled(state);
+}
+
+function isDeniedTrustedWritePath(candidatePath) {
+  const normalized = cleanText(candidatePath || "");
+  if (!normalized) {
+    return true;
   }
-  if (kind === "file_event") {
-    const entry = timelineEntryByToken(runtime, token, kind);
-    return entry ? buildTimelineFileEventDetail(entry, locale) : null;
+  const lower = normalized.toLowerCase();
+  const segments = lower.split(/[\\/]+/u).filter(Boolean);
+  const basename = segments[segments.length - 1] || "";
+  if (isSensitiveCommandPath(normalized)) {
+    return true;
   }
-  if (kind === "ambient_suggestions") {
-    const entry = timelineEntryByToken(runtime, token, kind);
-    if (entry) {
-      return buildAmbientSuggestionsDetail(entry, locale);
-    }
-    const historicalSource = (runtime.recentHistoryItems ?? []).find((item) => {
-      if (cleanText(item?.token || "") !== cleanText(token || "")) {
-        return false;
-      }
-      const itemKind = cleanText(item?.kind || "");
-      if (itemKind !== "assistant_final" && itemKind !== "completion") {
-        return false;
-      }
-      return parseAmbientSuggestionsPayload(item?.messageText ?? "") !== null;
-    });
-    if (!historicalSource) {
-      return null;
-    }
-    return buildAmbientSuggestionsDetail({
-      token: historicalSource.token,
-      threadId: historyItemThreadId(historicalSource),
-      threadLabel: historicalSource.threadLabel,
-      title: kindTitle(locale, "ambient_suggestions"),
-      createdAtMs: historicalSource.createdAtMs,
-      suggestions: parseAmbientSuggestionsPayload(historicalSource.messageText ?? "") ?? [],
-    }, locale);
+  if (segments.some((segment) => [".github", ".gitlab", ".terraform", ".claude", ".husky", ".vscode"].includes(segment))) {
+    return true;
   }
-  if (timelineMessageKinds.has(kind)) {
-    const entry = timelineEntryByToken(runtime, token, kind);
-    if (!entry) return null;
-    const detail = buildTimelineMessageDetail(entry, locale, runtime);
-    // Add reply support for Codex assistant_final entries only (replaces completion reply).
-    // Check directly against timeline entries (not history items) to avoid
-    // maxHistoryItems eviction issues.
-    if (kind === "assistant_final") {
-      const entryProvider = normalizeProvider(entry.provider);
-      if (entryProvider === "codex" && runtime?.ipcClient) {
-        const entryThreadId = cleanText(entry.threadId || "");
-        const entryTs = Number(entry.createdAtMs) || 0;
-        let isLatestForThread = true;
-        for (const other of runtime.recentTimelineEntries) {
-          if (other.kind === "assistant_final" &&
-            cleanText(other.threadId || "") === entryThreadId &&
-            (Number(other.createdAtMs) || 0) > entryTs) {
-            isLatestForThread = false;
-            break;
-          }
-        }
-        if (isLatestForThread) {
-          detail.reply = { enabled: true, supportsPlanMode: true, supportsImages: true };
-          detail.provider = entryProvider;
-        }
-      }
-    }
-    return detail;
+  if (
+    [
+      "package.json",
+      "package-lock.json",
+      "pnpm-lock.yaml",
+      "yarn.lock",
+      "bun.lockb",
+      "cargo.toml",
+      "cargo.lock",
+      "gemfile",
+      "gemfile.lock",
+      "podfile",
+      "podfile.lock",
+      "composer.json",
+      "composer.lock",
+      "pipfile",
+      "pipfile.lock",
+      "poetry.lock",
+      "requirements.txt",
+      "dockerfile",
+      "wrangler.toml",
+      "tsconfig.json",
+      "tsconfig.tsbuildinfo",
+    ].includes(basename)
+  ) {
+    return true;
   }
-  if (kind === "approval") {
-    const approval = runtime.nativeApprovalsByToken.get(token);
-    if (approval) {
-      return buildPendingApprovalDetail(runtime, approval, locale);
-    }
-    const historicalApproval = historyItemByToken(runtime, kind, token);
-    return historicalApproval ? buildHistoryDetail(historicalApproval, locale, runtime) : null;
+  return false;
+}
+
+function isAutoPilotContentWritePath(candidatePath) {
+  const normalized = cleanText(candidatePath || "");
+  if (!normalized || isDeniedTrustedWritePath(normalized)) {
+    return false;
   }
-  if (kind === "plan") {
-    const planRequest = runtime.planRequestsByToken.get(token);
-    if (planRequest && !planRequest.resolved && !isPlanRequestExpired(planRequest)) {
-      return buildPendingPlanDetail(planRequest, locale);
-    }
-    const historicalPlan = historyItemByToken(runtime, kind, token);
-    return historicalPlan ? buildHistoryDetail(historicalPlan, locale, runtime) : null;
+  const lower = normalized.toLowerCase();
+  const segments = lower.split(/[\\/]+/u).filter(Boolean);
+  const basename = segments[segments.length - 1] || "";
+  const extension = path.extname(basename);
+  if ([".md", ".mdx", ".txt", ".rst", ".adoc"].includes(extension)) {
+    return true;
   }
-  if (kind === "choice") {
-    const userInputRequest = findLatestPersistedUserInputRequest({ config, runtime, state, token });
-    if (userInputRequest && !userInputRequest.resolved && !isGenericUserInputRequestExpired(userInputRequest)) {
+  if (["license", "notice", "copying", "readme", "changelog", "contributing"].includes(path.basename(basename, extension))) {
+    return true;
+  }
+  if (segments.includes("i18n") && [".js", ".ts", ".json", ".yaml", ".yml"].includes(extension)) {
+    return true;
+  }
+  if (segments.includes("messages") && extension === ".json") {
+    return true;
+  }
+  return false;
+}
+
+function isAutoPilotUiTestWritePath(candidatePath) {
+  const normalized = cleanText(candidatePath || "");
+  if (!normalized || isDeniedTrustedWritePath(normalized)) {
+    return false;
+  }
+  const lower = normalized.toLowerCase();
+  const segments = lower.split(/[\\/]+/u).filter(Boolean);
+  const basename = segments[segments.length - 1] || "";
+  const extension = path.extname(basename);
+  if ([".css", ".scss", ".sass", ".less", ".styl", ".pcss"].includes(extension)) {
+    return true;
+  }
+  if (segments.includes("__tests__") || /\.(test|spec)\.[cm]?[jt]sx?$/u.test(basename)) {
+    return true;
+  }
+  if ((segments.includes("web") || segments.includes("components")) && [".js", ".jsx", ".ts", ".tsx", ".html"].includes(extension)) {
+    return true;
+  }
+  return false;
+}
+
+function isAutoPilotSourceWritePath(candidatePath) {
+  const normalized = cleanText(candidatePath || "");
+  if (!normalized || isDeniedTrustedWritePath(normalized)) {
+    return false;
+  }
+  if (isAutoPilotContentWritePath(normalized) || isAutoPilotUiTestWritePath(normalized)) {
+    return false;
+  }
+  const extension = path.extname(normalized.toLowerCase());
+  return [".js", ".jsx", ".ts", ".tsx", ".mjs", ".cjs"].includes(extension);
+}
+
+function extractAddedDiffLines(diffText) {
+  return normalizeTimelineDiffText(diffText)
+    .split("\n")
+    .filter((line) => line.startsWith("+") && !line.startsWith("+++"));
+}
+
+function addedDiffLinesContain(diffText, pattern) {
+  return extractAddedDiffLines(diffText).some((line) => pattern.test(line.slice(1)));
+}
+
+function hasUnsafeUiOrTestWriteDiff(diffText) {
+  const patterns = [
+    /\bprocess\.env\b/u,
+    /\b(?:child_process|spawn|exec|execFile|fork)\b/u,
+    /\bfs\.(?:write|append|rm|unlink|rename|chmod|chown|copyFile|cp)\b/u,
+    /\b(?:fetch|axios|XMLHttpRequest)\s*\(/u,
+    /\bcrypto\b/u,
+    /\b(?:secret|token|password|privateKey|credential)\b/iu,
+  ];
+  return (
+    addedDiffLinesContain(diffText, /^\s*(?:import\s|export\s+.*\s+from\s)/u) ||
+    addedDiffLinesContain(diffText, /\brequire\s*\(/u) ||
+    patterns.some((pattern) => addedDiffLinesContain(diffText, pattern))
+  );
+}
+
+function hasUnsafeSourceWriteDiff(diffText) {
+  const patterns = [
+    /\bprocess\.env\b/u,
+    /\b(?:child_process|spawn|exec|execFile|fork)\b/u,
+    /\bfs\.(?:write|append|rm|unlink|rename|chmod|chown|copyFile|cp)\b/u,
+    /\b(?:fetch|axios|XMLHttpRequest)\s*\(/u,
+    /\b(?:net|tls|dgram|http2?)\b/u,
+    /\bcrypto\b/u,
+    /\b(?:secret|token|password|privateKey|credential)\b/iu,
+  ];
+  return (
+    addedDiffLinesContain(diffText, /^\s*(?:import\s|export\s+.*\s+from\s)/u) ||
+    addedDiffLinesContain(diffText, /\brequire\s*\(/u) ||
+    patterns.some((pattern) => addedDiffLinesContain(diffText, pattern))
+  );
+}
+
+const AUTO_PILOT_SOURCE_CONTINUITY_WINDOW_MS = 15 * 60 * 1000;
+
+function isReadContinuityTimelineEntry(entry) {
+  if (!isPlainObject(entry)) {
+    return false;
+  }
+  if (cleanText(entry.kind || "") === "file_event" && cleanText(entry.fileEventType || "") === "read") {
+    return true;
+  }
+  return (
+    cleanText(entry.kind || "") === "approval" &&
+    cleanText(entry.outcome || "") === "approved" &&
+    !normalizeTimelineDiffText(entry.diffText ?? "") &&
+    normalizeTimelineFileRefs(entry.fileRefs ?? []).length > 0
+  );
+}
+
+function resolveRecentReadContinuityFileRefs({ entry, cwd, workspaceRoot }) {
+  const normalizedRefs = normalizeTimelineFileRefs(entry?.fileRefs ?? []);
+  if (normalizedRefs.length === 0) {
+    return [];
+  }
+  const resolvedRefs = [];
+  for (const fileRef of normalizedRefs) {
+    const resolved = resolveTrustedReadTargetPath({
+      token: fileRef,
+      cwd,
+      workspaceRoot,
+    });
+    if (resolved) {
+      resolvedRefs.push(resolved);
+    }
+  }
+  return normalizeTimelineFileRefs(resolvedRefs);
+}
+
+function hasRecentSourceReadContinuity({ runtime, state, approval, resolvedFileRefs }) {
+  const normalizedTargets = normalizeTimelineFileRefs(resolvedFileRefs ?? []);
+  if (normalizedTargets.length !== 1) {
+    return false;
+  }
+  const targetFileRef = normalizedTargets[0];
+  const conversationId = cleanText(approval?.conversationId || "");
+  const cwd = cleanText(approval?.cwd || approval?.rawParams?.cwd || approval?.rawParams?.grantRoot || "");
+  const workspaceRoot = cleanText(approval?.workspaceRoot || approval?.rawParams?.grantRoot || cwd);
+  if (!cwd || !workspaceRoot) {
+    return false;
+  }
+  const timelineEntries =
+    Array.isArray(runtime?.recentTimelineEntries) && runtime.recentTimelineEntries.length > 0
+      ? runtime.recentTimelineEntries
+      : normalizeTimelineEntries(state?.recentTimelineEntries ?? [], 40);
+  const now = Date.now();
+  for (const entry of timelineEntries) {
+    if (!isReadContinuityTimelineEntry(entry)) {
+      continue;
+    }
+    const createdAtMs = Number(entry?.createdAtMs) || 0;
+    if (!createdAtMs || now - createdAtMs > AUTO_PILOT_SOURCE_CONTINUITY_WINDOW_MS) {
+      continue;
+    }
+    const entryThreadId = cleanText(entry?.threadId || extractConversationIdFromStableId(entry?.stableId) || "");
+    if (conversationId && entryThreadId && entryThreadId !== conversationId) {
+      continue;
+    }
+    const entryFileRefs = resolveRecentReadContinuityFileRefs({
+      entry,
+      cwd,
+      workspaceRoot,
+    });
+    if (entryFileRefs.includes(targetFileRef)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+function classifyTrustedWriteLane({ runtime, state, approval, resolvedFileRefs, diffText, totalChangedLines }) {
+  const lanes = autoPilotWriteLaneState(state);
+  if (
+    lanes.content &&
+    resolvedFileRefs.length >= 1 &&
+    resolvedFileRefs.length <= 3 &&
+    totalChangedLines <= 120 &&
+    resolvedFileRefs.every((fileRef) => isAutoPilotContentWritePath(fileRef))
+  ) {
+    return "content";
+  }
+  if (
+    lanes.uiTests &&
+    resolvedFileRefs.length >= 1 &&
+    resolvedFileRefs.length <= 2 &&
+    totalChangedLines <= 80 &&
+    resolvedFileRefs.every((fileRef) => isAutoPilotUiTestWritePath(fileRef)) &&
+    !hasUnsafeUiOrTestWriteDiff(diffText)
+  ) {
+    return "ui_tests";
+  }
+  if (
+    lanes.source &&
+    resolvedFileRefs.length === 1 &&
+    totalChangedLines <= 40 &&
+    resolvedFileRefs.every((fileRef) => isAutoPilotSourceWritePath(fileRef)) &&
+    !hasUnsafeSourceWriteDiff(diffText) &&
+    hasRecentSourceReadContinuity({ runtime, state, approval, resolvedFileRefs })
+  ) {
+    return "source";
+  }
+  return "";
+}
+
+function resolveTrustedWriteFileRefs({ fileRefs, cwd, workspaceRoot }) {
+  const normalizedRefs = normalizeTimelineFileRefs(fileRefs ?? []);
+  if (normalizedRefs.length === 0 || normalizedRefs.length > 3) {
+    return null;
+  }
+  const resolvedRefs = [];
+  for (const fileRef of normalizedRefs) {
+    const resolved = resolveTrustedReadTargetPath({
+      token: fileRef,
+      cwd,
+      workspaceRoot,
+    });
+    if (!resolved || isDeniedTrustedWritePath(resolved)) {
+      return null;
+    }
+    resolvedRefs.push(resolved);
+  }
+  return normalizeTimelineFileRefs(resolvedRefs);
+}
+
+function sameNormalizedFileRefSet(leftRefs, rightRefs) {
+  const left = normalizeTimelineFileRefs(leftRefs ?? []);
+  const right = normalizeTimelineFileRefs(rightRefs ?? []);
+  if (left.length !== right.length) {
+    return false;
+  }
+  const rightSet = new Set(right);
+  return left.every((value) => rightSet.has(value));
+}
+
+function resolveTrustedWriteDiffSectionFileRefs({ diffSections, cwd, workspaceRoot }) {
+  const resolvedSections = [];
+  for (const section of diffSections) {
+    const paths = extractUnifiedDiffSectionPaths(section);
+    const sectionFileRef = cleanText(paths.newFileRef || paths.oldFileRef || "");
+    if (!sectionFileRef) {
+      return null;
+    }
+    if (paths.oldFileRef && paths.newFileRef && cleanText(paths.oldFileRef) !== cleanText(paths.newFileRef)) {
+      return null;
+    }
+    const resolved = resolveTrustedDiffSectionPath({
+      token: sectionFileRef,
+      cwd,
+      workspaceRoot,
+    });
+    if (!resolved || isDeniedTrustedWritePath(resolved)) {
+      return null;
+    }
+    resolvedSections.push(resolved);
+  }
+  return normalizeTimelineFileRefs(resolvedSections);
+}
+
+function evaluateTrustedWriteApprovalCandidate({ runtime, state, approval }) {
+  const cwd = cleanText(approval?.cwd || approval?.rawParams?.cwd || approval?.rawParams?.grantRoot || "");
+  const workspaceRoot = cleanText(approval?.workspaceRoot || approval?.rawParams?.grantRoot || cwd);
+  const resolvedFileRefs = resolveTrustedWriteFileRefs({
+    fileRefs: approval?.fileRefs ?? [],
+    cwd,
+    workspaceRoot,
+  });
+  const diffText = normalizeTimelineDiffText(approval?.diffText ?? "");
+  if (!cwd || !workspaceRoot || !resolvedFileRefs || !diffText) {
+    return null;
+  }
+  const counts = diffLineCounts(diffText);
+  const totalChangedLines =
+    Math.max(0, Number(counts.addedLines) || 0) +
+    Math.max(0, Number(counts.removedLines) || 0);
+  if (totalChangedLines === 0 || totalChangedLines > 120) {
+    return null;
+  }
+  const diffSections = splitUnifiedDiffTextByFile(diffText);
+  if (diffSections.length === 0 || diffSections.length > 3) {
+    return null;
+  }
+  if (
+    /^(?:new file mode|deleted file mode|rename from|rename to|old mode|new mode|similarity index|dissimilarity index|GIT binary patch|Binary files )/mu.test(diffText)
+  ) {
+    return null;
+  }
+  const diffSectionRefs = resolveTrustedWriteDiffSectionFileRefs({
+    diffSections,
+    cwd,
+    workspaceRoot,
+  });
+  if (!diffSectionRefs || !sameNormalizedFileRefSet(diffSectionRefs, resolvedFileRefs)) {
+    return null;
+  }
+  const lane = classifyTrustedWriteLane({
+    runtime,
+    state: state ?? approval?.stateSnapshot ?? null,
+    approval,
+    resolvedFileRefs: diffSectionRefs,
+    diffText,
+    totalChangedLines,
+  });
+  if (!lane) {
+    return null;
+  }
+  return {
+    fileRefs: diffSectionRefs,
+    diffText,
+    diffAddedLines: Math.max(0, Number(counts.addedLines) || 0),
+    diffRemovedLines: Math.max(0, Number(counts.removedLines) || 0),
+    totalChangedLines,
+    lane,
+  };
+}
+
+function maybeAutoApproveTrustedWriteCandidate({ runtime, state, approval }) {
+  if (!isAutoPilotTrustedWritesEnabled(state)) {
+    return null;
+  }
+  if (cleanText(approval?.kind || "") !== "file") {
+    return null;
+  }
+  return evaluateTrustedWriteApprovalCandidate({
+    runtime,
+    state,
+    approval: { ...approval, stateSnapshot: state },
+  });
+}
+
+function autoPilotTrustedWriteMessage(locale, approval, candidate) {
+  const prefix = t(locale, "server.message.autoPilotTrustedWriteApproved");
+  const fileBlock = candidate?.fileRefs?.length
+    ? `${t(locale, "server.message.filesLabel")}\n\`\`\`text\n${candidate.fileRefs.join("\n")}\n\`\`\``
+    : "";
+  const sizeLine =
+    candidate && Number.isFinite(candidate.diffAddedLines) && Number.isFinite(candidate.diffRemovedLines)
+      ? `${t(locale, "server.message.diffSummaryLabel")} +${candidate.diffAddedLines} / -${candidate.diffRemovedLines}`
+      : "";
+  const originalMessage = cleanText(approval?.messageText || "");
+  return [prefix, sizeLine, fileBlock, originalMessage].filter(Boolean).join("\n\n");
+}
+
+async function recordAutoApprovedTrustedRead({
+  config,
+  runtime,
+  state,
+  approval,
+  policyMatch,
+}) {
+  const stateChanged = recordActionHistoryItem({
+    config,
+    runtime,
+    state,
+    kind: "approval",
+    stableId: `approval:${approval.requestKey}:autopilot`,
+    token: approval.token,
+    title: approval.title,
+    threadLabel: approval.threadLabel || "",
+    messageText: autoPilotApprovalMessage(config.defaultLocale, policyMatch.commandText),
+    summary: t(config.defaultLocale, "server.message.autoPilotTrustedReadSummary"),
+    fileRefs: normalizeTimelineFileRefs(policyMatch.fileRefs ?? approval.fileRefs ?? []),
+    diffText: "",
+    diffSource: "",
+    diffAvailable: false,
+    diffAddedLines: 0,
+    diffRemovedLines: 0,
+    outcome: "approved",
+    provider: approval.provider || "codex",
+  });
+  if (stateChanged) {
+    await saveState(config.stateFile, state);
+  }
+}
+
+async function recordAutoApprovedTrustedWrite({
+  config,
+  runtime,
+  state,
+  approval,
+  candidate,
+}) {
+  const stateChanged = recordActionHistoryItem({
+    config,
+    runtime,
+    state,
+    kind: "approval",
+    stableId: `approval:${approval.requestKey}:autopilot-write:${candidate.lane || "content"}`,
+    token: approval.token,
+    title: approval.title,
+    threadLabel: approval.threadLabel || "",
+    messageText: autoPilotTrustedWriteMessage(config.defaultLocale, approval, candidate),
+    summary: t(config.defaultLocale, "server.message.autoPilotTrustedWriteSummary"),
+    fileRefs: candidate.fileRefs,
+    diffText: candidate.diffText,
+    diffSource: normalizeTimelineDiffSource(approval.diffSource ?? ""),
+    diffAvailable: true,
+    diffAddedLines: candidate.diffAddedLines,
+    diffRemovedLines: candidate.diffRemovedLines,
+    outcome: "approved",
+    provider: approval.provider || "codex",
+  });
+  if (stateChanged) {
+    await saveState(config.stateFile, state);
+  }
+}
+
+async function autoApproveTrustedRead({
+  config,
+  runtime,
+  state,
+  approval,
+  policyMatch,
+}) {
+  if (approval.provider === "claude" && approval.resolveClaudeWaiter) {
+    approval.resolveClaudeWaiter({
+      permissionDecision: "allow",
+      permissionDecisionReason: t(config.defaultLocale, "server.message.autoPilotTrustedReadReason"),
+    });
+  } else if (approval.provider !== "claude") {
+    await runtime.ipcClient?.sendApprovalDecision(approval, "accept");
+  }
+  approval.resolved = true;
+  approval.resolving = false;
+  runtime.nativeApprovalsByToken.delete(approval.token);
+  runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+  await recordAutoApprovedTrustedRead({
+    config,
+    runtime,
+    state,
+    approval,
+    policyMatch,
+  });
+  console.log(`[auto-pilot-approved] ${approval.requestKey} | ${policyMatch.command}`);
+}
+
+async function autoApproveTrustedWrite({
+  config,
+  runtime,
+  state,
+  approval,
+  candidate,
+}) {
+  if (approval.provider === "claude" && approval.resolveClaudeWaiter) {
+    approval.resolveClaudeWaiter({
+      permissionDecision: "allow",
+      permissionDecisionReason: t(config.defaultLocale, "server.message.autoPilotTrustedWriteReason"),
+    });
+  } else if (approval.provider !== "claude") {
+    await runtime.ipcClient?.sendApprovalDecision(approval, "accept");
+  }
+  approval.resolved = true;
+  approval.resolving = false;
+  runtime.nativeApprovalsByToken.delete(approval.token);
+  runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+  await recordAutoApprovedTrustedWrite({
+    config,
+    runtime,
+    state,
+    approval,
+    candidate,
+  });
+  console.log(`[auto-pilot-approved-write] ${approval.requestKey} | files=${candidate.fileRefs.length} | lines=${candidate.totalChangedLines}`);
+}
+
+async function handleNativeApprovalDecision({ config, runtime, state, approval, decision }) {
+  if (approval.resolveClaudeWaiter) {
+    if (approval.provider === "claude" && approval.kind === "plan") {
+      // ExitPlanMode cannot be truly auto-approved via permissionDecision: "allow"
+      // (Claude still shows the native PC plan dialog). Instead, deny the tool
+      // call with a reason that tells Claude the user already decided on mobile.
+      approval.resolveClaudeWaiter({
+        permissionDecision: "deny",
+        permissionDecisionReason:
+          decision === "accept"
+            ? "User approved the plan via the viveworker mobile app. Proceed with implementing the plan exactly as proposed and do not call ExitPlanMode again."
+            : "User rejected the plan via the viveworker mobile app. Revise the plan based on the conversation context before calling ExitPlanMode again.",
+      });
+    } else {
+      approval.resolveClaudeWaiter(decision);
+    }
+  } else if (approval.provider === "claude") {
+    // notifyOnly Claude approvals have no long-poll waiter and no ipcClient
+    // back-channel — the desktop user already answered. Nothing to send.
+  } else {
+    await runtime.ipcClient?.sendApprovalDecision(approval, decision);
+  }
+  approval.resolved = true;
+  approval.resolving = false;
+  runtime.nativeApprovalsByToken.delete(approval.token);
+  runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+  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(decision, config.defaultLocale, approval.provider)}\n\n${approval.messageText}`,
+    summary: formatNotificationBody(approval.messageText, 160) || approvalDecisionMessage(decision, config.defaultLocale, approval.provider),
+    fileRefs: normalizeTimelineFileRefs(approval.fileRefs ?? []),
+    diffText: normalizeTimelineDiffText(approval.diffText ?? ""),
+    diffSource: normalizeTimelineDiffSource(approval.diffSource ?? ""),
+    diffAvailable: approval.diffAvailable === true || Boolean(approval.diffText),
+    diffAddedLines: Math.max(0, Number(approval.diffAddedLines) || 0),
+    diffRemovedLines: Math.max(0, Number(approval.diffRemovedLines) || 0),
+    outcome: decision === "accept" ? "approved" : "rejected",
+    provider: approval.provider || "codex",
+  });
+  if (stateChanged) {
+    await saveState(config.stateFile, state);
+  }
+  console.log(`[native-decision] ${approval.requestKey} | ${decision}`);
+}
+
+async function buildApiItemDetail({ config, runtime, state, kind, token, locale }) {
+  if (kind === "diff_thread") {
+    const group = (await getDiffThreadGroupsCached(runtime, state, config)).find((entry) => entry.token === token);
+    return group ? buildDiffThreadDetail(group, locale) : null;
+  }
+  if (kind === "file_event") {
+    const entry = timelineEntryByToken(runtime, token, kind);
+    return entry ? buildTimelineFileEventDetail(entry, locale) : null;
+  }
+  if (kind === "ambient_suggestions") {
+    const entry = timelineEntryByToken(runtime, token, kind);
+    if (entry) {
+      return buildAmbientSuggestionsDetail(entry, locale);
+    }
+    const historicalSource = (runtime.recentHistoryItems ?? []).find((item) => {
+      if (cleanText(item?.token || "") !== cleanText(token || "")) {
+        return false;
+      }
+      const itemKind = cleanText(item?.kind || "");
+      if (itemKind !== "assistant_final" && itemKind !== "completion") {
+        return false;
+      }
+      return parseAmbientSuggestionsPayload(item?.messageText ?? "") !== null;
+    });
+    if (!historicalSource) {
+      return null;
+    }
+    return buildAmbientSuggestionsDetail({
+      token: historicalSource.token,
+      threadId: historyItemThreadId(historicalSource),
+      threadLabel: historicalSource.threadLabel,
+      title: kindTitle(locale, "ambient_suggestions"),
+      createdAtMs: historicalSource.createdAtMs,
+      suggestions: parseAmbientSuggestionsPayload(historicalSource.messageText ?? "") ?? [],
+    }, locale);
+  }
+  if (timelineMessageKinds.has(kind)) {
+    const entry = timelineEntryByToken(runtime, token, kind);
+    if (!entry) return null;
+    const detail = buildTimelineMessageDetail(entry, locale, runtime);
+    // Add reply support for Codex assistant_final entries only (replaces completion reply).
+    // Check directly against timeline entries (not history items) to avoid
+    // maxHistoryItems eviction issues.
+    if (kind === "assistant_final") {
+      const entryProvider = normalizeProvider(entry.provider);
+      if (entryProvider === "codex" && runtime?.ipcClient) {
+        const entryThreadId = cleanText(entry.threadId || "");
+        const entryTs = Number(entry.createdAtMs) || 0;
+        let isLatestForThread = true;
+        for (const other of runtime.recentTimelineEntries) {
+          if (other.kind === "assistant_final" &&
+            cleanText(other.threadId || "") === entryThreadId &&
+            (Number(other.createdAtMs) || 0) > entryTs) {
+            isLatestForThread = false;
+            break;
+          }
+        }
+        if (isLatestForThread) {
+          detail.reply = { enabled: true, supportsPlanMode: true, supportsImages: true };
+          detail.provider = entryProvider;
+        }
+      }
+    }
+    return detail;
+  }
+  if (kind === "approval") {
+    const approval = runtime.nativeApprovalsByToken.get(token);
+    if (approval) {
+      return buildPendingApprovalDetail(runtime, state, approval, locale);
+    }
+    const historicalApproval = historyItemByToken(runtime, kind, token);
+    return historicalApproval ? buildHistoryDetail(historicalApproval, locale, runtime) : null;
+  }
+  if (kind === "plan") {
+    const planRequest = runtime.planRequestsByToken.get(token);
+    if (planRequest && !planRequest.resolved && !isPlanRequestExpired(planRequest)) {
+      return buildPendingPlanDetail(planRequest, locale);
+    }
+    const historicalPlan = historyItemByToken(runtime, kind, token);
+    return historicalPlan ? buildHistoryDetail(historicalPlan, locale, runtime) : null;
+  }
+  if (kind === "choice") {
+    const userInputRequest = findLatestPersistedUserInputRequest({ config, runtime, state, token });
+    if (userInputRequest && !userInputRequest.resolved && !isGenericUserInputRequestExpired(userInputRequest)) {
       return buildChoiceDetail(userInputRequest, config, locale);
     }
     const historicalChoice = historyItemByToken(runtime, kind, token);
@@ -11343,21 +13341,81 @@ function contentTypeForFile(filePath) {
   }
 }
 
-async function serveWebAsset(res, urlPath) {
+// Per-file cache of {raw, gzip, mtimeMs}. Gzip of the ~464KB app shell
+// (app.js 278KB + app.css 76KB + i18n.js 110KB) takes a few ms to compute,
+// and without this the bridge would recompress on every request. Keyed by
+// resolved filePath so /app and /index.html share a cache slot.
+const WEB_ASSET_CACHE = new Map();
+const GZIPPABLE_EXTENSIONS = new Set([
+  ".js",
+  ".mjs",
+  ".css",
+  ".html",
+  ".htm",
+  ".json",
+  ".webmanifest",
+  ".svg",
+  ".txt",
+  ".map",
+]);
+const MIN_GZIP_BYTES = 512;
+
+async function loadWebAssetEntry(filePath) {
+  const stat = await fs.stat(filePath);
+  const cached = WEB_ASSET_CACHE.get(filePath);
+  if (cached && cached.mtimeMs === stat.mtimeMs && cached.size === stat.size) {
+    return cached;
+  }
+  const raw = await fs.readFile(filePath);
+  const extension = path.extname(filePath).toLowerCase();
+  let gzip = null;
+  if (GZIPPABLE_EXTENSIONS.has(extension) && raw.length >= MIN_GZIP_BYTES) {
+    try {
+      gzip = zlib.gzipSync(raw, { level: 6 });
+    } catch {
+      gzip = null;
+    }
+  }
+  const entry = {
+    raw,
+    gzip,
+    mtimeMs: stat.mtimeMs,
+    size: stat.size,
+    contentType: contentTypeForFile(filePath),
+  };
+  WEB_ASSET_CACHE.set(filePath, entry);
+  return entry;
+}
+
+function clientAcceptsGzip(req) {
+  const header = req?.headers?.["accept-encoding"];
+  if (!header) return false;
+  const value = Array.isArray(header) ? header.join(",") : String(header);
+  return /\bgzip\b/i.test(value);
+}
+
+async function serveWebAsset(res, urlPath, req) {
   const filePath = resolveWebAsset(urlPath);
   if (!filePath) {
     return false;
   }
 
   try {
-    const body = await fs.readFile(filePath);
+    const entry = await loadWebAssetEntry(filePath);
+    const wantsGzip = entry.gzip && clientAcceptsGzip(req);
     res.statusCode = 200;
-    res.setHeader("Content-Type", contentTypeForFile(filePath));
+    res.setHeader("Content-Type", entry.contentType);
     res.setHeader("Cache-Control", "no-store, max-age=0");
     if (urlPath === "/sw.js") {
       res.setHeader("Service-Worker-Allowed", "/");
     }
-    res.end(body);
+    if (wantsGzip) {
+      res.setHeader("Content-Encoding", "gzip");
+      res.setHeader("Vary", "Accept-Encoding");
+      res.end(entry.gzip);
+    } else {
+      res.end(entry.raw);
+    }
     return true;
   } catch {
     return false;
@@ -11489,10 +13547,11 @@ function createNativeApprovalServer({ config, runtime, state }) {
         url.pathname === "/app.js" ||
         url.pathname === "/app.css" ||
         url.pathname === "/i18n.js" ||
+        url.pathname === "/hazbase-passkey.js" ||
         url.pathname === "/sw.js" ||
         url.pathname.startsWith("/icons/")
       ) {
-        const served = await serveWebAsset(res, url.pathname);
+        const served = await serveWebAsset(res, url.pathname, req);
         if (served) {
           return;
         }
@@ -11632,16 +13691,47 @@ function createNativeApprovalServer({ config, runtime, state }) {
         if (session.authenticated && session.restoredFromDevice) {
           setSessionCookie(res, config);
         }
+        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
+      // TLS handshake — and `JSON.stringify(state)` hiccups on other
+      // requests make those handshakes bursty. One endpoint = one
+      // handshake + one response, which drops the "Completed list is
+      // blank for several seconds after launch" latency floor.
+      if (url.pathname === "/api/bootstrap" && req.method === "GET") {
+        const session = readSession(req, config, state);
+        const localeInfo = resolveDeviceLocaleInfo(config, state, session.deviceId);
+        if (session.authenticated && session.deviceId) {
+          const trustChanged = touchDeviceTrust(state, config, session.deviceId);
+          const metadataChanged = updateCurrentDeviceSnapshot(state, config, session.deviceId, {
+            userAgent: requestUserAgent(req),
+            lastLocale: localeInfo.locale,
+          });
+          if (trustChanged || metadataChanged) {
+            await saveState(config.stateFile, state);
+          }
+        }
+        if (session.authenticated && session.restoredFromDevice) {
+          setSessionCookie(res, config);
+        }
+        const sessionPayload = buildSessionPayload({ config, state, session });
+        if (!session.authenticated) {
+          return writeJson(res, 200, { session: sessionPayload });
+        }
         return writeJson(res, 200, {
-          authenticated: Boolean(session.authenticated),
-          expiresAtMs: Number(session.expiresAtMs) || 0,
-          pairingAvailable: isPairingAvailableForState(config, state),
-          webPushEnabled: config.webPushEnabled,
-          httpsEnabled: config.nativeApprovalPublicBaseUrl.startsWith("https://"),
-          appVersion: appPackageVersion,
-          deviceId: session.deviceId || null,
-          temporaryPairing: session.temporaryPairing === true,
-          ...buildSessionLocalePayload(config, state, session.deviceId),
+          session: sessionPayload,
+          inbox: buildInboxFastResponse(runtime, state, config, localeInfo.locale),
+          timeline: buildTimelineResponse(runtime, state, config, localeInfo.locale),
+          devices: buildDevicesResponse({ config, state, session, locale: localeInfo.locale }),
         });
       }
 
@@ -11756,7 +13846,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
           lastLocale: resolveDeviceLocaleInfo(config, state, session.deviceId).locale,
         }) || changed;
         if (changed) {
-          await saveState(config.stateFile, state);
+          scheduleSaveState(config, state);
         }
         return writeJson(res, 200, {
           ok: true,
@@ -11778,12 +13868,80 @@ function createNativeApprovalServer({ config, runtime, state }) {
         const enabled = payload?.enabled === true;
         if (state.claudeAwayMode !== enabled) {
           state.claudeAwayMode = enabled;
-          await saveState(config.stateFile, state);
+          scheduleSaveState(config, state);
         }
         await syncClaudeAwayModeSentinel(config, enabled);
         return writeJson(res, 200, { ok: true, enabled });
       }
 
+      if (url.pathname === "/api/settings/auto-pilot" && req.method === "POST") {
+        const session = requireMutatingApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+        let payload;
+        try {
+          payload = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+        const trustedReadsEnabled =
+          typeof payload?.trustedReadsEnabled === "boolean"
+            ? payload.trustedReadsEnabled === true
+            : state.autoPilotTrustedReads === true;
+        const hasLaneUpdate =
+          typeof payload?.writeLaneContentEnabled === "boolean" ||
+          typeof payload?.writeLaneUiTestsEnabled === "boolean" ||
+          typeof payload?.writeLaneSourceEnabled === "boolean";
+        const legacyTrustedWritesEnabled =
+          typeof payload?.trustedWritesEnabled === "boolean"
+            ? payload.trustedWritesEnabled === true
+            : typeof payload?.trustedWritesShadowEnabled === "boolean"
+              ? payload.trustedWritesShadowEnabled === true
+              : null;
+        const currentLanes = autoPilotWriteLaneState(state);
+        const writeLaneContentEnabled =
+          typeof payload?.writeLaneContentEnabled === "boolean"
+            ? payload.writeLaneContentEnabled === true
+            : !hasLaneUpdate && legacyTrustedWritesEnabled != null
+              ? legacyTrustedWritesEnabled
+              : currentLanes.content;
+        const writeLaneUiTestsEnabled =
+          typeof payload?.writeLaneUiTestsEnabled === "boolean"
+            ? payload.writeLaneUiTestsEnabled === true
+            : currentLanes.uiTests;
+        const writeLaneSourceEnabled =
+          typeof payload?.writeLaneSourceEnabled === "boolean"
+            ? payload.writeLaneSourceEnabled === true
+            : currentLanes.source;
+        const trustedWritesEnabled =
+          writeLaneContentEnabled || writeLaneUiTestsEnabled || writeLaneSourceEnabled;
+        if (
+          state.autoPilotTrustedReads !== trustedReadsEnabled ||
+          state.autoPilotWriteLaneContent !== writeLaneContentEnabled ||
+          state.autoPilotWriteLaneUiTests !== writeLaneUiTestsEnabled ||
+          state.autoPilotWriteLaneSource !== writeLaneSourceEnabled ||
+          isAutoPilotTrustedWritesEnabled(state) !== trustedWritesEnabled
+        ) {
+          state.autoPilotTrustedReads = trustedReadsEnabled;
+          state.autoPilotTrustedWrites = trustedWritesEnabled;
+          state.autoPilotTrustedWritesShadow = false;
+          state.autoPilotWriteLaneContent = writeLaneContentEnabled;
+          state.autoPilotWriteLaneUiTests = writeLaneUiTestsEnabled;
+          state.autoPilotWriteLaneSource = writeLaneSourceEnabled;
+          await saveState(config.stateFile, state);
+        }
+        return writeJson(res, 200, {
+          ok: true,
+          trustedReadsEnabled,
+          trustedWritesEnabled,
+          trustedWritesShadowEnabled: false,
+          writeLaneContentEnabled,
+          writeLaneUiTestsEnabled,
+          writeLaneSourceEnabled,
+        });
+      }
+
       if (url.pathname === "/api/settings/a2a-executor" && req.method === "POST") {
         const session = requireMutatingApiSession(req, res, config, state);
         if (!session) return;
@@ -11797,7 +13955,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
         const preference = valid.has(payload?.preference) ? payload.preference : "auto";
         if (state.a2aExecutorPreference !== preference) {
           state.a2aExecutorPreference = preference;
-          await saveState(config.stateFile, state);
+          scheduleSaveState(config, state);
         }
         return writeJson(res, 200, { ok: true, preference });
       }
@@ -11967,6 +14125,314 @@ function createNativeApprovalServer({ config, runtime, state }) {
         });
       }
 
+
+if (url.pathname === "/api/hazbase/status" && req.method === "GET") {
+  const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+  const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+  if (!hookAuth) {
+    const session = requireApiSession(req, res, config, state);
+    if (!session) return;
+  }
+  if (!config.hazbaseApiUrl) {
+    return writeJson(res, 200, { enabled: false });
+  }
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  const [paymentsResult, chainsResult] = await Promise.allSettled([
+    fetchHazbaseMetadata(config, "/api/meta/payments"),
+    fetchHazbaseMetadata(config, "/api/meta/chains"),
+  ]);
+  const payments = paymentsResult.status === "fulfilled" ? paymentsResult.value : null;
+  const chains = chainsResult.status === "fulfilled" ? chainsResult.value : null;
+  const errors = [];
+  if (paymentsResult.status === "rejected") {
+    errors.push(paymentsResult.reason?.message || String(paymentsResult.reason || "payments metadata unavailable"));
+  }
+  if (chainsResult.status === "rejected") {
+    errors.push(chainsResult.reason?.message || String(chainsResult.reason || "chains metadata unavailable"));
+  }
+  const supportedChains = Array.isArray(chains?.chains)
+    ? chains.chains.filter((entry) => Number(entry.chainId) === 8453 || Number(entry.chainId) === 84532)
+    : [];
+  const payoutAddresses = {
+    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,
+    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,
+    deviceBindingId: hazbase.deviceBindingId,
+    credentialId: hazbase.credentialId,
+    highTrustExpiresAt: hazbase.highTrustExpiresAt,
+    accounts: hazbase.accounts,
+    supportedPayments: payments?.networks || [],
+    supportedChains,
+    defaultPaymentNetwork: payments?.defaultNetwork || "base-sepolia",
+    payoutAddresses,
+    error: errors.join(" | "),
+  });
+}
+
+if (url.pathname === "/api/hazbase/payout-address" && req.method === "GET") {
+  const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+  const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+  if (!hookAuth) {
+    const session = requireApiSession(req, res, config, state);
+    if (!session) return;
+  }
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
+  const chainId = Number(url.searchParams.get("chainId") || 0);
+  if (chainId !== 8453 && chainId !== 84532) {
+    return writeJson(res, 400, { error: "unsupported-chain" });
+  }
+  const account = resolveHazbaseAccountForChain(hazbase.accounts, chainId);
+  if (!account?.smartAccountAddress) {
+    return writeJson(res, 409, { error: "hazbase-wallet-account-missing" });
+  }
+  return writeJson(res, 200, {
+    chainId,
+    payoutMethod: "hazbase_wallet",
+    payoutAddress: account.smartAccountAddress,
+    smartAccountAddress: account.smartAccountAddress,
+    accountVariant: account.accountVariant || "",
+    relayMode: account.relayMode || "",
+  });
+}
+
+if (url.pathname === "/api/hazbase/request-otp" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const body = await parseJsonBody(req);
+  const email = cleanText(body?.email || "");
+  if (!email) return writeJson(res, 400, { error: "email-required" });
+  const result = await requestHazbaseEmailOtp({ email });
+  state.hazbase = { ...normalizeHazbaseState(state.hazbase), email };
+  await saveState(config.stateFile, state);
+  return writeJson(res, 200, result);
+}
+
+if (url.pathname === "/api/hazbase/verify-otp" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const body = await parseJsonBody(req);
+  const email = cleanText(body?.email || state.hazbase?.email || "");
+  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 = {
+    ...previousHazbase,
+    email: result.email || email,
+    accessToken: cleanText(result.accessToken || ""),
+    sessionId: cleanText(result.sessionId || ""),
+    userId: cleanText(result.userId || ""),
+    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);
+}
+
+if (url.pathname === "/api/hazbase/passkey/register/challenge" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
+  const body = await parseJsonBody(req);
+  let partnerOrigin;
+  try {
+    partnerOrigin = deriveHazbasePartnerPasskeyOrigin(req, config);
+  } catch (error) {
+    return writeJson(res, 400, {
+      error: error?.code || "hazbase-passkey-local-host-required",
+      message: error?.message || "Open viveworker on its .local hostname to use hazBase passkeys.",
+    });
+  }
+  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);
+}
+
+if (url.pathname === "/api/hazbase/passkey/register/complete" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
+  const body = await parseJsonBody(req);
+  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);
+}
+
+if (url.pathname === "/api/hazbase/passkey/assert/challenge" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
+  const body = await parseJsonBody(req);
+  let partnerOrigin;
+  try {
+    partnerOrigin = deriveHazbasePartnerPasskeyOrigin(req, config);
+  } catch (error) {
+    return writeJson(res, 400, {
+      error: error?.code || "hazbase-passkey-local-host-required",
+      message: error?.message || "Open viveworker on its .local hostname to use hazBase passkeys.",
+    });
+  }
+  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);
+}
+
+if (url.pathname === "/api/hazbase/passkey/assert/complete" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  if (!hazbase.accessToken) return writeJson(res, 401, { error: "hazbase-auth-required" });
+  const body = await parseJsonBody(req);
+  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);
+}
+
+if (url.pathname === "/api/hazbase/account/bootstrap" && req.method === "POST") {
+  const session = requireMutatingApiSession(req, res, config, state);
+  if (!session) return;
+  const hazbase = normalizeHazbaseState(state.hazbase);
+  if (!hazbase.accessToken || !hazbase.deviceBindingId || !hazbase.highTrustToken) {
+    return writeJson(res, 409, { error: "hazbase-bootstrap-prerequisites-missing" });
+  }
+  const body = await parseJsonBody(req);
+  const chainId = Number(body?.chainId || 0);
+  if (chainId !== 8453 && chainId !== 84532) {
+    return writeJson(res, 400, { error: "unsupported-chain" });
+  }
+  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,
+    accountVariant: result.accountVariant,
+    relayMode: result.relayMode,
+    primaryDeviceBindingId: result.deviceBindingId,
+  }]);
+  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;
+  state.hazbase = normalizeHazbaseState(null);
+  await saveState(config.stateFile, state);
+  return writeJson(res, 200, { ok: true });
+}
+
       // Toggle acceptPublicTasks on the A2A relay.
       if (url.pathname === "/api/a2a/public-tasks" && req.method === "POST") {
         const session = requireApiSession(req, res, config, state);
@@ -11975,11 +14441,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
         const accept = body?.accept === true;
         config.a2aAcceptPublicTasks = accept;
         state.a2aAcceptPublicTasks = accept;
-        try {
-          await saveState(config.stateFile, state);
-        } catch (error) {
-          console.error(`[a2a-public-tasks-save] ${error.message}`);
-        }
+        scheduleSaveState(config, state);
         // Re-register with relay to propagate the flag.
         if (config.a2aRelayUrl && config.a2aRelayUserId) {
           try {
@@ -12154,6 +14616,8 @@ function createNativeApprovalServer({ config, runtime, state }) {
           await deliverWebPushItem({
             config, state,
             kind: "thread_share",
+            tab: "inbox",
+            subtab: "pending",
             token,
             stableId: `thread_share:${shareId}`,
             title: `Thread Share: ${sourceLabel || sourceTool || "agent"} → ${targetLabel || targetTool}`,
@@ -12251,6 +14715,8 @@ function createNativeApprovalServer({ config, runtime, state }) {
                 await deliverWebPushItem({
                   config, state,
                   kind: "thread_share",
+                  tab: "inbox",
+                  subtab: "completed",
                   token: share.token,
                   stableId: `thread_share_fallback:${share.shareId}`,
                   title: "Thread Share: target unreachable",
@@ -12393,7 +14859,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
           lastLocale: resolveDeviceLocaleInfo(config, state, session.deviceId).locale,
         });
         if (changed || metadataChanged) {
-          await saveState(config.stateFile, state);
+          scheduleSaveState(config, state);
         }
         return writeJson(res, 200, {
           ok: true,
@@ -12416,7 +14882,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
           changed = deletePushSubscriptionsForDevice(state, session.deviceId) || changed;
         }
         if (changed) {
-          await saveState(config.stateFile, state);
+          scheduleSaveState(config, state);
         }
         return writeJson(res, 200, { ok: true, subscribed: false });
       }
@@ -12428,13 +14894,13 @@ function createNativeApprovalServer({ config, runtime, state }) {
         }
         try {
           await sendPushTestToDevice({ config, state, session });
-          await saveState(config.stateFile, state);
+          scheduleSaveState(config, state);
           return writeJson(res, 200, { ok: true });
         } catch (error) {
           const statusCode = Number(error?.statusCode) || 0;
           if (statusCode === 404 || statusCode === 410) {
             deletePushSubscriptionsForDevice(state, session.deviceId);
-            await saveState(config.stateFile, state);
+            scheduleSaveState(config, state);
             return writeJson(res, 410, { error: "push-subscription-expired" });
           }
           return writeJson(res, 500, {
@@ -12442,43 +14908,201 @@ function createNativeApprovalServer({ config, runtime, state }) {
             ipcError: error.ipcError ?? null,
           });
         }
-      }
-
-      if (url.pathname === "/api/devices" && req.method === "GET") {
-        const session = requireApiSession(req, res, config, state);
-        if (!session) {
-          return;
+      }
+
+      if (url.pathname === "/api/devices" && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+        const locale = resolveDeviceLocaleInfo(config, state, session.deviceId).locale;
+        return writeJson(res, 200, buildDevicesResponse({ config, state, session, locale }));
+      }
+
+      const apiDeviceRevokeMatch = url.pathname.match(/^\/api\/devices\/([^/]+)\/revoke$/u);
+      if (apiDeviceRevokeMatch && req.method === "POST") {
+        const session = requireMutatingApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+        const deviceId = decodeURIComponent(apiDeviceRevokeMatch[1]);
+        const existing = getActiveDeviceTrustRecord(state, config, deviceId);
+        if (!existing) {
+          return writeJson(res, 404, { error: "device-not-found" });
+        }
+        let changed = false;
+        changed = revokeDeviceTrust(state, config, deviceId) || changed;
+        changed = deletePushSubscriptionsForDevice(state, deviceId) || changed;
+        if (changed) {
+          await saveState(config.stateFile, state);
+        }
+        const currentDeviceRevoked = deviceId === session.deviceId;
+        if (currentDeviceRevoked) {
+          clearAuthCookies(res, config);
+        }
+        return writeJson(res, 200, {
+          ok: true,
+          deviceId,
+          currentDeviceRevoked,
+        });
+      }
+
+
+      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) {
+          approval.resolving = false;
+          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" });
         }
-        const locale = resolveDeviceLocaleInfo(config, state, session.deviceId).locale;
-        return writeJson(res, 200, buildDevicesResponse({ config, state, session, locale }));
       }
 
-      const apiDeviceRevokeMatch = url.pathname.match(/^\/api\/devices\/([^/]+)\/revoke$/u);
-      if (apiDeviceRevokeMatch && req.method === "POST") {
-        const session = requireMutatingApiSession(req, res, config, state);
-        if (!session) {
-          return;
+      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" });
         }
-        const deviceId = decodeURIComponent(apiDeviceRevokeMatch[1]);
-        const existing = getActiveDeviceTrustRecord(state, config, deviceId);
-        if (!existing) {
-          return writeJson(res, 404, { error: "device-not-found" });
+
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
         }
-        let changed = false;
-        changed = revokeDeviceTrust(state, config, deviceId) || changed;
-        changed = deletePushSubscriptionsForDevice(state, deviceId) || changed;
-        if (changed) {
-          await saveState(config.stateFile, state);
+
+        const approval = createX402PaymentApproval({ config, body });
+        if (!approval) {
+          return writeJson(res, 400, { error: "invalid-payment-approval-request" });
         }
-        const currentDeviceRevoked = deviceId === session.deviceId;
-        if (currentDeviceRevoked) {
-          clearAuthCookies(res, config);
+        if (runtime.nativeApprovalsByRequestKey.has(approval.requestKey)) {
+          return writeJson(res, 409, { error: "payment-approval-already-pending" });
         }
-        return writeJson(res, 200, {
-          ok: true,
-          deviceId,
-          currentDeviceRevoked,
+
+        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") {
@@ -12640,6 +15264,8 @@ function createNativeApprovalServer({ config, runtime, state }) {
           diffSource: String(body.diffSource || "claude_permission_request"),
           diffAddedLines: Math.max(0, Number(body.diffAddedLines) || 0),
           diffRemovedLines: Math.max(0, Number(body.diffRemovedLines) || 0),
+          cwd: body.cwd ? String(body.cwd) : "",
+          workspaceRoot: body.cwd ? String(body.cwd) : "",
           createdAtMs: Number(body.createdAtMs) || Date.now(),
           resolved: false,
           resolving: false,
@@ -12653,6 +15279,59 @@ function createNativeApprovalServer({ config, runtime, state }) {
           readOnly: body.notifyOnly === true,
         };
 
+        const claudeAutoPilotMatch =
+          approval.kind === "command"
+            ? maybeAutoApproveTrustedRead({
+                state,
+                commandText: body?.toolInput?.command ?? "",
+                cwd: body.cwd ? String(body.cwd) : "",
+                workspaceRoot: body.cwd ? String(body.cwd) : "",
+              })
+            : null;
+        if (claudeAutoPilotMatch) {
+          try {
+            await recordAutoApprovedTrustedRead({
+              config,
+              runtime,
+              state,
+              approval,
+              policyMatch: claudeAutoPilotMatch,
+            });
+            console.log(`[auto-pilot-approved] ${approval.requestKey} | ${claudeAutoPilotMatch.command}`);
+            return writeJson(res, 200, {
+              permissionDecision: "allow",
+              permissionDecisionReason: t(config.defaultLocale, "server.message.autoPilotTrustedReadReason"),
+            });
+          } catch (error) {
+            console.error(`[auto-pilot-error] ${approval.requestKey} | ${error.message}`);
+          }
+        }
+
+        const claudeAutoPilotWriteCandidate =
+          approval.kind === "file"
+            ? maybeAutoApproveTrustedWriteCandidate({ runtime, state, approval })
+            : null;
+        if (claudeAutoPilotWriteCandidate) {
+          try {
+            await recordAutoApprovedTrustedWrite({
+              config,
+              runtime,
+              state,
+              approval,
+              candidate: claudeAutoPilotWriteCandidate,
+            });
+            console.log(
+              `[auto-pilot-approved-write] ${approval.requestKey} | files=${claudeAutoPilotWriteCandidate.fileRefs.length} | lines=${claudeAutoPilotWriteCandidate.totalChangedLines}`
+            );
+            return writeJson(res, 200, {
+              permissionDecision: "allow",
+              permissionDecisionReason: t(config.defaultLocale, "server.message.autoPilotTrustedWriteReason"),
+            });
+          } catch (error) {
+            console.error(`[auto-pilot-write-error] ${approval.requestKey} | ${error.message}`);
+          }
+        }
+
         runtime.nativeApprovalsByToken.set(token, approval);
         runtime.nativeApprovalsByRequestKey.set(requestKey, approval);
 
@@ -12660,6 +15339,8 @@ function createNativeApprovalServer({ config, runtime, state }) {
           config,
           state,
           kind: "approval",
+          tab: "inbox",
+          subtab: "pending",
           token: approval.token,
           stableId: pendingApprovalStableId(approval),
           title: approval.title,
@@ -12789,6 +15470,8 @@ function createNativeApprovalServer({ config, runtime, state }) {
             config,
             state,
             kind: "moltbook_reply",
+            tab: "inbox",
+            subtab: "pending",
             token,
             stableId: `moltbook_reply:${item.sourceId}`,
             title: item.title,
@@ -12970,6 +15653,8 @@ function createNativeApprovalServer({ config, runtime, state }) {
             config,
             state,
             kind: "moltbook_draft",
+            tab: "inbox",
+            subtab: "pending",
             token,
             stableId: `moltbook_draft:${sourceId}`,
             title: pushTitle,
@@ -13066,6 +15751,8 @@ function createNativeApprovalServer({ config, runtime, state }) {
               try {
                 await deliverWebPushItem({
                   config, state, kind: "moltbook_draft", token: draft.token,
+                  tab: "inbox",
+                  subtab: "completed",
                   stableId: `moltbook_draft_failed:${draft.sourceId}`,
                   title: "Draft post failed",
                   body: String(postError.message || "").slice(0, 160),
@@ -13089,7 +15776,16 @@ function createNativeApprovalServer({ config, runtime, state }) {
           return;
         }
         const locale = resolveDeviceLocaleInfo(config, state, session.deviceId).locale;
-        return writeJson(res, 200, await buildInboxResponse(runtime, state, config, locale));
+        return writeJson(res, 200, buildInboxFastResponse(runtime, state, config, locale));
+      }
+
+      if (url.pathname === "/api/inbox/diff" && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+        const locale = resolveDeviceLocaleInfo(config, state, session.deviceId).locale;
+        return writeJson(res, 200, await buildInboxDiffResponse(runtime, state, config, locale));
       }
 
       if (url.pathname === "/api/timeline" && req.method === "GET") {
@@ -13226,6 +15922,10 @@ function createNativeApprovalServer({ config, runtime, state }) {
         if (approval.resolved || approval.resolving) {
           return writeJson(res, 409, { error: "approval-already-handled" });
         }
+        if (approval.kind === "hazbase_wallet_payment") {
+          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 {
@@ -13820,6 +16520,21 @@ function createNativeApprovalServer({ config, runtime, state }) {
       if (approval.resolved || approval.resolving) {
         return writeApprovalHandled(res, req, approval.title, 409, config.defaultLocale);
       }
+      if (approval.kind === "hazbase_wallet_payment") {
+        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 {
@@ -15169,6 +17884,8 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
     const pushTitle = draft.draftType === "original_post" ? finalTitle : `Reply → ${draft.postTitle || "Moltbook"}`;
     await deliverWebPushItem({
       config, state, kind: "moltbook_draft", token: draft.token,
+      tab: "inbox",
+      subtab: "completed",
       stableId: `moltbook_draft_posted:${draft.sourceId}`,
       title: "Moltbook posted",
       body: truncate(singleLine(pushTitle), 160),
@@ -15201,6 +17918,12 @@ function buildConfig(cli) {
     a2aShareUrl: stripTrailingSlash(
       process.env.VIVEWORKER_SHARE_URL || "https://share.viveworker.com"
     ),
+    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),
@@ -15288,6 +18011,386 @@ function buildConfig(cli) {
   };
 }
 
+
+function normalizeHazbaseState(raw) {
+  const value = raw && typeof raw === "object" ? raw : {};
+  return {
+    email: cleanText(value.email ?? ""),
+    accessToken: cleanText(value.accessToken ?? ""),
+    sessionId: cleanText(value.sessionId ?? ""),
+    userId: cleanText(value.userId ?? ""),
+    deviceBindingId: cleanText(value.deviceBindingId ?? ""),
+    credentialId: cleanText(value.credentialId ?? ""),
+    highTrustToken: cleanText(value.highTrustToken ?? ""),
+    highTrustExpiresAt: cleanText(value.highTrustExpiresAt ?? ""),
+    accounts: Array.isArray(value.accounts) ? value.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 statusCode = Number(error?.statusCode || error?.status || details.statusCode || 0);
+  const text = [
+    error?.code,
+    error?.message,
+    details.errorCode,
+    details.code,
+    details.error,
+    details.message,
+  ]
+    .map((entry) => cleanText(entry || "").toLowerCase())
+    .filter(Boolean)
+    .join(" ");
+  return statusCode === 401 && 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";
+  return error;
+}
+
+function deriveHazbasePartnerPasskeyOrigin(req, config) {
+  const rawOrigin = cleanText(req.headers.origin || "");
+  const rawHost = cleanText(req.headers.host || "");
+  const candidateOrigin = rawOrigin || (rawHost ? `https://${rawHost}` : "");
+  if (!candidateOrigin) {
+    throw hazbasePasskeyLocalHostError();
+  }
+
+  let parsed;
+  try {
+    parsed = new URL(candidateOrigin);
+  } catch {
+    throw hazbasePasskeyLocalHostError();
+  }
+
+  const hostname = cleanText(parsed.hostname || "").toLowerCase();
+  if (parsed.protocol !== "https:" || !hostname || net.isIP(hostname) || !hostname.endsWith(".local")) {
+    throw hazbasePasskeyLocalHostError();
+  }
+
+  return {
+    origin: `${parsed.protocol}//${parsed.host}`.toLowerCase(),
+    rpId: hostname,
+    clientKey: config.hazbaseClientKey || "viveworker-internal",
+  };
+}
+
+function configureHazbaseClient(config) {
+  try {
+    setHazbaseClientKey(config.hazbaseClientKey || "viveworker-internal");
+    setHazbaseApiEndpoint(config.hazbaseApiUrl || "https://api.hazbase.com");
+  } catch (error) {
+    console.error(`[hazbase-config] ${error.message}`);
+  }
+}
+
+async function fetchHazbaseMetadata(config, endpoint, timeoutMs = HAZBASE_METADATA_TIMEOUT_MS) {
+  const baseUrl = stripTrailingSlash(config?.hazbaseApiUrl || "");
+  if (!baseUrl) return null;
+  const timeout = Math.max(250, Number(timeoutMs) || HAZBASE_METADATA_TIMEOUT_MS);
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeout);
+  timer.unref?.();
+  try {
+    const response = await fetch(`${baseUrl}${endpoint}`, {
+      method: "GET",
+      headers: { Accept: "application/json" },
+      signal: controller.signal,
+    });
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "");
+      throw new Error(`${endpoint} failed: ${cleanText(errorText || response.statusText || "upstream error")}`);
+    }
+    const payload = await response.json().catch(() => null);
+    return payload?.data ?? payload ?? null;
+  } catch (error) {
+    if (error?.name === "AbortError") {
+      throw new Error(`${endpoint} timed out after ${timeout}ms`);
+    }
+    throw error;
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+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 : [])]) {
+    if (!entry || !entry.smartAccountAddress) continue;
+    const key = `${Number(entry.chainId) || 0}:${String(entry.smartAccountAddress).toLowerCase()}`;
+    merged.set(key, entry);
+  }
+  return [...merged.values()];
+}
+
+function resolveHazbaseAccountForChain(accounts, chainId) {
+  const normalizedChainId = Number(chainId || 0);
+  if (!normalizedChainId) return null;
+  const list = Array.isArray(accounts) ? accounts : [];
+  return list.find((entry) => Number(entry?.chainId) === normalizedChainId && cleanText(entry?.smartAccountAddress || "")) || null;
+}
+
+
+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 {
@@ -15443,6 +18546,23 @@ async function loadState(stateFile) {
   try {
     const raw = await fs.readFile(stateFile, "utf8");
     const parsed = JSON.parse(raw);
+    const hasExplicitWriteLaneState =
+      typeof parsed.autoPilotWriteLaneContent === "boolean" ||
+      typeof parsed.autoPilotWriteLaneUiTests === "boolean" ||
+      typeof parsed.autoPilotWriteLaneSource === "boolean";
+    const legacyTrustedWritesEnabled = parsed.autoPilotTrustedWrites === true || parsed.autoPilotTrustedWritesShadow === true;
+    const autoPilotWriteLaneContent =
+      typeof parsed.autoPilotWriteLaneContent === "boolean"
+        ? parsed.autoPilotWriteLaneContent === true
+        : !hasExplicitWriteLaneState && legacyTrustedWritesEnabled;
+    const autoPilotWriteLaneUiTests =
+      typeof parsed.autoPilotWriteLaneUiTests === "boolean"
+        ? parsed.autoPilotWriteLaneUiTests === true
+        : false;
+    const autoPilotWriteLaneSource =
+      typeof parsed.autoPilotWriteLaneSource === "boolean"
+        ? parsed.autoPilotWriteLaneSource === true
+        : false;
     return {
       fileOffsets: parsed.fileOffsets ?? {},
       seenEvents: parsed.seenEvents ?? {},
@@ -15468,7 +18588,14 @@ async function loadState(stateFile) {
       pairingConsumedAt: Number(parsed.pairingConsumedAt) || 0,
       pairingConsumedCredential: cleanText(parsed.pairingConsumedCredential ?? ""),
       claudeAwayMode: parsed.claudeAwayMode === true,
+      autoPilotTrustedReads: parsed.autoPilotTrustedReads === true,
+      autoPilotTrustedWrites: autoPilotWriteLaneContent || autoPilotWriteLaneUiTests || autoPilotWriteLaneSource,
+      autoPilotTrustedWritesShadow: false,
+      autoPilotWriteLaneContent,
+      autoPilotWriteLaneUiTests,
+      autoPilotWriteLaneSource,
       a2aAcceptPublicTasks: parsed.a2aAcceptPublicTasks === true,
+      hazbase: normalizeHazbaseState(parsed.hazbase),
     };
   } catch {
     return {
@@ -15496,6 +18623,13 @@ async function loadState(stateFile) {
       pairingConsumedAt: 0,
       pairingConsumedCredential: "",
       claudeAwayMode: false,
+      autoPilotTrustedReads: false,
+      autoPilotTrustedWrites: false,
+      autoPilotTrustedWritesShadow: false,
+      autoPilotWriteLaneContent: false,
+      autoPilotWriteLaneUiTests: false,
+      autoPilotWriteLaneSource: false,
+      hazbase: normalizeHazbaseState(null),
     };
   }
 }
@@ -15520,7 +18654,11 @@ async function syncClaudeAwayModeSentinel(config, enabled) {
 }
 
 async function saveState(stateFile, state) {
-  const output = JSON.stringify(state, null, 2);
+  // No indent. The state file is ~8 MB and humans don't read it; pretty-print
+  // just costs a few extra ms of stringify and ~10% more bytes on disk. The
+  // single newline at the end keeps diffs/hexdumps working on the off chance
+  // someone cats the file.
+  const output = JSON.stringify(state);
   await fs.mkdir(path.dirname(stateFile), { recursive: true });
   await fs.writeFile(stateFile, `${output}\n`, "utf8");
 }
@@ -16128,6 +19266,7 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
   ) {
     runtime.recentCodeEvents = nextCodeEvents;
     state.recentCodeEvents = nextCodeEvents;
+    invalidateDiffThreadGroupsCache();
     changed = true;
   }
 
@@ -16318,8 +19457,8 @@ function extractTitleOnlyJsonTitle(value) {
 }
 
 function preferTitleOnlyJsonThreadLabel(rawThreadLabel, conversationId, ...candidates) {
-  const preferredThreadLabel = sanitizeResolvedThreadLabel(rawThreadLabel, conversationId);
-  if (preferredThreadLabel) {
+    const preferredThreadLabel = sanitizeResolvedThreadLabel(rawThreadLabel, conversationId);
+  if (preferredThreadLabel && !isFallbackConversationLabel(preferredThreadLabel, conversationId)) {
     return preferredThreadLabel;
   }
   for (const candidate of candidates) {
@@ -16327,8 +19466,12 @@ function preferTitleOnlyJsonThreadLabel(rawThreadLabel, conversationId, ...candi
     if (titleOnlyJsonTitle) {
       return titleOnlyJsonTitle;
     }
+    const derivedSdkCliLabel = deriveClaudeSdkCliThreadLabel(candidate, conversationId);
+    if (derivedSdkCliLabel) {
+      return derivedSdkCliLabel;
+    }
   }
-  return cleanText(rawThreadLabel || "");
+  return cleanText(preferredThreadLabel || rawThreadLabel || "");
 }
 
 function stripMarkdownLinks(value) {
@@ -16400,6 +19543,25 @@ function shortId(value) {
   return text.length > 8 ? text.slice(0, 8) : text;
 }
 
+function isFallbackTimelineTitle(rawTitle, kind, threadId) {
+  const normalizedTitle = cleanText(rawTitle || "");
+  const normalizedKind = cleanText(kind || "");
+  const normalizedThreadId = cleanText(threadId || "");
+  if (!normalizedTitle) {
+    return true;
+  }
+  if (normalizedThreadId && normalizedTitle === shortId(normalizedThreadId)) {
+    return true;
+  }
+  if (normalizedTitle === kindTitle(DEFAULT_LOCALE, normalizedKind)) {
+    return true;
+  }
+  if (normalizedThreadId && normalizedTitle === formatTitle(kindTitle(DEFAULT_LOCALE, normalizedKind), shortId(normalizedThreadId))) {
+    return true;
+  }
+  return false;
+}
+
 function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
@@ -16554,6 +19716,7 @@ async function main() {
       migratedRecentCodeEventsStateChanged ||
       restoredPendingUserInputStateChanged ||
       backfilledMoltbookInboxChanged ||
+      recoveredMissingProviderStateChanged ||
       refreshResolvedThreadLabels({ config, runtime, state })
     ) {
       await saveState(config.stateFile, state);
@@ -16660,7 +19823,16 @@ async function main() {
       try {
         const dirty = await scanOnce({ config, runtime, state });
         if (dirty) {
-          await saveState(config.stateFile, state);
+          // Fire-and-forget via the debouncer rather than awaiting — the
+          // ~8 MB state file used to block the scan loop for ~50-100 ms on
+          // every dirty iteration, which directly delays the next rollout /
+          // history.jsonl read and therefore how quickly new user_message
+          // entries reach the phone. runtime/state.recentTimelineEntries are
+          // already updated synchronously inside recordTimelineEntry, so the
+          // /api/timeline response sees fresh data the moment the client
+          // next polls, regardless of when the disk write lands. Pending
+          // writes are drained in the `finally` block below on SIGINT/SIGTERM.
+          scheduleSaveState(config, state);
         }
       } catch (error) {
         console.error(`[scan-error] ${error.message}`);
@@ -16737,5 +19909,10 @@ async function main() {
     if (approvalServer) {
       await stopHttpServer(approvalServer);
     }
+
+    // Drain any state mutations that were queued via scheduleSaveState but
+    // not yet written to disk — otherwise SIGINT/SIGTERM mid-debounce would
+    // silently drop the last ~500 ms of settings/notification changes.
+    await flushPendingStateWrite(config, state);
   }
 }