viveworker 0.7.0-beta.0 → 0.7.0-beta.2

package/scripts/viveworker-bridge.mjs

@@ -12,18 +12,35 @@ 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";
 import { buildAgentCard, handleA2ARequest, resolveA2ATaskDecision, completeA2ATask, failA2ATask } from "./a2a-handler.mjs";
 import { registerWithRelay, startRelayPolling, stopRelayPolling, postRelayResult, getRelayStatus, updatePublicTasksFlag } from "./a2a-relay-client.mjs";
-import { createMoltbookClient, readScoutState, writeScoutState, rollScoutDayIfNeeded, markPostSeen, recordComposeAttempt, writeDraft, readDraft, deleteDraft, listPendingDrafts, solveVerificationPuzzle, solvePuzzleWithLLM, listInboxItems } from "./moltbook-api.mjs";
+import { createMoltbookClient, readScoutState, writeScoutState, rollScoutDayIfNeeded, markPostSeen, recordComposeAttempt, writeDraft, readDraft, deleteDraft, listPendingDrafts, solveVerificationPuzzle, solvePuzzleWithLLM, recordPuzzleAttempt, listInboxItems } from "./moltbook-api.mjs";
 
 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,153 @@ 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;
+
+// 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 +211,7 @@ await maybeRotateStartupPairingEnv(envFile);
 
 const config = buildConfig(cli);
 validateConfig(config);
