viveworker 0.6.2 → 0.6.4

package/scripts/viveworker-bridge.mjs

@@ -12,6 +12,7 @@ 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 { DEFAULT_LOCALE, SUPPORTED_LOCALES, localeDisplayName, normalizeLocale, resolveLocalePreference, t } from "../web/i18n.js";
 import { generatePairingCredentials, shouldRotatePairing, upsertEnvText } from "./lib/pairing.mjs";
@@ -39,6 +40,152 @@ 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;
 
+// 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);
 loadEnvFile(envFile);
@@ -263,8 +410,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 +435,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 +938,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 +1435,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) {
@@ -2305,10 +2900,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 +2978,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);
 }
 
@@ -2563,6 +3190,9 @@ function recordCodeEvent({ config, runtime, state, entry }) {
     );
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
+  if (changed) {
+    invalidateDiffThreadGroupsCache();
+  }
   return changed;
 }
 
@@ -2614,6 +3244,9 @@ function syncRecentCodeEventsFromTimeline({ config, runtime, state }) {
     );
   runtime.recentCodeEvents = nextItems;
   state.recentCodeEvents = nextItems;
+  if (changed) {
+    invalidateDiffThreadGroupsCache();
+  }
   return changed;
 }
 
@@ -5134,11 +5767,33 @@ async function syncNativeApprovals({ config, runtime, state, conversationId, pre
         request,
         approval: existing,
       });
-      if (changed) {
-        const fileKeys = isPlainObject(existing.rawParams) ? Object.keys(existing.rawParams).join(",") : "";
-        console.log(
-          `[native-approval-refresh] ${requestKey} | files=${normalizeTimelineFileRefs(existing.fileRefs ?? []).length} | diff=${existing.diffAvailable || Boolean(existing.diffText) ? "yes" : "no"} | keys=${fileKeys || "none"}`
-        );
+      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(
+          `[native-approval-refresh] ${requestKey} | files=${normalizeTimelineFileRefs(existing.fileRefs ?? []).length} | diff=${existing.diffAvailable || Boolean(existing.diffText) ? "yes" : "no"} | keys=${fileKeys || "none"}`
+        );
       }
       continue;
     }
@@ -5156,6 +5811,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(
@@ -5633,6 +6339,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 +6377,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 +6398,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 +6419,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),
@@ -8724,6 +9438,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 +9447,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 +9583,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 +10354,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 +10513,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 +10744,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 +10764,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,6 +10789,193 @@ function buildPendingApprovalDetail(runtime, approval, locale) {
   return detail;
 }
 