+configureHazbaseClient(config);
 
 const runtime = {
   fileStates: new Map(),
@@ -165,6 +330,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 +429,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 +454,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 +957,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 +1454,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) {
@@ -2209,15 +2823,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 +2848,9 @@ function normalizeHistoryItem(raw) {
   if (!isPlainObject(raw)) {
     return null;
   }
+  if (shouldHideClaudeInternalItem(raw)) {
+    return null;
+  }
 
   const stableId = cleanText(raw.stableId ?? raw.id ?? "");
   const kind = cleanText(raw.kind ?? "");
@@ -2237,8 +2862,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 +2875,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 +2903,7 @@ function normalizeHistoryItem(raw) {
     ...(raw.instruction != null ? { instruction: cleanText(raw.instruction) } : {}),
     ...(raw.taskStatus != null ? { taskStatus: cleanText(raw.taskStatus) } : {}),
   };
+  return shouldHideClaudeInternalItem(normalized) ? null : normalized;
 }
 
 function historyToken(stableId) {
@@ -2305,10 +2933,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 +3011,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 +3043,9 @@ function normalizeTimelineEntry(raw) {
   if (!isPlainObject(raw)) {
     return null;
   }
+  if (shouldHideClaudeInternalItem(raw)) {
+    return null;
+  }
 
   const stableId = cleanText(raw.stableId ?? raw.id ?? "");
   const kind = cleanText(raw.kind ?? "");
@@ -2420,14 +3083,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 +3137,7 @@ function normalizeTimelineEntry(raw) {
     ...(raw.taskStatus != null ? { taskStatus: cleanText(raw.taskStatus) } : {}),
     ...(suggestions.length > 0 ? { suggestions } : {}),
   };
+  return shouldHideClaudeInternalItem(normalized) ? null : normalized;
 }
 
 function recordTimelineEntry({ config, runtime, state, entry }) {
@@ -2563,6 +3228,9 @@ function recordCodeEvent({ config, runtime, state, entry }) {
     );
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
+  if (changed) {
+    invalidateDiffThreadGroupsCache();
+  }
   return changed;
 }
 
@@ -2614,6 +3282,9 @@ function syncRecentCodeEventsFromTimeline({ config, runtime, state }) {
     );
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
+  if (changed) {
+    invalidateDiffThreadGroupsCache();
+  }
   return changed;
 }
 
@@ -2840,13 +3511,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 +3534,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 +3654,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 +3689,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 +3774,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 +4017,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 +4055,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 +4069,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 +4231,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 +4262,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 +4332,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 +4354,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) {
@@ -4826,6 +5695,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 +6005,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 +6049,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 +6131,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 +6256,8 @@ async function syncPlanImplementationRequests({
           config,
           state,
           kind: "plan",
+          tab: "inbox",
+          subtab: "pending",
           token: planRequest.token,
           stableId: pendingPlanStableId(planRequest),
           title: planRequest.title,
@@ -5515,6 +6463,8 @@ async function syncGenericUserInputRequests({
           config,
           state,
           kind: "choice",
+          tab: "inbox",
+          subtab: "pending",
           token: userInputRequest.token,
           stableId: pendingChoiceStableId(userInputRequest),
           title: userInputRequest.title,
@@ -5633,6 +6583,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 +6621,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 +6642,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 +6663,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 +8725,67 @@ 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 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 threadStateArchiveStatus(threadState) {
   if (!isPlainObject(threadState)) {
     return "";
@@ -8724,6 +9743,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 +9752,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,6 +9888,22 @@ function buildDeviceSummary({ config, state, deviceId, record, currentDeviceId,
   };
 }
 
+// Shared between `/api/session` and `/api/bootstrap` so both return an
+// identical session shape.
+function buildSessionPayload({ config, state, session }) {
+  return {
+    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 }) =>
@@ -9608,7 +10659,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 +10818,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 = [];
@@ -9988,9 +11049,10 @@ 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,
@@ -10007,6 +11069,7 @@ 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
       ? []
@@ -10031,78 +11094,265 @@ function buildPendingApprovalDetail(runtime, approval, locale) {
   return detail;
 }
 
-function buildPreviousApprovalContext(runtime, approval) {
-  const threadId = cleanText(approval?.conversationId || "");
-  const approvalCreatedAtMs = Number(approval?.createdAtMs) || 0;
-  if (!threadId || !approvalCreatedAtMs) {
-    return null;
-  }
-
-  const previousEntry = runtime.recentTimelineEntries
-    .filter((entry) => {
-      if (!timelineMessageKinds.has(entry.kind)) {
-        return false;
-      }
-      if (cleanText(entry.threadId || "") !== threadId) {
-        return false;
-      }
-      return Number(entry.createdAtMs) > 0 && Number(entry.createdAtMs) < approvalCreatedAtMs;
-    })
-    .sort((left, right) => Number(right.createdAtMs ?? 0) - Number(left.createdAtMs ?? 0))[0];
-
-  if (!previousEntry) {
+function buildAutoPilotManualReview(runtime, state, approval, locale) {
+  if (!isPlainObject(approval) || approval.readOnly === true) {
     return null;
   }
-
-  const sourceText = normalizeLongText(previousEntry.messageText || previousEntry.summary || "");
-  if (!sourceText) {
+  if (cleanText(approval.kind || "") !== "file") {
     return null;
   }
-
-  return {
-    kind: previousEntry.kind,
-    createdAtMs: Number(previousEntry.createdAtMs) || 0,
-    messageHtml: renderMessageHtml(sourceText, "<p></p>"),
-  };
+  return buildAutoPilotWriteManualReview(runtime, state, approval, locale);
 }
 
-function buildInterruptedTimelineContext(runtime, entry, locale) {
-  if (!runtime || !isTurnAbortedDisplayMessage(entry?.messageText)) {
-    return null;
+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 threadId = cleanText(entry?.threadId || "");
-  const interruptedCreatedAtMs = Number(entry?.createdAtMs) || 0;
-  if (!threadId || !interruptedCreatedAtMs) {
-    return null;
+  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 previousEntry = runtime.recentTimelineEntries
-    .filter((candidate) => {
-      if (!timelineMessageKinds.has(cleanText(candidate?.kind || ""))) {
-        return false;
-      }
-      if (cleanText(candidate?.threadId || "") !== threadId) {
-        return false;
-      }
-      if (Number(candidate?.createdAtMs) <= 0 || Number(candidate?.createdAtMs) >= interruptedCreatedAtMs) {
-        return false;
-      }
-      return !isTurnAbortedDisplayMessage(candidate?.messageText);
-    })
-    .sort((left, right) => Number(right?.createdAtMs ?? 0) - Number(left?.createdAtMs ?? 0))[0];
+  const diffText = normalizeTimelineDiffText(approval?.diffText ?? "");
+  if (!diffText) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingDiff"),
+    };
+  }
 
-  if (!previousEntry) {
-    return null;
+  const rawFileRefs = normalizeTimelineFileRefs(approval?.fileRefs ?? []);
+  if (rawFileRefs.length === 0) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingFiles"),
+    };
   }
 
-  const sourceText = normalizeLongText(previousEntry.messageText || previousEntry.summary || "");
-  if (!sourceText) {
-    return null;
+  const resolvedFileRefs = resolveTrustedWriteFileRefs({
+    fileRefs: approval?.fileRefs ?? [],
+    cwd,
+    workspaceRoot,
+  });
+  if (!resolvedFileRefs) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeInvalidFiles"),
+    };
   }
 
-  return {
-    kind: previousEntry.kind,
+  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;
+  if (!threadId || !approvalCreatedAtMs) {
+    return null;
+  }
+
+  const previousEntry = runtime.recentTimelineEntries
+    .filter((entry) => {
+      if (!timelineMessageKinds.has(entry.kind)) {
+        return false;
+      }
+      if (cleanText(entry.threadId || "") !== threadId) {
+        return false;
+      }
+      return Number(entry.createdAtMs) > 0 && Number(entry.createdAtMs) < approvalCreatedAtMs;
+    })
+    .sort((left, right) => Number(right.createdAtMs ?? 0) - Number(left.createdAtMs ?? 0))[0];
+
+  if (!previousEntry) {
+    return null;
+  }
+
+  const sourceText = normalizeLongText(previousEntry.messageText || previousEntry.summary || "");
+  if (!sourceText) {
+    return null;
+  }
+
+  return {
+    kind: previousEntry.kind,
+    createdAtMs: Number(previousEntry.createdAtMs) || 0,
+    messageHtml: renderMessageHtml(sourceText, "<p></p>"),
+  };
+}
+
+function buildInterruptedTimelineContext(runtime, entry, locale) {
+  if (!runtime || !isTurnAbortedDisplayMessage(entry?.messageText)) {
+    return null;
+  }
+
+  const threadId = cleanText(entry?.threadId || "");
+  const interruptedCreatedAtMs = Number(entry?.createdAtMs) || 0;
+  if (!threadId || !interruptedCreatedAtMs) {
+    return null;
+  }
+
+  const previousEntry = runtime.recentTimelineEntries
+    .filter((candidate) => {
+      if (!timelineMessageKinds.has(cleanText(candidate?.kind || ""))) {
+        return false;
+      }
+      if (cleanText(candidate?.threadId || "") !== threadId) {
+        return false;
+      }
+      if (Number(candidate?.createdAtMs) <= 0 || Number(candidate?.createdAtMs) >= interruptedCreatedAtMs) {
+        return false;
+      }
+      return !isTurnAbortedDisplayMessage(candidate?.messageText);
+    })
+    .sort((left, right) => Number(right?.createdAtMs ?? 0) - Number(left?.createdAtMs ?? 0))[0];
+
+  if (!previousEntry) {
+    return null;
+  }
+
+  const sourceText = normalizeLongText(previousEntry.messageText || previousEntry.summary || "");
+  if (!sourceText) {
+    return null;
+  }
+
+  return {
+    kind: previousEntry.kind,
     label: t(locale, "detail.interruptedTask"),
     createdAtMs: Number(previousEntry.createdAtMs) || 0,
     messageHtml: renderMessageHtml(sourceText, "<p></p>"),
@@ -10951,46 +12201,572 @@ function claudeToolFingerprint(toolName, toolInput) {
   }
 }
 
-function formatClaudeQuestionAnswers(questions, answers) {
-  if (!Array.isArray(questions) || !Array.isArray(answers)) return "";
-  const lines = [];
-  for (let i = 0; i < questions.length; i++) {
-    const q = questions[i] || {};
-    const ans = answers[i] || {};
-    const questionText = String(q.question || q.header || "").trim();
-    if (!questionText) continue;
-    const options = Array.isArray(q.options) ? q.options : [];
-    const optionIndices = Array.isArray(ans.optionIndices) ? ans.optionIndices : [];
-    const labels = optionIndices
-      .map((idx) => options[idx]?.label)
-      .filter((label) => typeof label === "string" && label.length > 0);
-    const note = typeof ans.note === "string" ? ans.note.trim() : "";
-    let answerLine = "";
-    if (labels.length > 0) {
-      answerLine = labels.join(", ");
-    }
-    if (note) {
-      answerLine = answerLine ? `${answerLine} (note: ${note})` : note;
-    }
-    if (!answerLine) {
-      answerLine = "(no answer)";
-    }
-    lines.push(`Q${i + 1}: ${questionText}`);
-    lines.push(`A: ${answerLine}`);
+function formatClaudeQuestionAnswers(questions, answers) {
+  if (!Array.isArray(questions) || !Array.isArray(answers)) return "";
+  const lines = [];
+  for (let i = 0; i < questions.length; i++) {
+    const q = questions[i] || {};
+    const ans = answers[i] || {};
+    const questionText = String(q.question || q.header || "").trim();
+    if (!questionText) continue;
+    const options = Array.isArray(q.options) ? q.options : [];
+    const optionIndices = Array.isArray(ans.optionIndices) ? ans.optionIndices : [];
+    const labels = optionIndices
+      .map((idx) => options[idx]?.label)
+      .filter((label) => typeof label === "string" && label.length > 0);
+    const note = typeof ans.note === "string" ? ans.note.trim() : "";
+    let answerLine = "";
+    if (labels.length > 0) {
+      answerLine = labels.join(", ");
+    }
+    if (note) {
+      answerLine = answerLine ? `${answerLine} (note: ${note})` : note;
+    }
+    if (!answerLine) {
+      answerLine = "(no answer)";
+    }
+    lines.push(`Q${i + 1}: ${questionText}`);
+    lines.push(`A: ${answerLine}`);
+  }
+  return lines.join("\n");
+}
+
+function findClaudePendingApprovalForTool(runtime, threadId, toolName, fingerprint) {
+  let match = null;
+  for (const approval of runtime.nativeApprovalsByToken.values()) {
+    if (approval.resolved) continue;
+    if (approval.conversationId !== threadId) continue;
+    if (approval.claudeToolName && toolName && approval.claudeToolName !== toolName) continue;
+    if (approval.claudeToolFingerprint && fingerprint && approval.claudeToolFingerprint !== fingerprint) continue;
+    if (!match || approval.createdAtMs > match.createdAtMs) match = approval;
+  }
+  return match;
+}
+
+function maybeAutoApproveTrustedRead({ state, commandText, cwd, workspaceRoot }) {
+  if (state?.autoPilotTrustedReads !== true) {
+    return null;
+  }
+  return evaluateTrustedReadCommandPolicy({ commandText, cwd, workspaceRoot });
+}
+
+function isAutoPilotTrustedWritesEnabled(state) {
+  return hasAnyAutoPilotWriteLaneEnabled(state);
+}
+
+function isDeniedTrustedWritePath(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 (isSensitiveCommandPath(normalized)) {
+    return true;
+  }
+  if (segments.some((segment) => [".github", ".gitlab", ".terraform", ".claude", ".husky", ".vscode"].includes(segment))) {
+    return true;
+  }
+  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;
+  }
+  return false;
+}
+
+function isAutoPilotContentWritePath(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 ([".md", ".mdx", ".txt", ".rst", ".adoc"].includes(extension)) {
+    return true;
+  }
+  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");
   }
-  return lines.join("\n");
+  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}`);
 }
 
-function findClaudePendingApprovalForTool(runtime, threadId, toolName, fingerprint) {
-  let match = null;
-  for (const approval of runtime.nativeApprovalsByToken.values()) {
-    if (approval.resolved) continue;
-    if (approval.conversationId !== threadId) continue;
-    if (approval.claudeToolName && toolName && approval.claudeToolName !== toolName) continue;
-    if (approval.claudeToolFingerprint && fingerprint && approval.claudeToolFingerprint !== fingerprint) continue;
-    if (!match || approval.createdAtMs > match.createdAtMs) match = approval;
+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");
   }
-  return match;
+  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 }) {
@@ -11047,7 +12823,7 @@ async function handleNativeApprovalDecision({ config, runtime, state, approval,
 
 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);
+    const group = (await getDiffThreadGroupsCached(runtime, state, config)).find((entry) => entry.token === token);
     return group ? buildDiffThreadDetail(group, locale) : null;
   }
   if (kind === "file_event") {
@@ -11113,7 +12889,7 @@ async function buildApiItemDetail({ config, runtime, state, kind, token, locale
   if (kind === "approval") {
     const approval = runtime.nativeApprovalsByToken.get(token);
     if (approval) {
-      return buildPendingApprovalDetail(runtime, approval, locale);
+      return buildPendingApprovalDetail(runtime, state, approval, locale);
     }
     const historicalApproval = historyItemByToken(runtime, kind, token);
     return historicalApproval ? buildHistoryDetail(historicalApproval, locale, runtime) : null;
@@ -11343,21 +13119,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 +13325,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 +13469,41 @@ function createNativeApprovalServer({ config, runtime, state }) {
         if (session.authenticated && session.restoredFromDevice) {
           setSessionCookie(res, config);
         }
+        return writeJson(res, 200, buildSessionPayload({ config, state, session }));
+      }
+
+      // 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 +13618,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 +13640,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 +13727,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 +13897,251 @@ 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 || "",
+  };
+  return writeJson(res, 200, {
+    enabled: true,
+    apiUrl: config.hazbaseApiUrl,
+    signedIn: Boolean(hazbase.accessToken),
+    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 });
+  state.hazbase = {
+    ...normalizeHazbaseState(state.hazbase),
+    email: result.email || email,
+    accessToken: cleanText(result.accessToken || ""),
+    sessionId: cleanText(result.sessionId || ""),
+    userId: cleanText(result.userId || ""),
+    accounts: Array.isArray(result.accounts) ? result.accounts : [],
+    highTrustToken: "",
+    highTrustExpiresAt: "",
+  };
+  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.",
+    });
+  }
+  const result = await requestPasskeyRegistrationChallenge({
+    emailSession: hazbase.accessToken,
+    deviceLabel: cleanText(body?.deviceLabel || config.hazbaseDeviceLabel || "") || undefined,
+    partnerOrigin,
+  });
+  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);
+  const result = await completePasskeyRegistration({
+    emailSession: hazbase.accessToken,
+    challengeId: cleanText(body?.challengeId || ""),
+    credential: body?.credential,
+    deviceLabel: cleanText(body?.deviceLabel || config.hazbaseDeviceLabel || "") || undefined,
+  });
+  state.hazbase = {
+    ...hazbase,
+    deviceBindingId: cleanText(result.deviceBindingId || hazbase.deviceBindingId || ""),
+    credentialId: cleanText(result.credentialId || hazbase.credentialId || ""),
+  };
+  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.",
+    });
+  }
+  const result = await requestPasskeyAssertionChallenge({
+    emailSession: hazbase.accessToken,
+    purpose: cleanText(body?.purpose || "bootstrap") || "bootstrap",
+    deviceBindingId: hazbase.deviceBindingId || undefined,
+    partnerOrigin,
+  });
+  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);
+  const result = await completePasskeyAssertion({
+    emailSession: hazbase.accessToken,
+    challengeId: cleanText(body?.challengeId || ""),
+    credential: body?.credential,
+    purpose: cleanText(body?.purpose || "bootstrap") || "bootstrap",
+    deviceBindingId: hazbase.deviceBindingId || undefined,
+  });
+  state.hazbase = {
+    ...hazbase,
+    deviceBindingId: cleanText(result.deviceBindingId || hazbase.deviceBindingId || ""),
+    credentialId: cleanText(result.credentialId || hazbase.credentialId || ""),
+    highTrustToken: cleanText(result.highTrustToken || ""),
+    highTrustExpiresAt: cleanText(result.highTrustExpiresAt || ""),
+  };
+  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" });
+  }
+  const result = await bootstrapPasskeyAccount({
+    emailSession: hazbase.accessToken,
+    deviceBindingId: hazbase.deviceBindingId,
+    highTrustToken: hazbase.highTrustToken,
+    chainId,
+  });
+  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,
+  };
+  await saveState(config.stateFile, state);
+  return writeJson(res, 200, result);
+}
+
+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 +14150,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 +14325,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 +14424,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 +14568,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 +14591,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 +14603,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, {
@@ -12640,6 +14815,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 +14830,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 +14890,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 +15021,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 +15204,8 @@ function createNativeApprovalServer({ config, runtime, state }) {
             config,
             state,
             kind: "moltbook_draft",
+            tab: "inbox",
+            subtab: "pending",
             token,
             stableId: `moltbook_draft:${sourceId}`,
             title: pushTitle,
@@ -13066,6 +15302,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 +15327,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") {
@@ -15038,6 +17285,12 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
   const finalTitle = draft.decision.title || draft.postTitle;
 
   let verification;
+  // Captured so the post-verify history record knows which post/comment the
+  // challenge_text was attached to. `draft.postId` only exists for replies;
+  // for `original_post` drafts the id only shows up in the POST /posts
+  // response.
+  let createdPostId = null;
+  let createdCommentId = null;
 
   if (draft.draftType === "original_post") {
     const result = await mb("/posts", {
@@ -15051,6 +17304,7 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
     });
     const post = result?.post || null;
     verification = post?.verification || null;
+    createdPostId = post?.id || null;
     console.log(`[moltbook-draft-post] Posted original post (id=${post?.id})`);
 
     const scoutState = rollScoutDayIfNeeded(await readScoutState());
@@ -15066,6 +17320,8 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
     });
     const comment = result?.comment || null;
     verification = comment?.verification || null;
+    createdPostId = draft.postId || null;
+    createdCommentId = comment?.id || null;
     console.log(`[moltbook-draft-post] Posted reply (commentId=${comment?.id}) to post ${draft.postId}`);
 
     const scoutState = rollScoutDayIfNeeded(await readScoutState());
@@ -15080,41 +17336,79 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
   }
 
   // Solve verification puzzle if present.
+  //
+  // Every attempt — success, server rejection, or complete failure — gets
+  // recorded via `recordPuzzleAttempt` so we can build a corpus of
+  // challenge_text at `~/.viveworker/moltbook-verify-history.jsonl`. This is
+  // the only way to reconstruct failing puzzles; Moltbook only returns
+  // `challenge_text` in the initial POST response.
   if (verification) {
-    let answer = solveVerificationPuzzle(verification.challenge_text);
-    const source = answer != null ? "solver" : null;
-    if (answer == null) {
-      answer = await solvePuzzleWithLLM(verification.challenge_text);
+    const solverAnswer = solveVerificationPuzzle(verification.challenge_text);
+    let submittedAnswer = solverAnswer;
+    let llmAnswer = null;
+    let outcome = "unknown";
+    let verifyError = null;
+
+    if (submittedAnswer == null) {
+      llmAnswer = await solvePuzzleWithLLM(verification.challenge_text);
+      submittedAnswer = llmAnswer;
     }
-    if (answer != null) {
+
+    if (submittedAnswer != null) {
       try {
         await mb("/verify", {
           method: "POST",
-          body: JSON.stringify({ verification_code: verification.verification_code, answer }),
+          body: JSON.stringify({ verification_code: verification.verification_code, answer: submittedAnswer }),
         });
-        console.log(`[moltbook-draft-verify] Verified with answer ${answer}`);
-      } catch (verifyError) {
+        console.log(`[moltbook-draft-verify] Verified with answer ${submittedAnswer}`);
+        outcome = solverAnswer != null && llmAnswer == null ? "solver-verified" : "llm-verified";
+      } catch (err) {
+        verifyError = err.message;
         // Wrong answer from solver — retry with LLM.
-        if (/incorrect/i.test(verifyError.message) && source === "solver") {
-          const llmAnswer = await solvePuzzleWithLLM(verification.challenge_text);
-          if (llmAnswer && llmAnswer !== answer) {
+        if (/incorrect/i.test(err.message) && solverAnswer != null && llmAnswer == null) {
+          llmAnswer = await solvePuzzleWithLLM(verification.challenge_text);
+          if (llmAnswer && llmAnswer !== solverAnswer) {
             try {
               await mb("/verify", {
                 method: "POST",
                 body: JSON.stringify({ verification_code: verification.verification_code, answer: llmAnswer }),
               });
               console.log(`[moltbook-draft-verify] Verified with LLM retry answer ${llmAnswer}`);
+              submittedAnswer = llmAnswer;
+              verifyError = null;
+              outcome = "solver-incorrect-llm-verified";
             } catch (retryError) {
               console.error(`[moltbook-draft-verify] LLM retry failed: ${retryError.message}`);
+              verifyError = retryError.message;
+              outcome = "both-incorrect";
             }
+          } else {
+            outcome = "solver-incorrect-llm-agreed-or-null";
           }
         } else {
-          console.error(`[moltbook-draft-verify] Failed: ${verifyError.message}`);
+          console.error(`[moltbook-draft-verify] Failed: ${err.message}`);
+          outcome = solverAnswer != null ? "solver-rejected" : "llm-rejected";
         }
       }
     } else {
       console.error(`[moltbook-draft-verify] Could not solve puzzle for draft ${draft.token}`);
-    }
+      outcome = "both-failed-to-solve";
+    }
+
+    // Best-effort corpus write. Never throws.
+    await recordPuzzleAttempt({
+      draftToken: draft.token,
+      draftType: draft.draftType,
+      postId: createdPostId,
+      commentId: createdCommentId,
+      challenge_text: verification.challenge_text,
+      verification_code: verification.verification_code,
+      solverAnswer,
+      llmAnswer,
+      submittedAnswer,
+      outcome,
+      verifyError,
+    });
   }
 
   // Push notification for successful post.
@@ -15122,6 +17416,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),
@@ -15154,6 +17450,9 @@ 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"),
     webUiEnabled: boolEnv("WEB_UI_ENABLED", true),
     authRequired: boolEnv("AUTH_REQUIRED", true),
     webPushEnabled: boolEnv("WEB_PUSH_ENABLED", false),
@@ -15241,6 +17540,110 @@ 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 : [],
+  };
+}
+
+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);
+  }
+}
+
+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;
+}
+
 function validateConfig(config) {
   let publicBaseUrl = null;
   try {
@@ -15396,6 +17799,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 ?? {},
@@ -15421,7 +17841,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 {
@@ -15449,6 +17876,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),
     };
   }
 }
@@ -15473,7 +17907,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");
 }
@@ -16081,6 +18519,7 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
   ) {
     runtime.recentCodeEvents = nextCodeEvents;
     state.recentCodeEvents = nextCodeEvents;
+    invalidateDiffThreadGroupsCache();
     changed = true;
   }
 
@@ -16271,8 +18710,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) {
@@ -16280,8 +18719,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) {
@@ -16353,6 +18796,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));
 }
@@ -16507,6 +18969,7 @@ async function main() {
       migratedRecentCodeEventsStateChanged ||
       restoredPendingUserInputStateChanged ||
       backfilledMoltbookInboxChanged ||
+      recoveredMissingProviderStateChanged ||
       refreshResolvedThreadLabels({ config, runtime, state })
     ) {
       await saveState(config.stateFile, state);
@@ -16613,7 +19076,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}`);
@@ -16690,5 +19162,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);
   }
 }