+function buildAutoPilotManualReview(runtime, state, approval, locale) {
+  if (!isPlainObject(approval) || approval.readOnly === true) {
+    return null;
+  }
+  if (cleanText(approval.kind || "") !== "file") {
+    return null;
+  }
+  return buildAutoPilotWriteManualReview(runtime, state, approval, locale);
+}
+
+function buildAutoPilotWriteManualReview(runtime, state, approval, locale) {
+  const writesEnabled = isAutoPilotTrustedWritesEnabled(state);
+  if (!writesEnabled) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDisabled"),
+    };
+  }
+
+  const cwd = cleanText(approval?.cwd || approval?.rawParams?.cwd || approval?.rawParams?.grantRoot || "");
+  const workspaceRoot = cleanText(approval?.workspaceRoot || approval?.rawParams?.grantRoot || cwd);
+  if (!cwd || !workspaceRoot) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingWorkspace"),
+    };
+  }
+
+  const diffText = normalizeTimelineDiffText(approval?.diffText ?? "");
+  if (!diffText) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingDiff"),
+    };
+  }
+
+  const rawFileRefs = normalizeTimelineFileRefs(approval?.fileRefs ?? []);
+  if (rawFileRefs.length === 0) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingFiles"),
+    };
+  }
+
+  const resolvedFileRefs = resolveTrustedWriteFileRefs({
+    fileRefs: approval?.fileRefs ?? [],
+    cwd,
+    workspaceRoot,
+  });
+  if (!resolvedFileRefs) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeInvalidFiles"),
+    };
+  }
+
+  const counts = diffLineCounts(diffText);
+  const totalChangedLines =
+    Math.max(0, Number(counts.addedLines) || 0) +
+    Math.max(0, Number(counts.removedLines) || 0);
+  if (totalChangedLines === 0) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeMissingDiff"),
+    };
+  }
+  if (totalChangedLines > 120) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDiffTooLarge"),
+    };
+  }
+
+  const diffSections = splitUnifiedDiffTextByFile(diffText);
+  if (diffSections.length === 0) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDiffUnreadable"),
+    };
+  }
+  if (diffSections.length > 3) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDiffTooLarge"),
+    };
+  }
+
+  if (
+    /^(?:new file mode|deleted file mode|rename from|rename to|old mode|new mode|similarity index|dissimilarity index|GIT binary patch|Binary files )/mu.test(diffText)
+  ) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDangerousDiff"),
+    };
+  }
+
+  const diffSectionRefs = resolveTrustedWriteDiffSectionFileRefs({
+    diffSections,
+    cwd,
+    workspaceRoot,
+  });
+  if (!diffSectionRefs || !sameNormalizedFileRefSet(diffSectionRefs, resolvedFileRefs)) {
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeDiffMismatch"),
+    };
+  }
+
+  const lanes = autoPilotWriteLaneState(state);
+  const isContentOnly = resolvedFileRefs.every((fileRef) => isAutoPilotContentWritePath(fileRef));
+  if (isContentOnly) {
+    if (!lanes.content) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeContentDisabled"),
+      };
+    }
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeNoLaneMatch"),
+    };
+  }
+
+  const isUiTestsOnly = resolvedFileRefs.every((fileRef) => isAutoPilotUiTestWritePath(fileRef));
+  if (isUiTestsOnly) {
+    if (!lanes.uiTests) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeUiDisabled"),
+      };
+    }
+    if (totalChangedLines > 80) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeUiTooLarge"),
+      };
+    }
+    if (hasUnsafeUiOrTestWriteDiff(diffText)) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeUiUnsafe"),
+      };
+    }
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeNoLaneMatch"),
+    };
+  }
+
+  const isSourceOnly = resolvedFileRefs.every((fileRef) => isAutoPilotSourceWritePath(fileRef));
+  if (isSourceOnly) {
+    if (!lanes.source) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeSourceDisabled"),
+      };
+    }
+    if (totalChangedLines > 40) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeSourceTooLarge"),
+      };
+    }
+    if (hasUnsafeSourceWriteDiff(diffText)) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeSourceUnsafe"),
+      };
+    }
+    if (!hasRecentSourceReadContinuity({ runtime, state, approval, resolvedFileRefs })) {
+      return {
+        title: t(locale, "detail.autoPilot.manualTitle"),
+        body: t(locale, "detail.autoPilot.writeSourceContinuity"),
+      };
+    }
+    return {
+      title: t(locale, "detail.autoPilot.manualTitle"),
+      body: t(locale, "detail.autoPilot.writeNoLaneMatch"),
+    };
+  }
+
+  return {
+    title: t(locale, "detail.autoPilot.manualTitle"),
+    body: t(locale, "detail.autoPilot.writeNoLaneMatch"),
+  };
+}
+
 function buildPreviousApprovalContext(runtime, approval) {
   const threadId = cleanText(approval?.conversationId || "");
   const approvalCreatedAtMs = Number(approval?.createdAtMs) || 0;
@@ -10895,102 +11840,628 @@ async function handlePlanDecision({ config, runtime, state, planRequest, decisio
     }
   }
 
-  planRequest.resolved = true;
-  planRequest.resolving = false;
-  planRequest.isLiveRequestActive = false;
-  planRequest.lastSeenAtMs = Date.now();
-  planRequest.expiresAtMs = Date.now() + config.planRequestTtlMs;
-  let stateChanged = clearPlanTurnActive(state, planRequest.turnKey);
-  stateChanged = markPlanTurnSuppressed(state, planRequest.turnKey, config.maxSeenEvents) || stateChanged;
-  state.dismissedPlanRequests[planRequest.requestKey] = Date.now();
-  trimSeenEvents(state.dismissedPlanRequests, config.maxSeenEvents);
-  stateChanged = storePendingPlanRequest(state, planRequest) || stateChanged;
-  stateChanged = recordActionHistoryItem({
+  planRequest.resolved = true;
+  planRequest.resolving = false;
+  planRequest.isLiveRequestActive = false;
+  planRequest.lastSeenAtMs = Date.now();
+  planRequest.expiresAtMs = Date.now() + config.planRequestTtlMs;
+  let stateChanged = clearPlanTurnActive(state, planRequest.turnKey);
+  stateChanged = markPlanTurnSuppressed(state, planRequest.turnKey, config.maxSeenEvents) || stateChanged;
+  state.dismissedPlanRequests[planRequest.requestKey] = Date.now();
+  trimSeenEvents(state.dismissedPlanRequests, config.maxSeenEvents);
+  stateChanged = storePendingPlanRequest(state, planRequest) || stateChanged;
+  stateChanged = recordActionHistoryItem({
+    config,
+    runtime,
+    state,
+    kind: "plan",
+    stableId: `plan:${planRequest.requestKey}:${planRequest.lastSeenAtMs}`,
+    token: planRequest.token,
+    title: planRequest.title,
+    messageText: `${planDecisionMessage(decision, config.defaultLocale)}\n\n${planRequest.messageText}`,
+    summary: planDecisionMessage(decision, config.defaultLocale),
+    outcome: decision === "implement" ? "implemented" : "dismissed",
+  }) || stateChanged;
+  if (stateChanged) {
+    await saveState(config.stateFile, state);
+  }
+  console.log(`[plan-decision] ${planRequest.requestKey} | ${decision} | ${decisionTransport}`);
+}
+
+function claudeToolFingerprint(toolName, toolInput) {
+  if (!toolInput || typeof toolInput !== "object") return "";
+  if (toolName === "Bash") {
+    return String(toolInput.command || "").slice(0, 500);
+  }
+  if (toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") {
+    return String(toolInput.file_path || toolInput.path || "");
+  }
+  if (toolName === "AskUserQuestion") {
+    // PostToolUse may include the user's `answers` in toolInput, which would
+    // change a naive JSON.stringify fingerprint. Hash only the question texts.
+    try {
+      const qs = Array.isArray(toolInput.questions) ? toolInput.questions : [];
+      return JSON.stringify(qs.map((q) => String(q?.question || q?.header || ""))).slice(0, 500);
+    } catch {
+      return "";
+    }
+  }
+  if (toolName === "ExitPlanMode") {
+    return String(toolInput.plan || "").slice(0, 500);
+  }
+  try {
+    return JSON.stringify(toolInput).slice(0, 500);
+  } catch {
+    return "";
+  }
+}
+
+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: "plan",
-    stableId: `plan:${planRequest.requestKey}:${planRequest.lastSeenAtMs}`,
-    token: planRequest.token,
-    title: planRequest.title,
-    messageText: `${planDecisionMessage(decision, config.defaultLocale)}\n\n${planRequest.messageText}`,
-    summary: planDecisionMessage(decision, config.defaultLocale),
-    outcome: decision === "implement" ? "implemented" : "dismissed",
-  }) || stateChanged;
+    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);
   }
-  console.log(`[plan-decision] ${planRequest.requestKey} | ${decision} | ${decisionTransport}`);
 }
 
-function claudeToolFingerprint(toolName, toolInput) {
-  if (!toolInput || typeof toolInput !== "object") return "";
-  if (toolName === "Bash") {
-    return String(toolInput.command || "").slice(0, 500);
-  }
-  if (toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") {
-    return String(toolInput.file_path || toolInput.path || "");
-  }
-  if (toolName === "AskUserQuestion") {
-    // PostToolUse may include the user's `answers` in toolInput, which would
-    // change a naive JSON.stringify fingerprint. Hash only the question texts.
-    try {
-      const qs = Array.isArray(toolInput.questions) ? toolInput.questions : [];
-      return JSON.stringify(qs.map((q) => String(q?.question || q?.header || ""))).slice(0, 500);
-    } catch {
-      return "";
-    }
-  }
-  if (toolName === "ExitPlanMode") {
-    return String(toolInput.plan || "").slice(0, 500);
-  }
-  try {
-    return JSON.stringify(toolInput).slice(0, 500);
-  } catch {
-    return "";
+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);
   }
 }
 
-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}`);
+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 +12518,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 +12584,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 +12814,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;
@@ -11492,7 +13023,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
         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 +13163,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 +13312,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 +13334,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 +13421,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 });
       }
@@ -11975,11 +13599,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 {
@@ -12393,7 +14013,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 +14036,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 +14048,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 +14260,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 +14275,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);
 
@@ -13089,7 +14764,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") {
@@ -15443,6 +17127,23 @@ async function loadState(stateFile) {
   try {
     const raw = await fs.readFile(stateFile, "utf8");
     const parsed = JSON.parse(raw);
+    const hasExplicitWriteLaneState =
+      typeof parsed.autoPilotWriteLaneContent === "boolean" ||
+      typeof parsed.autoPilotWriteLaneUiTests === "boolean" ||
+      typeof parsed.autoPilotWriteLaneSource === "boolean";
+    const legacyTrustedWritesEnabled = parsed.autoPilotTrustedWrites === true || parsed.autoPilotTrustedWritesShadow === true;
+    const autoPilotWriteLaneContent =
+      typeof parsed.autoPilotWriteLaneContent === "boolean"
+        ? parsed.autoPilotWriteLaneContent === true
+        : !hasExplicitWriteLaneState && legacyTrustedWritesEnabled;
+    const autoPilotWriteLaneUiTests =
+      typeof parsed.autoPilotWriteLaneUiTests === "boolean"
+        ? parsed.autoPilotWriteLaneUiTests === true
+        : false;
+    const autoPilotWriteLaneSource =
+      typeof parsed.autoPilotWriteLaneSource === "boolean"
+        ? parsed.autoPilotWriteLaneSource === true
+        : false;
     return {
       fileOffsets: parsed.fileOffsets ?? {},
       seenEvents: parsed.seenEvents ?? {},
@@ -15468,6 +17169,12 @@ 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,
     };
   } catch {
@@ -15496,6 +17203,12 @@ async function loadState(stateFile) {
       pairingConsumedAt: 0,
       pairingConsumedCredential: "",
       claudeAwayMode: false,
+      autoPilotTrustedReads: false,
+      autoPilotTrustedWrites: false,
+      autoPilotTrustedWritesShadow: false,
+      autoPilotWriteLaneContent: false,
+      autoPilotWriteLaneUiTests: false,
+      autoPilotWriteLaneSource: false,
     };
   }
 }
@@ -15520,7 +17233,11 @@ async function syncClaudeAwayModeSentinel(config, enabled) {
 }
 
 async function saveState(stateFile, state) {
-  const output = JSON.stringify(state, null, 2);
+  // No indent. The state file is ~8 MB and humans don't read it; pretty-print
+  // just costs a few extra ms of stringify and ~10% more bytes on disk. The
+  // single newline at the end keeps diffs/hexdumps working on the off chance
+  // someone cats the file.
+  const output = JSON.stringify(state);
   await fs.mkdir(path.dirname(stateFile), { recursive: true });
   await fs.writeFile(stateFile, `${output}\n`, "utf8");
 }
@@ -16128,6 +17845,7 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
   ) {
     runtime.recentCodeEvents = nextCodeEvents;
     state.recentCodeEvents = nextCodeEvents;
+    invalidateDiffThreadGroupsCache();
     changed = true;
   }
 
@@ -16660,7 +18378,16 @@ async function main() {
       try {
         const dirty = await scanOnce({ config, runtime, state });
         if (dirty) {
-          await saveState(config.stateFile, state);
+          // Fire-and-forget via the debouncer rather than awaiting — the
+          // ~8 MB state file used to block the scan loop for ~50-100 ms on
+          // every dirty iteration, which directly delays the next rollout /
+          // history.jsonl read and therefore how quickly new user_message
+          // entries reach the phone. runtime/state.recentTimelineEntries are
+          // already updated synchronously inside recordTimelineEntry, so the
+          // /api/timeline response sees fresh data the moment the client
+          // next polls, regardless of when the disk write lands. Pending
+          // writes are drained in the `finally` block below on SIGINT/SIGTERM.
+          scheduleSaveState(config, state);
         }
       } catch (error) {
         console.error(`[scan-error] ${error.message}`);
@@ -16737,5 +18464,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);
   }
 }