viveworker 0.8.0 → 0.8.2

package/scripts/viveworker-bridge.mjs

@@ -4,7 +4,7 @@ import { spawn } from "node:child_process";
 import crypto from "node:crypto";
 import { createServer as createHttpServer } from "node:http";
 import { createServer as createHttpsServer } from "node:https";
-import { promises as fs, readFileSync, createReadStream } from "node:fs";
+import { promises as fs, readFileSync, createReadStream, watch as watchFs } from "node:fs";
 import net from "node:net";
 import os from "node:os";
 import path from "node:path";
@@ -16,6 +16,7 @@ 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 { APP_BUILD_ID as WEB_APP_BUILD_ID } from "../web/build-id.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";
@@ -48,13 +49,13 @@ const listSupportedPayments = typeof hazbaseAuth.listSupportedPayments === "func
   ? hazbaseAuth.listSupportedPayments.bind(hazbaseAuth)
   : async () => ({ networks: [], defaultNetwork: "base-sepolia" });
 const appPackageVersion = readPackageVersion();
-const WEB_APP_BUILD_ID = "20260428-remote-token-refresh";
 const WEB_APP_SCRIPT_URL = `/app.js?v=${WEB_APP_BUILD_ID}`;
+const WEB_APP_BUILD_ID_PLACEHOLDER = "__VIVEWORKER_APP_BUILD_ID__";
 const sessionCookieName = "viveworker_session";
 const deviceCookieName = "viveworker_device";
 const historyKinds = new Set(["completion", "assistant_final", "plan_ready", "approval", "plan", "choice", "info", "moltbook_reply", "moltbook_draft", "thread_share", "a2a_task", "a2a_task_result"]);
 const timelineMessageKinds = new Set(["user_message", "assistant_commentary", "assistant_final"]);
-const timelineKinds = new Set([...timelineMessageKinds, "ambient_suggestions", "approval", "plan", "choice", "plan_ready", "file_event", "moltbook_reply", "moltbook_draft", "thread_share", "a2a_task", "a2a_task_result"]);
+const timelineKinds = new Set([...timelineMessageKinds, "ambient_suggestions", "approval", "plan", "choice", "plan_ready", "file_event", "command_event", "moltbook_reply", "moltbook_draft", "thread_share", "a2a_task", "a2a_task_result"]);
 const SQLITE_COMPLETION_BATCH_SIZE = 200;
 const DEFAULT_DEVICE_TRUST_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const MAX_PAIRED_DEVICES = 200;
@@ -63,7 +64,9 @@ const PAIRING_RATE_LIMIT_MAX_ATTEMPTS = 8;
 const REMOTE_PAIRING_RELAY_TOKEN_ROTATION_MS = 30 * 24 * 60 * 60 * 1000;
 const DEFAULT_COMPLETION_REPLY_IMAGE_MAX_BYTES = 15 * 1024 * 1024;
 const DEFAULT_COMPLETION_REPLY_UPLOAD_TTL_MS = 24 * 60 * 60 * 1000;
+const DEFAULT_COMPLETION_REPLY_ACK_TIMEOUT_MS = 1200;
 const MAX_COMPLETION_REPLY_IMAGE_COUNT = 4;
+const COMPLETION_PUSH_CONTENT_DEDUPE_WINDOW_MS = 2 * 60 * 1000;
 const HAZBASE_METADATA_TIMEOUT_MS = 1500;
 const NPM_VERSION_CHECK_TIMEOUT_MS = 2500;
 const NPM_VERSION_CHECK_CACHE_TTL_MS = 6 * 60 * 60 * 1000;
@@ -269,6 +272,15 @@ const runtime = {
   recentHistoryItems: [],
   recentTimelineEntries: [],
   recentCodeEvents: [],
+  timelineBus: null,
+  timelineRevision: 0,
+  timelineLiveWatchers: [],
+  timelineLiveScanTimer: null,
+  timelineLiveScanInFlight: false,
+  timelineLiveScanReschedule: false,
+  timelineLiveScanReasons: new Set(),
+  timelineLiveClaudeFiles: new Set(),
+  timelineLiveRolloutFiles: new Set(),
   pairingAttemptsByRemoteAddress: new Map(),
   ipcClient: null,
   remotePairingHandle: null,
@@ -516,6 +528,8 @@ function kindTitle(locale, kind) {
       return t(locale, "server.title.complete");
     case "file_event":
       return t(locale, "common.fileEvent");
+    case "command_event":
+      return t(locale, "common.commandEvent");
     case "diff_thread":
       return t(locale, "common.diff");
     case "a2a_task":
@@ -671,6 +685,118 @@ function formatLocalizedTitle(locale, baseKeyOrTitle, threadLabel) {
   return formatTitle(baseTitle, threadLabel);
 }
 
+function localizedThreadSharePushContent(locale, { sourceLabel = "", sourceTool = "", targetLabel = "", targetTool = "", body = "" } = {}) {
+  const source = cleanText(sourceLabel || sourceTool || "agent");
+  const target = cleanText(targetLabel || targetTool || "target");
+  return {
+    title: t(locale, "server.push.threadShare.title", { source, target }),
+    body: pushBodySnippet(body),
+  };
+}
+
+function localizedThreadShareFallbackPushContent(locale, target) {
+  const normalizedTarget = cleanText(target || "");
+  return {
+    title: t(locale, "server.push.threadShareFallback.title"),
+    body: t(locale, "server.push.threadShareFallback.body", { target: normalizedTarget }),
+  };
+}
+
+function localizedMcpNotifyTitle(locale, title) {
+  const normalizedTitle = cleanText(title || "");
+  if (!normalizedTitle || normalizedTitle === "MCP") {
+    return t(locale, "server.push.mcpNotify.title");
+  }
+  return normalizedTitle;
+}
+
+function localizedMcpApprovalPushContent(locale, approval) {
+  const kind = cleanText(approval?.kind || "mcp");
+  const title = cleanText(approval?.title || "");
+  const body = cleanText(approval?.messageText || "");
+  if (kind === "question") {
+    return {
+      title: t(locale, "server.push.mcpQuestion.title"),
+      body: pushBodySnippet(body),
+    };
+  }
+  if (kind === "file_share") {
+    const filePath = compactPath(normalizeTimelineFileRefs(approval?.fileRefs ?? [])[0] || t(locale, "common.fileEvent"));
+    const sizeMatch = body.match(/^\s*Size:\s*([^\n]+)$/imu);
+    return {
+      title: t(locale, "server.push.mcpShareFile.title"),
+      body: t(locale, "server.push.mcpShareFile.body", {
+        path: filePath,
+        size: cleanText(sizeMatch?.[1] || ""),
+      }),
+    };
+  }
+  if (kind === "a2a_task") {
+    const target = cleanText(title.match(/^Send A2A task to\s+(.+)$/iu)?.[1] || "A2A target");
+    return {
+      title: t(locale, "server.push.mcpA2aTask.title", { target }),
+      body: t(locale, "server.push.mcpA2aTask.body", { target }),
+    };
+  }
+  if (!title || title === "MCP approval") {
+    return {
+      title: t(locale, "server.push.mcpApproval.title"),
+      body: pushBodySnippet(body),
+    };
+  }
+  return { title, body: pushBodySnippet(body) };
+}
+
+function localizedPaymentApprovalPushContent(locale, approval) {
+  const payment = isPlainObject(approval?.rawParams) ? approval.rawParams : {};
+  const amount = cleanText(payment.amountUsdc || payment.amountAtomic || "");
+  const network = cleanText(payment.network || "");
+  const resource = cleanText(payment.resource || payment.url || "");
+  const titleKey = cleanText(approval?.kind || "") === "hazbase_wallet_payment"
+    ? "server.push.hazbasePayment.title"
+    : "server.push.paymentApproval.title";
+  return {
+    title: t(locale, titleKey, { amount }),
+    body: t(locale, "server.push.paymentApproval.body", { amount, network, resource }),
+  };
+}
+
+function localizedMoltbookReplyPushContent(locale, item) {
+  const title = cleanText(item?.title || "");
+  return {
+    title: !title || title === "Moltbook reply" ? t(locale, "server.push.moltbookReply.title") : title,
+    body: cleanText(item?.summary || "") || t(locale, "server.push.moltbookReply.body"),
+  };
+}
+
+function localizedMoltbookDraftPushTitle(locale, { draftType = "", postTitle = "", slot = "" } = {}) {
+  const normalizedPostTitle = cleanText(postTitle || "");
+  if (draftType !== "original_post") {
+    return t(locale, "server.push.moltbookDraft.replyTitle", { postTitle: normalizedPostTitle });
+  }
+  switch (cleanText(slot || "")) {
+    case "morning":
+      return t(locale, "server.push.moltbookDraft.originalMorning");
+    case "noon":
+      return t(locale, "server.push.moltbookDraft.originalNoon");
+    case "evening":
+      return t(locale, "server.push.moltbookDraft.originalEvening");
+    default:
+      return normalizedPostTitle || t(locale, "server.push.moltbookDraft.originalTitle");
+  }
+}
+
+function localizedMoltbookPostedBody(locale, draft, finalTitle) {
+  if (cleanText(draft?.draftType || "") === "original_post") {
+    return t(locale, "server.push.moltbookDraft.postedOriginalBody", { title: cleanText(finalTitle || draft?.postTitle || "") });
+  }
+  return t(locale, "server.push.moltbookDraft.postedReplyBody", { postTitle: cleanText(draft?.postTitle || "") });
+}
+
+function pushBodySnippet(value, maxChars = 160) {
+  return truncate(singleLine(value || ""), maxChars);
+}
+
 function notificationIconPrefix(kind) {
   switch (kind) {
     case "approval":
@@ -703,13 +829,17 @@ function normalizeTimelineOutcome(value) {
 
 function normalizeTimelineFileEventType(value) {
   const normalized = cleanText(value || "").toLowerCase();
-  return ["read", "write", "create", "delete", "rename"].includes(normalized) ? normalized : "";
+  return ["read", "search", "command", "write", "create", "delete", "rename"].includes(normalized) ? normalized : "";
 }
 
 function fileEventTitle(locale, fileEventType) {
   switch (normalizeTimelineFileEventType(fileEventType)) {
     case "read":
       return t(locale, "fileEvent.read");
+    case "search":
+      return t(locale, "fileEvent.search");
+    case "command":
+      return t(locale, "fileEvent.command");
     case "write":
       return t(locale, "fileEvent.write");
     case "create":
@@ -728,6 +858,10 @@ function fileEventDetailCopy(locale, fileEventType, provider) {
   switch (normalizeTimelineFileEventType(fileEventType)) {
     case "read":
       return t(locale, "detail.fileEvent.read", vars);
+    case "search":
+      return t(locale, "detail.fileEvent.search", vars);
+    case "command":
+      return t(locale, "detail.fileEvent.command", vars);
     case "write":
       return t(locale, "detail.fileEvent.write", vars);
     case "create":
@@ -1435,6 +1569,87 @@ function extractCommandLineFromFunctionOutput(outputText) {
   return unwrapShellCommand(match?.[1] || "");
 }
 
+function parseToolArgumentsJson(value) {
+  if (isPlainObject(value)) {
+    return value;
+  }
+  if (typeof value !== "string" || !value.trim()) {
+    return null;
+  }
+  const parsed = safeJsonParse(value);
+  return isPlainObject(parsed) ? parsed : null;
+}
+
+function commandBaseName(command) {
+  const normalized = cleanText(command || "");
+  if (!normalized) {
+    return "";
+  }
+  return path.basename(normalized);
+}
+
+function classifyTimelineCommand(commandText) {
+  const normalizedCommand = unwrapShellCommand(commandText);
+  const tokens = tokenizeShellWords(normalizedCommand);
+  if (tokens.length === 0) {
+    return {
+      fileEventType: "command",
+      command: "",
+      commandText: normalizedCommand,
+      fileRefs: [],
+    };
+  }
+
+  const command = commandBaseName(tokens[0]);
+  const gitSubcommand = command === "git" ? cleanText(tokens[1] || "") : "";
+  let fileEventType = "command";
+  if (["rg", "grep", "ag", "ack", "fd", "find"].includes(command) || gitSubcommand === "grep") {
+    fileEventType = "search";
+  } else if (
+    ["cat", "sed", "nl", "head", "tail", "wc", "ls", "pwd", "less", "more"].includes(command) ||
+    (command === "git" && ["status", "diff", "show", "log", "ls-files", "branch"].includes(gitSubcommand))
+  ) {
+    fileEventType = "read";
+  }
+
+  return {
+    fileEventType,
+    command,
+    commandText: normalizedCommand,
+    fileRefs: extractReadFileRefsFromCommand(normalizedCommand),
+  };
+}
+
+function redactTimelineCommandText(commandText) {
+  return cleanText(commandText || "")
+    .replace(/((?:--)?(?:api[-_]?key|token|secret|password|credential)(?:=|\s+))(["']?)[^\s"']+\2/giu, "$1[redacted]")
+    .replace(/\b([A-Z0-9_]*(?:API_KEY|TOKEN|SECRET|PASSWORD|CREDENTIAL)[A-Z0-9_]*=)(["']?)[^\s"']+\2/giu, "$1[redacted]");
+}
+
+function timelineCommandMessage(locale, { commandText = "", toolName = "", fileRefs = [] } = {}) {
+  const commandBlock = commandText
+    ? `${t(locale, "server.message.commandLabel")}\n\`\`\`sh\n${redactTimelineCommandText(commandText)}\n\`\`\``
+    : "";
+  const toolBlock = !commandBlock && toolName
+    ? `${t(locale, "server.message.toolLabel")}\n\`\`\`text\n${cleanText(toolName)}\n\`\`\``
+    : "";
+  const files = normalizeTimelineFileRefs(fileRefs);
+  const filesBlock = files.length
+    ? `${t(locale, "server.message.filesLabel")}\n\`\`\`text\n${files.join("\n")}\n\`\`\``
+    : "";
+  return [commandBlock || toolBlock, filesBlock].filter(Boolean).join("\n\n");
+}
+
+function timelineCommandSummary(commandText, fallback = "") {
+  const redacted = redactTimelineCommandText(commandText);
+  return truncate(singleLine(redacted || fallback || ""), 180);
+}
+
+function firstMarkdownCodeFenceText(text) {
+  const match = String(text || "").match(/```(?:\w+)?\n([\s\S]*?)\n```/u);
+  return cleanText(match?.[1] || "");
+}
+
 function extractReadFileRefsFromCommand(commandText) {
   const normalizedCommand = unwrapShellCommand(commandText);
   const tokens = tokenizeShellWords(normalizedCommand);
@@ -1663,6 +1878,36 @@ function rememberApplyPatchInput(fileState, payload, createdAtMs = Date.now()) {
   }
 }
 
+function rememberToolEventInput(fileState, payload, createdAtMs = Date.now()) {
+  const callId = cleanText(payload?.call_id || payload?.callId || payload?.id || "");
+  if (!callId) {
+    return null;
+  }
+  if (!(fileState.toolEventInputsByCallId instanceof Map)) {
+    fileState.toolEventInputsByCallId = new Map();
+  }
+  const stored = {
+    callId,
+    name: cleanText(payload?.name || ""),
+    arguments: parseToolArgumentsJson(payload?.arguments),
+    createdAtMs: Number(createdAtMs) || Date.now(),
+  };
+  fileState.toolEventInputsByCallId.set(callId, stored);
+  while (fileState.toolEventInputsByCallId.size > 128) {
+    const oldestKey = fileState.toolEventInputsByCallId.keys().next().value;
+    fileState.toolEventInputsByCallId.delete(oldestKey);
+  }
+  return stored;
+}
+
+function findStoredToolEventInput(fileState, callId) {
+  const normalizedCallId = cleanText(callId || "");
+  if (!normalizedCallId || !(fileState?.toolEventInputsByCallId instanceof Map)) {
+    return null;
+  }
+  return fileState.toolEventInputsByCallId.get(normalizedCallId) || null;
+}
+
 async function findStoredApplyPatchInput({ fileState, callId, rolloutFilePath }) {
   const normalizedCallId = cleanText(callId || "");
   if (!normalizedCallId) {
@@ -2067,6 +2312,7 @@ async function ensureRolloutFileState(runtime, threadId, rolloutFilePath) {
     threadId: cleanText(threadId || ""),
     cwd: await findRolloutThreadCwd(runtime, threadId || ""),
     applyPatchInputsByCallId: new Map(),
+    toolEventInputsByCallId: new Map(),
     startupCutoffMs: 0,
     skipPartialLine: false,
   };
@@ -2839,6 +3085,7 @@ function normalizeProvider(value) {
   if (normalized === "moltbook") return "moltbook";
   if (normalized === "a2a") return "a2a";
   if (normalized === "viveworker") return "viveworker";
+  if (normalized === "mcp") return "mcp";
   return "codex";
 }
 
@@ -2848,6 +3095,7 @@ function providerDisplayName(locale, provider) {
   if (p === "moltbook") return "Moltbook";
   if (p === "a2a") return "A2A";
   if (p === "viveworker") return t(locale, "common.appName");
+  if (p === "mcp") return "MCP";
   return t(locale, "common.codex");
 }
 
@@ -2896,7 +3144,7 @@ function normalizeHistoryItem(raw) {
   const threadId = cleanText(raw.threadId ?? extractConversationIdFromStableId(stableId) ?? "");
   const rawThreadLabel = cleanText(raw.threadLabel ?? "");
   const historyProvider = normalizeProvider(raw.provider);
-  const skipHistoryThreadLabelRewrite = historyProvider === "moltbook" || historyProvider === "a2a" || historyProvider === "viveworker"
+  const skipHistoryThreadLabelRewrite = historyProvider === "moltbook" || historyProvider === "a2a" || historyProvider === "viveworker" || historyProvider === "mcp"
     || kind === "moltbook_reply" || kind === "moltbook_draft" || kind === "a2a_task" || kind === "a2a_task_result" || kind === "thread_share";
   const threadLabel = skipHistoryThreadLabelRewrite
     ? rawThreadLabel
@@ -3138,6 +3386,8 @@ function timelineKindSortPriority(kind) {
       return 60;
     case "ambient_suggestions":
       return 52;
+    case "command_event":
+      return 46;
     case "file_event":
       return 45;
     case "assistant_final":
@@ -3160,7 +3410,9 @@ function normalizeTimelineEntry(raw) {
   }
 
   const stableId = cleanText(raw.stableId ?? raw.id ?? "");
-  const kind = cleanText(raw.kind ?? "");
+  const rawKind = cleanText(raw.kind ?? "");
+  const fileEventType = normalizeTimelineFileEventType(raw.fileEventType ?? "");
+  const kind = rawKind === "file_event" && fileEventType === "command" ? "command_event" : rawKind;
   const createdAtMs = Number(raw.createdAtMs) || Date.now();
   if (!stableId || !timelineKinds.has(kind)) {
     return null;
@@ -3169,7 +3421,6 @@ function normalizeTimelineEntry(raw) {
   const threadId = cleanText(raw.threadId ?? extractConversationIdFromStableId(stableId) ?? "");
   const rawMessageText = raw.messageText ?? "";
   const messageText = normalizeTimelineMessageText(rawMessageText);
-  const fileEventType = normalizeTimelineFileEventType(raw.fileEventType ?? "");
   const diffText = normalizeTimelineDiffText(raw.diffText ?? "");
   const diffSource = normalizeTimelineDiffSource(raw.diffSource ?? "");
   const diffCounts = diffLineCounts(diffText);
@@ -3183,7 +3434,7 @@ function normalizeTimelineEntry(raw) {
     (kind === "file_event" ? "" : cleanText(raw.title ?? "")) ||
     "";
   const rawProvider = normalizeProvider(raw.provider);
-  const skipThreadLabelRewrite = rawProvider === "moltbook" || rawProvider === "a2a" || rawProvider === "viveworker"
+  const skipThreadLabelRewrite = rawProvider === "moltbook" || rawProvider === "a2a" || rawProvider === "viveworker" || rawProvider === "mcp"
     || kind === "moltbook_reply" || kind === "moltbook_draft" || kind === "a2a_task" || kind === "a2a_task_result" || kind === "thread_share";
   const threadLabel =
     skipThreadLabelRewrite
@@ -3261,7 +3512,78 @@ function normalizeTimelineEntry(raw) {
   return shouldHideInternalTimelineItem(normalized) ? null : normalized;
 }
 
-function recordTimelineEntry({ config, runtime, state, entry }) {
+class TimelineBus {
+  constructor() {
+    this.clients = new Set();
+  }
+
+  addClient(client) {
+    this.clients.add(client);
+    return () => {
+      this.clients.delete(client);
+    };
+  }
+
+  emit(eventName, payload) {
+    for (const client of [...this.clients]) {
+      try {
+        client.send(eventName, payload);
+      } catch {
+        try {
+          client.close?.();
+        } catch {}
+        this.clients.delete(client);
+      }
+    }
+  }
+
+  closeAll() {
+    for (const client of [...this.clients]) {
+      try {
+        client.close?.();
+      } catch {}
+    }
+    this.clients.clear();
+  }
+}
+
+function ensureTimelineBus(runtime) {
+  if (!runtime.timelineBus) {
+    runtime.timelineBus = new TimelineBus();
+  }
+  return runtime.timelineBus;
+}
+
+function buildTimelineUpdatePayload({ runtime, entry, source = "unknown" }) {
+  runtime.timelineRevision = (Number(runtime.timelineRevision) || 0) + 1;
+  return {
+    revision: runtime.timelineRevision,
+    token: cleanText(entry?.token || historyToken(entry?.stableId || entry?.createdAtMs || "")).slice(0, 120),
+    stableId: cleanText(entry?.stableId || "").slice(0, 180),
+    kind: cleanText(entry?.kind || "").slice(0, 80),
+    provider: cleanText(entry?.provider || "").slice(0, 40),
+    threadId: cleanText(entry?.threadId || "").slice(0, 120),
+    createdAtMs: Number(entry?.createdAtMs) || 0,
+    source: cleanText(source || "unknown").slice(0, 80),
+    ingestAtMs: Date.now(),
+  };
+}
+
+function publishTimelineUpdate({ config, runtime, entry, source = "unknown" }) {
+  if (!config?.timelineLiveSync || !runtime || !entry) {
+    return;
+  }
+  const payload = buildTimelineUpdatePayload({ runtime, entry, source });
+  console.log(
+    `[timeline-ingest] at=${new Date(payload.ingestAtMs).toISOString()} ` +
+    `provider=${payload.provider || "unknown"} kind=${payload.kind || "unknown"} ` +
+    `token=${payload.token || "none"} createdAtMs=${payload.createdAtMs || 0} ` +
+    `source=${payload.source || "unknown"} revision=${payload.revision}`
+  );
+  ensureTimelineBus(runtime).emit("timeline:update", payload);
+}
+
+function recordTimelineEntry({ config, runtime, state, entry, source = "unknown" }) {
   const normalized = normalizeTimelineEntry(entry);
   if (!normalized) {
     return false;
@@ -3278,6 +3600,10 @@ function recordTimelineEntry({ config, runtime, state, entry }) {
   const changed = timelineProjectionChanged(nextItems, runtime.recentTimelineEntries, [
     "stableId",
     "title",
+    "summary",
+    "messageText",
+    "fileEventType",
+    "fileRefs",
     "createdAtMs",
     "diffAvailable",
     "diffSource",
@@ -3288,6 +3614,9 @@ function recordTimelineEntry({ config, runtime, state, entry }) {
   ]);
   runtime.recentTimelineEntries = nextItems;
   state.recentTimelineEntries = nextItems;
+  if (changed) {
+    publishTimelineUpdate({ config, runtime, entry: normalized, source });
+  }
   return changed;
 }
 
@@ -3408,6 +3737,18 @@ function historyItemFromEvent(event) {
   });
 }
 
+function completionPushContentDedupeId(event) {
+  if (!event || event.kind !== "task_complete") {
+    return "";
+  }
+  const threadId = cleanText(event.threadId ?? event.conversationId ?? "unknown") || "unknown";
+  const messageText = normalizeLongText(event.detailText || event.message || "");
+  if (!messageText) {
+    return "";
+  }
+  return `task_complete_content:${threadId}:${historyToken(messageText)}`;
+}
+
 function recordHistoryItem({ config, runtime, state, item }) {
   const normalized = normalizeHistoryItem(item);
   if (!normalized) {
@@ -3570,6 +3911,7 @@ function recordActionHistoryItem({
     runtime,
     state,
     entry: item,
+    source: "event",
   });
   return historyChanged || timelineChanged;
 }
@@ -3729,7 +4071,20 @@ function pushDeliveryKey(deviceId, stableId) {
   return `${cleanText(deviceId || "")}:${cleanText(stableId || "")}`;
 }
 
-async function deliverWebPushItem({ config, state, kind, token, stableId, title, body, tab = "", subtab = "", buildLocalizedContent = null }) {
+async function deliverWebPushItem({
+  config,
+  state,
+  kind,
+  token,
+  stableId,
+  title,
+  body,
+  tab = "",
+  subtab = "",
+  buildLocalizedContent = null,
+  dedupeId = "",
+  dedupeWindowMs = 0,
+}) {
   if (!config.webPushEnabled || config.dryRun) {
     return false;
   }
@@ -3746,8 +4101,18 @@ async function deliverWebPushItem({ config, state, kind, token, stableId, title,
   let changed = false;
 
   for (const subscription of subscriptions) {
-    const deliveryKey = pushDeliveryKey(subscription.deviceId, stableId);
-    if (state.pushDeliveries[deliveryKey]) {
+    const now = Date.now();
+    const stableDeliveryKey = pushDeliveryKey(subscription.deviceId, stableId);
+    const dedupeDeliveryKey = pushDeliveryKey(subscription.deviceId, dedupeId || stableId);
+    const stableDeliveredAt = Number(state.pushDeliveries[stableDeliveryKey]) || 0;
+    const dedupeDeliveredAt = Number(state.pushDeliveries[dedupeDeliveryKey]) || 0;
+    if (stableDeliveredAt) {
+      continue;
+    }
+    if (
+      dedupeDeliveredAt &&
+      (!dedupeWindowMs || now - dedupeDeliveredAt <= Math.max(0, Number(dedupeWindowMs) || 0))
+    ) {
       continue;
     }
 
@@ -3775,8 +4140,10 @@ async function deliverWebPushItem({ config, state, kind, token, stableId, title,
         },
         payload
       );
-      const now = Date.now();
-      state.pushDeliveries[deliveryKey] = now;
+      state.pushDeliveries[stableDeliveryKey] = now;
+      if (dedupeDeliveryKey !== stableDeliveryKey) {
+        state.pushDeliveries[dedupeDeliveryKey] = now;
+      }
       trimSeenEvents(state.pushDeliveries, config.maxSeenEvents * 4);
       const stored = normalizePushSubscriptionRecord(state.pushSubscriptions?.[subscription.id]);
       if (stored) {
@@ -3928,6 +4295,207 @@ async function scanOnce({ config, runtime, state }) {
   return dirty;
 }
 
+function isPathWithin(parentDir, candidatePath) {
+  const parent = path.resolve(parentDir || "");
+  const candidate = path.resolve(candidatePath || "");
+  if (!parent || !candidate) return false;
+  return candidate === parent || candidate.startsWith(`${parent}${path.sep}`);
+}
+
+function isClaudeTranscriptPath(config, filePath) {
+  return Boolean(
+    filePath &&
+    filePath.endsWith(".jsonl") &&
+    isPathWithin(config.claudeProjectsDir, filePath)
+  );
+}
+
+function isRolloutFilePath(filePath) {
+  const base = path.basename(filePath || "");
+  return base.startsWith("rollout-") && base.endsWith(".jsonl");
+}
+
+function watchedEventPath(root, filename) {
+  if (!filename) return root;
+  const text = Buffer.isBuffer(filename) ? filename.toString("utf8") : String(filename);
+  if (!text) return root;
+  return path.isAbsolute(text) ? text : path.join(root, text);
+}
+
+function addTimelineLiveWatcher({ runtime, label, targetPath, options = {}, onChange }) {
+  if (!targetPath) return;
+  try {
+    const watcher = watchFs(targetPath, options, (_eventType, filename) => {
+      onChange(watchedEventPath(targetPath, filename));
+    });
+    watcher.on?.("error", (err) => {
+      console.warn(`[timeline-live-watch-error] ${label} ${err?.message || err}`);
+    });
+    runtime.timelineLiveWatchers.push(watcher);
+    console.log(`[timeline-live-watch] ${label} ${targetPath}`);
+  } catch (err) {
+    console.warn(`[timeline-live-watch-skip] ${label} ${targetPath} ${err?.message || err}`);
+  }
+}
+
+function scheduleTimelineLiveScan({ config, runtime, state, reason = "unknown", filePath = "" }) {
+  if (!config.timelineLiveSync || runtime.stopping) {
+    return;
+  }
+  runtime.timelineLiveScanReasons.add(cleanText(reason || "unknown").slice(0, 80));
+  const normalizedPath = cleanText(filePath || "");
+  if (isClaudeTranscriptPath(config, normalizedPath)) {
+    runtime.timelineLiveClaudeFiles.add(normalizedPath);
+  } else if (isRolloutFilePath(normalizedPath)) {
+    runtime.timelineLiveRolloutFiles.add(normalizedPath);
+  }
+
+  if (runtime.timelineLiveScanTimer) {
+    return;
+  }
+  runtime.timelineLiveScanTimer = setTimeout(() => {
+    runtime.timelineLiveScanTimer = null;
+    runPendingTimelineLiveScan({ config, runtime, state }).catch((err) => {
+      console.warn(`[timeline-live-scan-error] ${err?.message || err}`);
+    });
+  }, Math.max(25, Number(config.timelineLiveDebounceMs) || 150));
+  runtime.timelineLiveScanTimer.unref?.();
+}
+
+async function runPendingTimelineLiveScan({ config, runtime, state }) {
+  if (runtime.timelineLiveScanInFlight) {
+    runtime.timelineLiveScanReschedule = true;
+    return;
+  }
+  runtime.timelineLiveScanInFlight = true;
+  const reasons = new Set(runtime.timelineLiveScanReasons);
+  const claudeFiles = [...runtime.timelineLiveClaudeFiles];
+  const rolloutFiles = [...runtime.timelineLiveRolloutFiles];
+  runtime.timelineLiveScanReasons.clear();
+  runtime.timelineLiveClaudeFiles.clear();
+  runtime.timelineLiveRolloutFiles.clear();
+
+  let dirty = false;
+  const now = Date.now();
+  try {
+    if (reasons.has("codex-home") || reasons.has("codex-history") || reasons.has("codex-logs")) {
+      if (!config.codexLogsDbFile) {
+        const latestLogsDbFile = await findLatestCodexLogsDbFile(config.codexHome);
+        if (latestLogsDbFile && latestLogsDbFile !== runtime.logsDbFile) {
+          runtime.logsDbFile = latestLogsDbFile;
+        }
+      }
+      dirty = (await processHistoryTimelineFile({ config, runtime, state, now })) || dirty;
+      if (config.notifyCompletions || config.webUiEnabled) {
+        dirty = (await processSqliteCompletionLog({ config, runtime, state, now })) || dirty;
+      }
+      if (config.webUiEnabled) {
+        dirty = (await processSqliteTimelineLog({ config, runtime, state, now })) || dirty;
+      }
+    }
+
+    for (const filePath of rolloutFiles.slice(0, 12)) {
+      if (!runtime.knownFiles.includes(filePath)) {
+        runtime.knownFiles.push(filePath);
+        runtime.knownFiles.sort();
+      }
+      dirty = (await processRolloutFile({ filePath, config, runtime, state, now })) || dirty;
+    }
+
+    let claudeTranscriptChanged = false;
+    let claudeTargets = claudeFiles;
+    if (reasons.has("claude-dir") && claudeTargets.length === 0) {
+      claudeTargets = await listClaudeTranscriptFiles(config.claudeProjectsDir, config.claudeTranscriptMaxAgeMs);
+    }
+    for (const filePath of claudeTargets.slice(0, 24)) {
+      if (!runtime.claudeKnownFiles.includes(filePath)) {
+        runtime.claudeKnownFiles.push(filePath);
+      }
+      const changed = await processClaudeTranscriptFile({ filePath, config, runtime, state, now });
+      claudeTranscriptChanged = claudeTranscriptChanged || changed;
+      dirty = dirty || changed;
+    }
+    if (claudeTranscriptChanged) {
+      dirty = refreshResolvedThreadLabels({ config, runtime, state }) || dirty;
+    }
+
+    if (dirty) {
+      scheduleSaveState(config, state);
+    }
+  } finally {
+    runtime.timelineLiveScanInFlight = false;
+    if (runtime.timelineLiveScanReschedule || runtime.timelineLiveScanReasons.size > 0) {
+      runtime.timelineLiveScanReschedule = false;
+      scheduleTimelineLiveScan({ config, runtime, state, reason: "reschedule" });
+    }
+  }
+}
+
+function startTimelineLiveSync({ config, runtime, state }) {
+  if (config.dryRun || !config.webUiEnabled || !config.timelineLiveSync) {
+    return null;
+  }
+
+  addTimelineLiveWatcher({
+    runtime,
+    label: "codex-home",
+    targetPath: config.codexHome,
+    onChange: (filePath) => {
+      const base = path.basename(filePath || "");
+      if (filePath === config.historyFile || base === path.basename(config.historyFile || "")) {
+        scheduleTimelineLiveScan({ config, runtime, state, reason: "codex-history", filePath });
+        return;
+      }
+      if (/^logs(?:_\d+)?\.sqlite(?:-wal|-shm)?$/u.test(base)) {
+        scheduleTimelineLiveScan({ config, runtime, state, reason: "codex-logs", filePath });
+      }
+    },
+  });
+
+  addTimelineLiveWatcher({
+    runtime,
+    label: "codex-sessions",
+    targetPath: config.sessionsDir,
+    options: { recursive: true },
+    onChange: (filePath) => {
+      if (isRolloutFilePath(filePath)) {
+        scheduleTimelineLiveScan({ config, runtime, state, reason: "codex-rollout", filePath });
+      }
+    },
+  });
+
+  addTimelineLiveWatcher({
+    runtime,
+    label: "claude-projects",
+    targetPath: config.claudeProjectsDir,
+    options: { recursive: true },
+    onChange: (filePath) => {
+      scheduleTimelineLiveScan({
+        config,
+        runtime,
+        state,
+        reason: isClaudeTranscriptPath(config, filePath) ? "claude-file" : "claude-dir",
+        filePath,
+      });
+    },
+  });
+
+  return {
+    close() {
+      if (runtime.timelineLiveScanTimer) {
+        clearTimeout(runtime.timelineLiveScanTimer);
+        runtime.timelineLiveScanTimer = null;
+      }
+      for (const watcher of runtime.timelineLiveWatchers.splice(0)) {
+        try {
+          watcher.close();
+        } catch {}
+      }
+      runtime.timelineBus?.closeAll?.();
+    },
+  };
+}
+
 async function processRolloutFile({ filePath, config, runtime, state, now }) {
   let stat;
   try {
@@ -3951,6 +4519,7 @@ async function processRolloutFile({ filePath, config, runtime, state, now }) {
       threadId: extractThreadIdFromRolloutPath(filePath),
       cwd: null,
       applyPatchInputsByCallId: new Map(),
+      toolEventInputsByCallId: new Map(),
       startupCutoffMs:
         typeof restoredOffset === "number" ? 0 : now - config.replaySeconds * 1000,
       skipPartialLine:
@@ -4028,6 +4597,7 @@ async function processRolloutFile({ filePath, config, runtime, state, now }) {
             runtime,
             state,
             entry: timelineEntry,
+            source: "codex-rollout",
           }) || dirty;
       }
 
@@ -4045,6 +4615,7 @@ async function processRolloutFile({ filePath, config, runtime, state, now }) {
             runtime,
             state,
             entry: fileTimelineEntry,
+            source: "codex-rollout",
           }) || dirty;
         dirty =
           recordCodeEvent({
@@ -4231,6 +4802,109 @@ async function listClaudeTranscriptFiles(claudeProjectsDir, maxAgeMs = 0) {
   }
 }
 
+function buildClaudeToolTimelineEntries({ content, threadId, threadLabel, uuid, createdAtMs, cwd }) {
+  if (!Array.isArray(content) || !threadId) {
+    return [];
+  }
+
+  const entries = [];
+  for (const block of content) {
+    if (!isPlainObject(block) || block.type !== "tool_use") {
+      continue;
+    }
+    const toolName = cleanText(block.name || "");
+    const input = isPlainObject(block.input) ? block.input : {};
+    const toolId = cleanText(block.id || block.tool_use_id || "") || historyToken(JSON.stringify(block));
+    const callId = `${uuid || createdAtMs}:${toolId}`;
+    const lowerToolName = toolName.toLowerCase();
+
+    if (lowerToolName === "bash") {
+      const commandText = cleanText(input.command || "");
+      if (!commandText) {
+        continue;
+      }
+      const classified = classifyTimelineCommand(commandText);
+      entries.push(
+        buildToolTimelineEntry({
+          provider: "claude",
+          threadId,
+          threadLabel,
+          callId,
+          createdAtMs,
+          fileEventType: classified.fileEventType,
+          commandText: classified.commandText || commandText,
+          fileRefs: classified.fileRefs,
+          cwd,
+        })
+      );
+      continue;
+    }
+
+    if (["write", "edit", "multiedit", "todowrite", "exitplanmode", "askuserquestion"].includes(lowerToolName)) {
+      continue;
+    }
+
+    if (lowerToolName === "read") {
+      const fileRefs = normalizeTimelineFileRefs([input.file_path || input.path || input.filePath].filter(Boolean));
+      entries.push(
+        buildToolTimelineEntry({
+          provider: "claude",
+          threadId,
+          threadLabel,
+          callId,
+          createdAtMs,
+          fileEventType: "read",
+          toolName,
+          summaryText: fileRefs[0] ? `${toolName}: ${fileRefs[0]}` : toolName,
+          fileRefs,
+          cwd,
+        })
+      );
+      continue;
+    }
+
+    if (["grep", "glob", "websearch", "webfetch"].includes(lowerToolName)) {
+      const query = cleanText(input.pattern || input.query || input.url || "");
+      const fileRefs = normalizeTimelineFileRefs([input.path || input.file_path || input.filePath].filter(Boolean));
+      entries.push(
+        buildToolTimelineEntry({
+          provider: "claude",
+          threadId,
+          threadLabel,
+          callId,
+          createdAtMs,
+          fileEventType: "search",
+          toolName,
+          summaryText: query ? `${toolName}: ${query}` : toolName,
+          fileRefs,
+          cwd,
+        })
+      );
+      continue;
+    }
+
+    if (lowerToolName === "ls") {
+      const fileRefs = normalizeTimelineFileRefs([input.path].filter(Boolean));
+      entries.push(
+        buildToolTimelineEntry({
+          provider: "claude",
+          threadId,
+          threadLabel,
+          callId,
+          createdAtMs,
+          fileEventType: "read",
+          toolName,
+          summaryText: fileRefs[0] ? `${toolName}: ${fileRefs[0]}` : toolName,
+          fileRefs,
+          cwd,
+        })
+      );
+    }
+  }
+
+  return entries.filter(Boolean);
+}
+
 async function processClaudeTranscriptFile({ filePath, config, runtime, state, now }) {
   let fileState = runtime.claudeFileStates.get(filePath);
   if (!fileState) {
@@ -4346,6 +5020,20 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
     const claudeTitle = threadId ? runtime.claudeSessionTitles.get(threadId) || "" : "";
     const threadLabel = claudeTitle || fileState.threadLabel || "";
 
+    if (type === "assistant" && Array.isArray(content)) {
+      const toolEntries = buildClaudeToolTimelineEntries({
+        content,
+        threadId,
+        threadLabel,
+        uuid,
+        createdAtMs,
+        cwd: fileState.cwd,
+      });
+      for (const toolEntry of toolEntries) {
+        dirty = recordTimelineEntry({ config, runtime, state, entry: toolEntry, source: "claude-tool" }) || dirty;
+      }
+    }
+
     let text = "";
     if (typeof content === "string") {
       text = content;
@@ -4354,7 +5042,10 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
         if (block?.type === "text" && block.text) text += block.text;
       }
     }
-    text = cleanText(text);
+    // Preserve paragraph structure for the renderer — `cleanText` collapses
+    // every \s+ (newlines included) into a single space, which would flatten
+    // markdown tables / code fences / lists into a single illegible line.
+    text = normalizeLongText(text);
     if (!text) continue;
     if (type === "user" && record.entrypoint === "sdk-cli") {
       const derivedThreadLabel = deriveClaudeSdkCliThreadLabel(text, threadId);
@@ -4398,7 +5089,7 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
       provider: "claude",
     });
     if (entry) {
-      dirty = recordTimelineEntry({ config, runtime, state, entry }) || dirty;
+      dirty = recordTimelineEntry({ config, runtime, state, entry, source: "claude-transcript" }) || dirty;
 
       // Also record Claude assistant_final as a history item for the completed list
       if (kind === "assistant_final") {
@@ -4707,6 +5398,7 @@ async function processSqliteTimelineLog({ config, runtime, state, now }) {
           runtime,
           state,
           entry,
+          source: "codex-sqlite",
         }) || dirty;
 
       // Also record Codex assistant_final as a history item so it appears
@@ -4858,6 +5550,7 @@ async function processHistoryTimelineFile({ config, runtime, state, now }) {
         runtime,
         state,
         entry,
+        source: "codex-history",
       }) || dirty;
   }
 
@@ -5032,6 +5725,7 @@ async function backfillRecentTimelineEntryDiffs({ config, runtime, state }) {
         threadId: cleanText(entry?.threadId || ""),
         cwd: await findRolloutThreadCwd(runtime, entry?.threadId || ""),
         applyPatchInputsByCallId: new Map(),
+        toolEventInputsByCallId: new Map(),
         startupCutoffMs: 0,
         skipPartialLine: false,
       };
@@ -5604,6 +6298,47 @@ function buildRolloutUserTimelineEntry({ record, fileState, runtime }) {
   });
 }
 
+function buildToolTimelineEntry({
+  provider,
+  threadId,
+  threadLabel,
+  callId,
+  createdAtMs,
+  fileEventType,
+  commandText = "",
+  toolName = "",
+  summaryText = "",
+  fileRefs = [],
+  cwd = "",
+}) {
+  const normalizedType = normalizeTimelineFileEventType(fileEventType) || "command";
+  const normalizedRefs = normalizeTimelineFileRefs(fileRefs);
+  const kind = normalizedType === "command" ? "command_event" : "file_event";
+  const stableKey = callId || historyToken(`${threadId}:${createdAtMs}:${normalizedType}:${commandText || toolName}:${normalizedRefs.join("|")}`);
+  const messageText = timelineCommandMessage(DEFAULT_LOCALE, {
+    commandText,
+    toolName,
+    fileRefs: normalizedRefs,
+  });
+  const summary = timelineCommandSummary(commandText, summaryText || toolName) || fileEventTitle(DEFAULT_LOCALE, normalizedType);
+  return normalizeTimelineEntry({
+    stableId: `${kind}:${normalizedType}:${threadId}:${stableKey}`,
+    token: historyToken(`${kind}:${normalizedType}:${threadId}:${stableKey}`),
+    kind,
+    fileEventType: normalizedType,
+    threadId,
+    threadLabel,
+    title: kind === "command_event" ? kindTitle(DEFAULT_LOCALE, "command_event") : fileEventTitle(DEFAULT_LOCALE, normalizedType),
+    summary,
+    messageText,
+    fileRefs: normalizedRefs,
+    createdAtMs,
+    cwd,
+    readOnly: true,
+    provider,
+  });
+}
+
 async function buildRolloutFileTimelineEntries({ config, record, fileState, runtime, rolloutFilePath = "" }) {
   if (!isPlainObject(record) || cleanText(record.type) !== "response_item") {
     return [];
@@ -5624,30 +6359,54 @@ async function buildRolloutFileTimelineEntries({ config, record, fileState, runt
     cwd: fileState.cwd || "",
   });
 
+  if (payloadType === "function_call" && cleanText(payload?.name || "") === "exec_command") {
+    const stored = rememberToolEventInput(fileState, payload, createdAtMs);
+    const args = stored?.arguments || {};
+    const commandText = cleanText(args.cmd || args.command || "");
+    if (!commandText) {
+      return [];
+    }
+    const classified = classifyTimelineCommand(commandText);
+    return [
+      buildToolTimelineEntry({
+        provider: "codex",
+        threadId,
+        threadLabel,
+        callId,
+        createdAtMs,
+        fileEventType: classified.fileEventType,
+        commandText: classified.commandText || commandText,
+        fileRefs: classified.fileRefs,
+        cwd: cleanText(args.workdir || fileState.cwd || ""),
+      }),
+    ].filter(Boolean);
+  }
+
   if (payloadType === "custom_tool_call") {
     rememberApplyPatchInput(fileState, payload, createdAtMs);
     return [];
   }
 
   if (payloadType === "function_call_output") {
+    if (findStoredToolEventInput(fileState, callId)) {
+      return [];
+    }
     const commandText = extractCommandLineFromFunctionOutput(payload.output ?? "");
-    const fileRefs = extractReadFileRefsFromCommand(commandText);
-    if (fileRefs.length === 0) {
+    if (!commandText) {
       return [];
     }
+    const classified = classifyTimelineCommand(commandText);
     return [
-      normalizeTimelineEntry({
-        stableId: `file_event:read:${threadId}:${callId || historyToken(`${threadId}:${createdAtMs}:${fileRefs.join("|")}`)}`,
-        token: historyToken(`file_event:read:${threadId}:${callId || createdAtMs}`),
-        kind: "file_event",
-        fileEventType: "read",
+      buildToolTimelineEntry({
+        provider: "codex",
         threadId,
         threadLabel,
-        title: fileEventTitle(DEFAULT_LOCALE, "read"),
-        summary: "",
-        fileRefs,
+        callId,
         createdAtMs,
-        readOnly: true,
+        fileEventType: classified.fileEventType,
+        commandText: classified.commandText || commandText,
+        fileRefs: classified.fileRefs,
+        cwd: fileState.cwd || "",
       }),
     ].filter(Boolean);
   }
@@ -5878,6 +6637,8 @@ async function processScannedEvent({ config, runtime, state, event }) {
         subtab: "completed",
         token: historyToken(event.id),
         stableId: event.id,
+        dedupeId: completionPushContentDedupeId(event),
+        dedupeWindowMs: COMPLETION_PUSH_CONTENT_DEDUPE_WINDOW_MS,
         title: event.title,
         body: event.detailText || event.message,
         buildLocalizedContent: ({ locale }) => ({
@@ -6096,6 +6857,8 @@ function buildRolloutEvent({ record, filePath, fileState, sessionIndex, config,
       threadLabel: context.threadLabel,
       message,
       detailText,
+      threadId,
+      turnId,
       priority: config.completePriority,
       tags: config.completeTags,
       clickUrl: config.clickUrl,
@@ -6329,7 +7092,7 @@ async function syncNativeApprovals({ config, runtime, state, conversationId, pre
         body: approval.messageText,
         buildLocalizedContent: ({ locale }) => ({
           title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
-          body: approval.messageText,
+          body: formatNativeApprovalMessage(approval.kind, approval.rawParams, locale),
         }),
       }) || stateChanged;
   }
@@ -6665,7 +7428,11 @@ async function syncGenericUserInputRequests({
               userInputRequest.supported ? "server.title.choice" : "server.title.choiceReadOnly",
               userInputRequest.threadLabel
             ),
-            body: userInputRequest.notificationText || userInputRequest.messageText,
+            body: buildUserInputNotificationText(
+              userInputRequest.questions,
+              userInputRequest.supported,
+              locale
+            ),
           }),
         }) || stateChanged;
     }
@@ -8463,7 +9230,7 @@ class NativeIpcClient {
     );
   }
 
-  async startTurn(conversationId, turnStartParams, ownerClientId = null) {
+  async startTurn(conversationId, turnStartParams, ownerClientId = null, options = {}) {
     return this.sendThreadFollowerRequest(
       "thread-follower-start-turn",
       {
@@ -8471,11 +9238,12 @@ class NativeIpcClient {
         turnStartParams,
       },
       conversationId,
-      ownerClientId
+      ownerClientId,
+      options
     );
   }
 
-  async startTurnDirect(conversationId, turnStartParams, ownerClientId = null) {
+  async startTurnDirect(conversationId, turnStartParams, ownerClientId = null, options = {}) {
     const targetClientId =
       ownerClientId ??
       this.runtime.threadOwnerClientIds.get(conversationId) ??
@@ -8483,7 +9251,7 @@ class NativeIpcClient {
     return this.sendRequest(
       "turn/start",
       buildDirectTurnStartPayload(conversationId, turnStartParams),
-      { targetClientId }
+      { targetClientId, ...options }
     );
   }
 
@@ -8513,12 +9281,13 @@ class NativeIpcClient {
     );
   }
 
-  sendThreadFollowerRequest(method, params, conversationId, ownerClientId = null) {
+  sendThreadFollowerRequest(method, params, conversationId, ownerClientId = null, options = {}) {
     return this.sendRequest(method, params, {
       targetClientId:
         ownerClientId ??
         this.runtime.threadOwnerClientIds.get(conversationId) ??
         null,
+      ...options,
     });
   }
 
@@ -10593,55 +11362,323 @@ function setPairingCookies(res, config, existingDeviceId = "") {
   ]);
 }
 
-function clearAuthCookies(res, config) {
-  const secure = config.nativeApprovalPublicBaseUrl.startsWith("https://");
-  res.setHeader("Set-Cookie", [
-    buildCookieHeader(sessionCookieName, { value: "", maxAgeSecs: 0, secure }),
-    buildCookieHeader(deviceCookieName, { value: "", maxAgeSecs: 0, secure }),
-  ]);
+function clearAuthCookies(res, config) {
+  const secure = config.nativeApprovalPublicBaseUrl.startsWith("https://");
+  res.setHeader("Set-Cookie", [
+    buildCookieHeader(sessionCookieName, { value: "", maxAgeSecs: 0, secure }),
+    buildCookieHeader(deviceCookieName, { value: "", maxAgeSecs: 0, secure }),
+  ]);
+}
+
+function normalizePushSubscriptionBody(payload, deviceId) {
+  const endpoint = cleanText(payload?.subscription?.endpoint ?? payload?.endpoint ?? "");
+  const p256dh = cleanText(
+    payload?.subscription?.keys?.p256dh ??
+    payload?.keys?.p256dh ??
+    payload?.p256dh ??
+    ""
+  );
+  const auth = cleanText(
+    payload?.subscription?.keys?.auth ??
+    payload?.keys?.auth ??
+    payload?.auth ??
+    ""
+  );
+  if (!endpoint || !p256dh || !auth || !deviceId) {
+    return null;
+  }
+  return normalizePushSubscriptionRecord({
+    id: pushSubscriptionId(endpoint),
+    endpoint,
+    keys: { p256dh, auth },
+    deviceId,
+    userAgent: cleanText(payload?.userAgent ?? ""),
+    standalone: payload?.standalone === true,
+    createdAtMs: Date.now(),
+    updatedAtMs: Date.now(),
+  });
+}
+
+function buildPushStatusResponse(config, state, session) {
+  const current = getPushSubscriptionForDevice(state, session.deviceId);
+  return {
+    enabled: config.webPushEnabled,
+    secureOrigin: config.nativeApprovalPublicBaseUrl.startsWith("https://"),
+    vapidPublicKey: config.webPushEnabled ? config.webPushVapidPublicKey : "",
+    subject: config.webPushEnabled ? config.webPushSubject : "",
+    deviceId: session.deviceId || null,
+    subscribed: Boolean(current),
+    subscriptionId: current?.id || null,
+    lastSuccessfulDeliveryAtMs: Number(current?.lastSuccessfulDeliveryAtMs) || 0,
+  };
+}
+
+async function buildMcpStatusResponse(config, runtime, state) {
+  const remote = getRemotePairingStatus(runtime);
+  let remotePairings = 0;
+  try {
+    remotePairings = (await loadPairings()).length;
+  } catch {
+    remotePairings = 0;
+  }
+  const now = Date.now();
+  const pairedDevices = isPlainObject(state.pairedDevices) ? state.pairedDevices : {};
+  const trustedDevices = Object.values(pairedDevices).filter((raw) => {
+    const record = normalizeDeviceTrustRecord(raw, { trustTtlMs: config.deviceTrustTtlMs, now });
+    return record && !record.revokedAtMs && Number(record.trustedUntilMs) > now;
+  }).length;
+  const a2aRelay = getRelayStatus();
+  return {
+    ok: true,
+    bridge: {
+      running: true,
+      publicBaseUrl: config.nativeApprovalPublicBaseUrl,
+      locale: config.defaultLocale,
+      codexConnected: Boolean(runtime.ipcClient?.clientId),
+    },
+    pairing: {
+      trustedDevices,
+      webPushEnabled: Boolean(config.webPushEnabled),
+      pushSubscriptions: listPushSubscriptions(state).length,
+    },
+    remote: {
+      enabled: Boolean(remote.enabled),
+      relayUrl: remote.relayUrl || config.remotePairingRelayUrl || "",
+      identityFingerprint: remote.identityFingerprint || null,
+      pairings: remotePairings,
+      sessions: Array.isArray(remote.sessions)
+        ? remote.sessions.map((session) => ({
+            state: cleanText(session?.state || ""),
+            lastRoute: cleanText(session?.lastRoute || ""),
+            connected: cleanText(session?.state || "") === "connected",
+            phoneFingerprint: cleanText(session?.phoneFingerprint || ""),
+            lastSeenAtMs: Number(session?.lastSeenAtMs) || 0,
+          }))
+        : [],
+    },
+    a2a: {
+      enabled: Boolean(config.a2aApiKey),
+      relayEnabled: Boolean(config.a2aRelayUrl && config.a2aRelayUserId),
+      relayConnected: Boolean(a2aRelay.polling && a2aRelay.lastPollOk),
+      userIdConfigured: Boolean(config.a2aRelayUserId),
+    },
+    share: {
+      enabled: Boolean(config.a2aRelayUserId && config.a2aApiKey),
+      shareUrl: config.a2aShareUrl || "",
+    },
+    moltbook: {
+      enabled: Boolean(config.moltbookApiKey),
+    },
+  };
+}
+
+function mcpTimeoutMs(value) {
+  const n = Number(value);
+  if (!Number.isFinite(n)) return 600_000;
+  return Math.max(10_000, Math.min(900_000, Math.floor(n)));
+}
+
+function mcpText(value, maxChars = 50_000) {
+  const text = String(value ?? "");
+  return text.length > maxChars ? `${text.slice(0, maxChars)}\n\n[truncated by viveworker MCP]` : text;
+}
+
+function normalizeMcpStringArray(value, maxItems = 20) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((item) => cleanText(item ?? ""))
+    .filter(Boolean)
+    .slice(0, maxItems);
+}
+
+function normalizeMcpQuestionOptions(value) {
+  if (!Array.isArray(value)) return [];
+  return value
+    .map((option, index) => {
+      if (typeof option === "string") {
+        const label = cleanText(option);
+        return label ? { label } : null;
+      }
+      if (!isPlainObject(option)) return null;
+      const label = cleanText(option.label ?? option.title ?? `Option ${index + 1}`);
+      if (!label) return null;
+      const description = cleanText(option.description ?? option.detail ?? "");
+      return { label, ...(description ? { description } : {}) };
+    })
+    .filter(Boolean)
+    .slice(0, 10);
+}
+
+function normalizeMcpApprovalKind(value) {
+  const normalized = cleanText(value || "mcp").toLowerCase();
+  if (!/^[a-z0-9_-]{1,40}$/u.test(normalized)) {
+    return "mcp";
+  }
+  // Keep MCP in the normal approval lane. These kinds have provider-specific
+  // UI/actions elsewhere and should not be spoofable from a generic MCP client.
+  if (normalized === "payment" || normalized === "hazbase_wallet_payment" || normalized === "plan" || normalized === "question") {
+    return "mcp";
+  }
+  return normalized;
+}
+
+function createMcpPendingApproval(body, kind) {
+  const token = crypto.randomBytes(18).toString("hex");
+  const requestId = cleanText(body.requestId || crypto.randomUUID());
+  const title = cleanText(body.title || (kind === "question" ? "MCP question" : "MCP approval"));
+  const messageText = kind === "question"
+    ? mcpText(body.question || body.message || "")
+    : mcpText(body.messageText || body.message || "");
+  const requestKey = `mcp:${requestId}`;
+  const approval = {
+    token,
+    requestKey,
+    conversationId: "mcp",
+    requestId,
+    ownerClientId: null,
+    kind,
+    threadLabel: title || "MCP",
+    title,
+    messageText,
+    fileRefs: normalizeMcpStringArray(body.fileRefs),
+    previousFileRefs: [],
+    diffText: kind === "question" ? "" : mcpText(body.diffText || "", 100_000),
+    diffAvailable: kind !== "question" && Boolean(body.diffText),
+    diffSource: kind === "question" ? "" : "mcp",
+    diffAddedLines: 0,
+    diffRemovedLines: 0,
+    cwd: "",
+    workspaceRoot: "",
+    createdAtMs: Date.now(),
+    resolved: false,
+    resolving: false,
+    resolveMcpWaiter: null,
+    provider: "mcp",
+    planText: "",
+    questions: [],
+    notifyOnly: false,
+    readOnly: false,
+  };
+  if (kind === "question") {
+    approval.questions = [
+      {
+        question: mcpText(body.question || body.message || "", 2000),
+        options: normalizeMcpQuestionOptions(body.options),
+        multiSelect: body.multiSelect === true,
+      },
+    ];
+  }
+  return approval;
+}
+
+async function waitForMcpApprovalResult(runtime, approval, timeoutMs) {
+  const waitMs = mcpTimeoutMs(timeoutMs);
+  const result = await new Promise((resolve) => {
+    const timer = setTimeout(() => {
+      resolve({ approved: false, decision: "timeout" });
+    }, waitMs);
+    approval.resolveMcpWaiter = (value) => {
+      clearTimeout(timer);
+      resolve(value);
+    };
+  });
+  if (!approval.resolved) {
+    approval.resolved = true;
+    approval.resolving = false;
+    runtime.nativeApprovalsByToken.delete(approval.token);
+    runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+  }
+  return result;
 }
 
-function normalizePushSubscriptionBody(payload, deviceId) {
-  const endpoint = cleanText(payload?.subscription?.endpoint ?? payload?.endpoint ?? "");
-  const p256dh = cleanText(
-    payload?.subscription?.keys?.p256dh ??
-    payload?.keys?.p256dh ??
-    payload?.p256dh ??
-    ""
-  );
-  const auth = cleanText(
-    payload?.subscription?.keys?.auth ??
-    payload?.keys?.auth ??
-    payload?.auth ??
-    ""
-  );
-  if (!endpoint || !p256dh || !auth || !deviceId) {
-    return null;
+async function handleMcpProviderEvent({ config, runtime, state, body, res }) {
+  const eventType = cleanText(body.eventType || "");
+  if (eventType === "status") {
+    return writeJson(res, 200, await buildMcpStatusResponse(config, runtime, state));
   }
-  return normalizePushSubscriptionRecord({
-    id: pushSubscriptionId(endpoint),
-    endpoint,
-    keys: { p256dh, auth },
-    deviceId,
-    userAgent: cleanText(payload?.userAgent ?? ""),
-    standalone: payload?.standalone === true,
-    createdAtMs: Date.now(),
-    updatedAtMs: Date.now(),
-  });
-}
 
-function buildPushStatusResponse(config, state, session) {
-  const current = getPushSubscriptionForDevice(state, session.deviceId);
-  return {
-    enabled: config.webPushEnabled,
-    secureOrigin: config.nativeApprovalPublicBaseUrl.startsWith("https://"),
-    vapidPublicKey: config.webPushEnabled ? config.webPushVapidPublicKey : "",
-    subject: config.webPushEnabled ? config.webPushSubject : "",
-    deviceId: session.deviceId || null,
-    subscribed: Boolean(current),
-    subscriptionId: current?.id || null,
-    lastSuccessfulDeliveryAtMs: Number(current?.lastSuccessfulDeliveryAtMs) || 0,
-  };
+  if (eventType === "notify") {
+    const title = cleanText(body.title || "MCP");
+    const messageText = mcpText(body.message || body.messageText || "");
+    if (!messageText) {
+      return writeJson(res, 400, { error: "missing-message" });
+    }
+    const stableId = `mcp_notify:${historyToken(`${title}:${messageText}:${Date.now()}`)}`;
+    const token = historyToken(stableId);
+    const entry = {
+      stableId,
+      token,
+      kind: "assistant_commentary",
+      threadId: "mcp",
+      threadLabel: cleanText(body.threadLabel || "MCP"),
+      title,
+      summary: formatNotificationBody(messageText, 160) || messageText,
+      messageText,
+      createdAtMs: Date.now(),
+      readOnly: true,
+      provider: "mcp",
+    };
+    const timelineChanged = recordTimelineEntry({ config, runtime, state, entry });
+    const historyChanged = recordHistoryItem({ config, runtime, state, item: entry });
+    const pushChanged = await deliverWebPushItem({
+      config,
+      state,
+      kind: "assistant_commentary",
+      tab: "timeline",
+      token,
+      stableId,
+      title,
+      body: messageText,
+      buildLocalizedContent: ({ locale }) => ({
+        title: localizedMcpNotifyTitle(locale, title),
+        body: pushBodySnippet(messageText),
+      }),
+    }).catch((error) => {
+      console.error(`[mcp-notify-push] ${error.message}`);
+      return false;
+    });
+    if (timelineChanged || historyChanged || pushChanged) {
+      await saveState(config.stateFile, state);
+    }
+    return writeJson(res, 200, { ok: true, token });
+  }
+
+  if (eventType === "approval_request" || eventType === "choice_request") {
+    const kind = eventType === "choice_request" ? "question" : normalizeMcpApprovalKind(body.approvalKind);
+    if (kind !== "question" && !mcpText(body.message || body.messageText || "")) {
+      return writeJson(res, 400, { error: "missing-message" });
+    }
+    if (kind === "question" && !mcpText(body.question || body.message || "")) {
+      return writeJson(res, 400, { error: "missing-question" });
+    }
+    const approval = createMcpPendingApproval(body, kind);
+    runtime.nativeApprovalsByToken.set(approval.token, approval);
+    runtime.nativeApprovalsByRequestKey.set(approval.requestKey, approval);
+    deliverWebPushItem({
+      config,
+      state,
+      kind: "approval",
+      tab: "inbox",
+      subtab: "pending",
+      token: approval.token,
+      stableId: pendingApprovalStableId(approval),
+      title: approval.title || "MCP",
+      body: approval.messageText,
+      buildLocalizedContent: ({ locale }) => localizedMcpApprovalPushContent(locale, approval),
+    }).catch((error) => {
+      console.error(`[mcp-approval-push] ${approval.requestKey} | ${error.message}`);
+    });
+    const result = await waitForMcpApprovalResult(runtime, approval, body.timeoutMs);
+    return writeJson(res, 200, {
+      ok: true,
+      approved: result?.approved === true || result?.decision === "accept",
+      decision: result?.decision || (result?.approved ? "accept" : "reject"),
+      ...(result?.answerText ? { answerText: result.answerText } : {}),
+      ...(Array.isArray(result?.answers) ? { answers: result.answers } : {}),
+    });
+  }
+
+  return writeJson(res, 400, { error: "unsupported-mcp-event" });
 }
 
 function requestUserAgent(req) {
@@ -10992,6 +12029,17 @@ function historyItemByToken(runtime, kind, token) {
   ) ?? null;
 }
 
+function approvalDecisionFromHistoryItem(item) {
+  const outcome = cleanText(item?.outcome || "");
+  if (outcome === "approved") {
+    return "accept";
+  }
+  if (outcome === "rejected") {
+    return "decline";
+  }
+  return "";
+}
+
 function listLatestPersistedUserInputRequests({ config, runtime, state }) {
   const byToken = new Map();
   for (const userInputRequest of runtime.userInputRequestsByToken.values()) {
@@ -12065,6 +13113,48 @@ function findNewerThreadMessageAfterCompletion(runtime, completionItem) {
     .sort((left, right) => Number(right?.createdAtMs ?? 0) - Number(left?.createdAtMs ?? 0))[0] || null;
 }
 
+function normalizeCompletionReplyComparisonText(value) {
+  return normalizeLongText(value).replace(/\s+/gu, " ").trim();
+}
+
+function isMatchingCompletionReplyTimelineMessage(entry, messageText, expectedImageCount = 0) {
+  if (cleanText(entry?.kind || "") !== "user_message") {
+    return false;
+  }
+  const expectedText = normalizeCompletionReplyComparisonText(messageText);
+  const actualText = normalizeCompletionReplyComparisonText(entry?.messageText || entry?.summary || entry?.title || "");
+  if (!expectedText || actualText !== expectedText) {
+    return false;
+  }
+  const entryImageCount = normalizeTimelineImagePaths(entry?.imagePaths || []).length;
+  return expectedImageCount <= 0 || entryImageCount === expectedImageCount;
+}
+
+function findMatchingCompletionReplyAfterCompletion(runtime, completionItem, messageText, expectedImageCount = 0) {
+  const itemKind = cleanText(completionItem?.kind || "");
+  if (!runtime || !REPLYABLE_HISTORY_KINDS.has(itemKind)) {
+    return null;
+  }
+
+  const threadId = historyItemThreadId(completionItem);
+  const completionCreatedAtMs = Number(completionItem?.createdAtMs) || 0;
+  if (!threadId || !completionCreatedAtMs) {
+    return null;
+  }
+
+  return runtime.recentTimelineEntries
+    .filter((entry) => {
+      if (cleanText(entry?.threadId || "") !== threadId) {
+        return false;
+      }
+      if (Number(entry?.createdAtMs) <= completionCreatedAtMs) {
+        return false;
+      }
+      return isMatchingCompletionReplyTimelineMessage(entry, messageText, expectedImageCount);
+    })
+    .sort((left, right) => Number(right?.createdAtMs ?? 0) - Number(left?.createdAtMs ?? 0))[0] || null;
+}
+
 function buildHistoryDetail(item, locale, runtime = null) {
   const threadId = historyItemThreadId(item);
   const replyEnabled =
@@ -12182,6 +13272,13 @@ function buildAmbientSuggestionsDetail(entry, locale) {
 
 function buildTimelineFileEventDetail(entry, locale) {
   const fileEventType = normalizeTimelineFileEventType(entry?.fileEventType ?? "");
+  const commandText = ["read", "search"].includes(fileEventType)
+    ? firstMarkdownCodeFenceText(entry?.messageText ?? "")
+    : "";
+  const detailText = [
+    fileEventDetailCopy(locale, fileEventType, entry?.provider),
+    commandText ? "" : normalizeTimelineMessageText(entry?.messageText ?? "", locale),
+  ].filter(Boolean).join("\n\n");
   return {
     kind: "file_event",
     token: entry.token,
@@ -12190,9 +13287,10 @@ function buildTimelineFileEventDetail(entry, locale) {
     threadLabel: entry.threadLabel || "",
     fileEventType,
     createdAtMs: Number(entry.createdAtMs) || 0,
-    messageHtml: renderMessageHtml(fileEventDetailCopy(locale, fileEventType, entry?.provider), `<p>${escapeHtml(t(locale, "detail.detailUnavailable"))}</p>`),
+    messageHtml: renderMessageHtml(detailText, `<p>${escapeHtml(t(locale, "detail.detailUnavailable"))}</p>`),
     fileRefs: normalizeTimelineFileRefs(entry.fileRefs ?? []),
     previousFileRefs: normalizeTimelineFileRefs(entry.previousFileRefs ?? []),
+    ...(commandText ? { commandText } : {}),
     diffAvailable: Boolean(entry.diffAvailable),
     diffText: normalizeTimelineDiffText(entry.diffText ?? ""),
     diffSource: normalizeTimelineDiffSource(entry.diffSource ?? ""),
@@ -12203,6 +13301,25 @@ function buildTimelineFileEventDetail(entry, locale) {
   };
 }
 
+function buildTimelineCommandEventDetail(entry, locale) {
+  const commandText = firstMarkdownCodeFenceText(entry?.messageText ?? "") || cleanText(entry?.summary || "");
+  const detailText = t(locale, "detail.commandEvent.copy", { provider: providerDisplayName(locale, entry?.provider) });
+  return {
+    kind: "command_event",
+    token: entry.token,
+    threadId: cleanText(entry.threadId || ""),
+    title: cleanText(entry.threadLabel || entry.title || "") || kindTitle(locale, "command_event"),
+    threadLabel: entry.threadLabel || "",
+    fileEventType: "command",
+    createdAtMs: Number(entry.createdAtMs) || 0,
+    messageHtml: renderMessageHtml(detailText, `<p>${escapeHtml(t(locale, "detail.detailUnavailable"))}</p>`),
+    commandText,
+    fileRefs: normalizeTimelineFileRefs(entry.fileRefs ?? []),
+    readOnly: true,
+    actions: [],
+  };
+}
+
 function buildDiffThreadDetail(group, locale) {
   const changedFileCount = Math.max(0, Number(group.changedFileCount) || 0);
   return {
@@ -12576,6 +13693,25 @@ async function handleCompletionReply({
   if (!conversationId) {
     throw new Error("completion-reply-unavailable");
   }
+  console.log(
+    `[completion-reply] received at=${new Date().toISOString()} ` +
+    `token=${cleanText(completionItem?.token || "") || "unknown"} thread=${conversationId} ` +
+    `images=${normalizedLocalImagePaths.length} plan=${planMode ? 1 : 0} force=${force ? 1 : 0}`
+  );
+
+  const alreadyAcceptedReply = findMatchingCompletionReplyAfterCompletion(
+    runtime,
+    completionItem,
+    messageText,
+    normalizedLocalImagePaths.length
+  );
+  if (alreadyAcceptedReply && !force) {
+    console.log(
+      `[completion-reply] idempotent token=${cleanText(completionItem?.token || "") || "unknown"} thread=${conversationId} timeline=${cleanText(alreadyAcceptedReply.stableId || alreadyAcceptedReply.token || "") || "unknown"}`
+    );
+    return { alreadyAccepted: true };
+  }
+
   // For assistant_final, check against timeline entries (avoids maxHistoryItems eviction).
   // For legacy completion, check against history items.
   const itemKind = cleanText(completionItem?.kind || "");
@@ -12666,30 +13802,32 @@ async function handleCompletionReply({
         await runtime.ipcClient.startTurnDirect(
           conversationId,
           candidate.turnStartParams,
-          ownerClientId
+          ownerClientId,
+          { timeoutMs: config.completionReplyAckTimeoutMs }
         );
       } else {
         await runtime.ipcClient.startTurn(
           conversationId,
           candidate.turnStartParams,
-          ownerClientId
+          ownerClientId,
+          { timeoutMs: config.completionReplyAckTimeoutMs }
         );
       }
       console.log(
-        `[completion-reply] success candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")}`
+        `[completion-reply] success at=${new Date().toISOString()} candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")}`
       );
       await finalizeReplyAccepted();
-      return;
+      return { alreadyAccepted: false };
     } catch (error) {
       if (isStartTurnAckTimeout(error)) {
         // Codex can create the turn but fail to send the bridge an ACK before
         // its internal follower timeout fires. Retrying risks duplicate user
         // turns, so treat this as accepted and let the timeline catch up.
         console.log(
-          `[completion-reply] accepted candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")} ack-timeout=${normalizeIpcErrorMessage(error)}`
+          `[completion-reply] accepted at=${new Date().toISOString()} candidate=${candidate.name} transport=${cleanText(candidate.transport || "thread-follower")} ack-timeout=${normalizeIpcErrorMessage(error)}`
         );
         await finalizeReplyAccepted();
-        return;
+        return { alreadyAccepted: false, ackTimeout: true };
       }
       lastError = error;
       console.log(
@@ -13380,7 +14518,12 @@ async function autoApproveTrustedWrite({
 }
 
 async function handleNativeApprovalDecision({ config, runtime, state, approval, decision }) {
-  if (approval.resolveClaudeWaiter) {
+  if (approval.resolveMcpWaiter) {
+    approval.resolveMcpWaiter({
+      approved: decision === "accept",
+      decision,
+    });
+  } else if (approval.resolveClaudeWaiter) {
     if (approval.provider === "claude" && approval.kind === "plan") {
       // ExitPlanMode cannot be truly auto-approved via permissionDecision: "allow"
       // (Claude still shows the native PC plan dialog). Instead, deny the tool
@@ -13440,6 +14583,10 @@ async function buildApiItemDetail({ config, runtime, state, kind, token, locale
     const entry = timelineEntryByToken(runtime, token, kind);
     return entry ? buildTimelineFileEventDetail(entry, locale) : null;
   }
+  if (kind === "command_event") {
+    const entry = timelineEntryByToken(runtime, token, kind);
+    return entry ? buildTimelineCommandEventDetail(entry, locale) : null;
+  }
   if (kind === "ambient_suggestions") {
     const entry = timelineEntryByToken(runtime, token, kind);
     if (entry) {
@@ -13621,6 +14768,8 @@ async function buildApiItemDetail({ config, runtime, state, kind, token, locale
       provider: "a2a",
       instruction,
       messageText: responseText,
+      viveworker: task?.viveworker || entry?.viveworker || {},
+      paidDeliverable: task?.paidDeliverable || entry?.paidDeliverable || null,
       taskId: task?.id || "",
       taskStatus: task?.status || entry?.taskStatus || (kind === "a2a_task_result" ? "completed" : "submitted"),
       callerInfo: task?.callerInfo || {},
@@ -13751,13 +14900,32 @@ const GZIPPABLE_EXTENSIONS = new Set([
 ]);
 const MIN_GZIP_BYTES = 512;
 
+function renderWebAssetBuffer(filePath, raw) {
+  const basename = path.basename(filePath);
+  if (basename !== "index.html" && basename !== "sw.js" && basename !== "app.js") {
+    return raw;
+  }
+
+  const text = raw.toString("utf8");
+  if (!text.includes(WEB_APP_BUILD_ID_PLACEHOLDER)) {
+    return raw;
+  }
+
+  return Buffer.from(text.replaceAll(WEB_APP_BUILD_ID_PLACEHOLDER, WEB_APP_BUILD_ID), "utf8");
+}
+
 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) {
+  if (
+    cached &&
+    cached.mtimeMs === stat.mtimeMs &&
+    cached.sourceSize === stat.size &&
+    cached.buildId === WEB_APP_BUILD_ID
+  ) {
     return cached;
   }
-  const raw = await fs.readFile(filePath);
+  const raw = renderWebAssetBuffer(filePath, await fs.readFile(filePath));
   const extension = path.extname(filePath).toLowerCase();
   let gzip = null;
   if (GZIPPABLE_EXTENSIONS.has(extension) && raw.length >= MIN_GZIP_BYTES) {
@@ -13771,7 +14939,8 @@ async function loadWebAssetEntry(filePath) {
     raw,
     gzip,
     mtimeMs: stat.mtimeMs,
-    size: stat.size,
+    sourceSize: stat.size,
+    buildId: WEB_APP_BUILD_ID,
     contentType: contentTypeForFile(filePath),
   };
   WEB_ASSET_CACHE.set(filePath, entry);
@@ -13870,7 +15039,7 @@ function buildWebAppHtml({ pairToken }) {
     <link rel="manifest" href="${escapeHtml(manifestHref)}">
     <link rel="apple-touch-icon" href="/icons/apple-touch-icon.png">
     <link rel="icon" type="image/png" sizes="192x192" href="/icons/viveworker-icon-192.png">
-    <link rel="stylesheet" href="/app.css">
+    <link rel="stylesheet" href="/app.css?v=${escapeHtml(WEB_APP_BUILD_ID)}">
     <style>
       .boot-splash {
         position: fixed;
@@ -14080,6 +15249,107 @@ function logRemotePairingBootTrace(body, session, req) {
   }
 }
 
+function logClientEvent(body, session, req) {
+  const type = cleanText(body?.type || "").slice(0, 80);
+  if (type !== "timeline-render") {
+    return;
+  }
+
+  const route = cleanText(body?.route || "").slice(0, 24) || "unknown";
+  const reason = cleanText(body?.reason || "").slice(0, 80) || "unknown";
+  const latestToken = cleanText(body?.latestToken || "").slice(0, 80) || "none";
+  const latestKind = cleanText(body?.latestKind || "").slice(0, 80) || "unknown";
+  const appBuildId = cleanText(body?.appBuildId || "").slice(0, 80) || "unknown";
+  const currentTab = cleanText(body?.currentTab || "").slice(0, 40) || "unknown";
+  const entryCount = Math.max(0, Math.min(10_000, Math.round(Number(body?.entryCount) || 0)));
+  const latestCreatedAtMs = Math.max(0, Math.min(9_999_999_999_999, Math.round(Number(body?.latestCreatedAtMs) || 0)));
+  const clientAtMs = Math.max(0, Math.min(9_999_999_999_999, Math.round(Number(body?.clientAtMs) || 0)));
+  const visible = body?.visible === true;
+  const renderedTokens = Array.isArray(body?.renderedTokens)
+    ? body.renderedTokens
+        .slice(0, 5)
+        .map((item) => {
+          const token = cleanText(item?.token || "").slice(0, 80);
+          const kind = cleanText(item?.kind || "").slice(0, 80);
+          const createdAtMs = Math.max(0, Math.min(9_999_999_999_999, Math.round(Number(item?.createdAtMs) || 0)));
+          return token && kind ? `${kind}:${token}:${createdAtMs}` : "";
+        })
+        .filter(Boolean)
+    : [];
+  const deviceId = cleanText(session?.deviceId || "").slice(0, 60) || "unknown";
+  const ua = requestUserAgent(req).slice(0, 90);
+
+  console.log(
+    `[client-event] timeline-render at=${new Date().toISOString()} device=${deviceId} ` +
+    `route=${route} visible=${visible ? 1 : 0} tab=${currentTab} reason=${reason} ` +
+    `latest=${latestKind}:${latestToken} latestCreatedAtMs=${latestCreatedAtMs} ` +
+    `clientAtMs=${clientAtMs} count=${entryCount} build=${appBuildId} ` +
+    `rendered=${renderedTokens.join(",") || "none"} ua=${JSON.stringify(ua)}`
+  );
+}
+
+function writeSseEvent(res, eventName, payload) {
+  res.write(`event: ${eventName}\n`);
+  res.write(`data: ${JSON.stringify(payload)}\n\n`);
+}
+
+function openTimelineStream({ config, runtime, req, res, session }) {
+  if (!config.timelineLiveSync) {
+    return writeJson(res, 404, { error: "timeline-live-sync-disabled" });
+  }
+  res.statusCode = 200;
+  res.setHeader("Content-Type", "text/event-stream; charset=utf-8");
+  res.setHeader("Cache-Control", "no-cache, no-transform");
+  res.setHeader("Connection", "keep-alive");
+  res.setHeader("X-Accel-Buffering", "no");
+  res.flushHeaders?.();
+
+  let closed = false;
+  const deviceId = cleanText(session?.deviceId || "").slice(0, 60) || "unknown";
+  const bus = ensureTimelineBus(runtime);
+  const client = {
+    send(eventName, payload) {
+      if (closed || res.destroyed || res.writableEnded) {
+        throw new Error("timeline-stream-closed");
+      }
+      writeSseEvent(res, eventName, payload);
+    },
+    close() {
+      if (closed) return;
+      closed = true;
+      clearInterval(heartbeat);
+      remove();
+      try {
+        res.end();
+      } catch {}
+    },
+  };
+  const remove = bus.addClient(client);
+  const heartbeat = setInterval(() => {
+    try {
+      client.send("heartbeat", {
+        atMs: Date.now(),
+        revision: Number(runtime.timelineRevision) || 0,
+      });
+    } catch {
+      client.close();
+    }
+  }, 20_000);
+  heartbeat.unref?.();
+
+  req.on("close", () => client.close());
+  req.on("aborted", () => client.close());
+  res.on("error", () => client.close());
+  client.send("hello", {
+    ok: true,
+    revision: Number(runtime.timelineRevision) || 0,
+    appBuildId: WEB_APP_BUILD_ID,
+    deviceId,
+    atMs: Date.now(),
+  });
+  console.log(`[timeline-stream] open device=${deviceId} clients=${bus.clients.size}`);
+}
+
 function recordRemotePairingAudit(event) {
   appendRemotePairingAuditEvent({
     atMs: Date.now(),
@@ -14173,6 +15443,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
       if (
         url.pathname === "/app.js" ||
         url.pathname === "/app.css" ||
+        url.pathname === "/build-id.js" ||
         url.pathname === "/i18n.js" ||
         url.pathname === "/hazbase-passkey.js" ||
         url.pathname === "/sw.js" ||
@@ -14251,7 +15522,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
         if (action === "approve") {
           // Resolve which executor to use.
           const available = runtime.a2aAvailableExecutors || { codex: false, claude: false };
-          const preference = requestedExecutor || state.a2aExecutorPreference || "ask";
+          const preference = requestedExecutor || task.viveworker?.requestedExecutor || state.a2aExecutorPreference || "ask";
           let executor;
           if (preference === "codex" && available.codex) executor = "codex";
           else if (preference === "claude" && available.claude) executor = "claude";
@@ -15160,6 +16431,29 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         return writeJson(res, 200, { ok: true });
       }
 
+      // POST /api/client-events — local-only diagnostics from the PWA.
+      //
+      // The endpoint deliberately accepts only small sanitized metadata, not
+      // message text, commands, file paths, relay tokens, or public keys. It is
+      // used to correlate "bridge accepted" timings with "the PWA rendered the
+      // latest timeline item" timings while debugging LAN/remote freshness.
+      if (url.pathname === "/api/client-events" && req.method === "POST") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) return;
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch (err) {
+          return writeJson(res, 400, { error: "invalid-json-body", message: err.message });
+        }
+        try {
+          logClientEvent(body, session, req);
+        } catch (err) {
+          console.warn(`[client-event] failed to log event: ${err?.message}`);
+        }
+        return writeJson(res, 200, { ok: true });
+      }
+
       // POST /api/remote-pairing/toggle — flip on/off without restart.
       //
       // Body: { enabled: boolean }
@@ -15748,7 +17042,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
               messageText: content,
               createdAtMs: share.createdAtMs,
               readOnly: false,
-              provider: "viveworker",
+              provider: sourceTool === "mcp" ? "mcp" : "viveworker",
             },
           });
           await saveState(config.stateFile, state);
@@ -15765,6 +17059,13 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
             stableId: `thread_share:${shareId}`,
             title: `Thread Share: ${sourceLabel || sourceTool || "agent"} → ${targetLabel || targetTool}`,
             body: String(content).slice(0, 160),
+            buildLocalizedContent: ({ locale }) => localizedThreadSharePushContent(locale, {
+              sourceLabel,
+              sourceTool,
+              targetLabel,
+              targetTool,
+              body: content,
+            }),
           });
         } catch (error) {
           console.error(`[thread-share-push] ${error.message}`);
@@ -15864,6 +17165,10 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
                   stableId: `thread_share_fallback:${share.shareId}`,
                   title: "Thread Share: target unreachable",
                   body: `Codex thread "${share.targetLabel || share.targetConversationId.slice(0, 8)}" is not connected. Content saved to inbox.`,
+                  buildLocalizedContent: ({ locale }) => localizedThreadShareFallbackPushContent(
+                    locale,
+                    share.targetLabel || share.targetConversationId.slice(0, 8)
+                  ),
                 });
               } catch (error) {
                 console.error(`[thread-share-fallback-push] ${error.message}`);
@@ -15956,7 +17261,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           rangeDate = d.toISOString().slice(0, 10);
         }
 
-        const relevantKinds = new Set(["file_event", "completion", "plan_ready", "assistant_final"]);
+        const relevantKinds = new Set(["file_event", "command_event", "completion", "plan_ready", "assistant_final"]);
         const entries = (runtime.recentTimelineEntries || [])
           .filter((e) => e.createdAtMs >= rangeStart && e.createdAtMs < rangeEnd && relevantKinds.has(e.kind))
           .map((e) => ({
@@ -16125,7 +17430,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           stableId: pendingApprovalStableId(approval),
           title: approval.title,
           body: approval.messageText,
-          buildLocalizedContent: () => ({ title: approval.title, body: approval.messageText }),
+          buildLocalizedContent: ({ locale }) => localizedPaymentApprovalPushContent(locale, approval),
         }).catch((error) => {
           console.error(`[hazbase-wallet-payment-push] ${approval.requestKey} | ${error.message}`);
         });
@@ -16215,10 +17520,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           stableId: pendingApprovalStableId(approval),
           title: approval.title,
           body: approval.messageText,
-          buildLocalizedContent: () => ({
-            title: approval.title,
-            body: approval.messageText,
-          }),
+          buildLocalizedContent: ({ locale }) => localizedPaymentApprovalPushContent(locale, approval),
         }).catch((error) => {
           console.error(`[payment-approval-push] ${approval.requestKey} | ${error.message}`);
         });
@@ -16252,6 +17554,22 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         return writeJson(res, 403, { approved: false, decision: "decline", error: "payment-approval-declined" });
       }
 
+      if (url.pathname === "/api/providers/mcp/events" && req.method === "POST") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+          return writeJson(res, 401, { error: "unauthorized" });
+        }
+
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+
+        return handleMcpProviderEvent({ config, runtime, state, body, res });
+      }
+
       if (url.pathname === "/api/providers/claude/events" && req.method === "POST") {
         const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
         if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
@@ -16494,7 +17812,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           body: approval.messageText,
           buildLocalizedContent: ({ locale }) => ({
             title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
-            body: approval.messageText,
+            body: formatNativeApprovalMessage(approval.kind, approval.rawParams, locale),
           }),
         }).catch(() => {});
 
@@ -16623,6 +17941,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
             stableId: `moltbook_reply:${item.sourceId}`,
             title: item.title,
             body: item.summary,
+            buildLocalizedContent: ({ locale }) => localizedMoltbookReplyPushContent(locale, item),
           });
         } catch (error) {
           console.error(`[moltbook-push-error] ${error.message}`);
@@ -16782,20 +18101,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           console.error(`[moltbook-draft-timeline-save] ${error.message}`);
         }
         try {
-          const pushTitle = (() => {
-            if (draftType !== "original_post") {
-              return postTitle ? `draft → ${postTitle}` : "Moltbook draft";
-            }
-            const greetings = {
-              morning: { en: "Good morning! Share yesterday's highlights?", ja: "おはようございます！昨日の成果をシェアしませんか？" },
-              noon: { en: "Nice progress! Ready to share your morning work?", ja: "午前中お疲れ様でした！進捗をシェアしませんか？" },
-              evening: { en: "Great work today! Let's share what you built.", ja: "今日もお疲れ様でした！成果をシェアしませんか？" },
-            };
-            const locale = config.locale || "en";
-            const lang = locale.startsWith("ja") ? "ja" : "en";
-            const g = greetings[slot];
-            return g ? g[lang] : (postTitle || "Moltbook new post");
-          })();
+          const pushTitle = localizedMoltbookDraftPushTitle(config.defaultLocale, { draftType, postTitle, slot });
           await deliverWebPushItem({
             config,
             state,
@@ -16806,6 +18112,10 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
             stableId: `moltbook_draft:${sourceId}`,
             title: pushTitle,
             body: draftType === "original_post" ? (postTitle || String(draftText).slice(0, 160)) : String(draftText).slice(0, 160),
+            buildLocalizedContent: ({ locale }) => ({
+              title: localizedMoltbookDraftPushTitle(locale, { draftType, postTitle, slot }),
+              body: draftType === "original_post" ? (postTitle || pushBodySnippet(draftText)) : pushBodySnippet(draftText),
+            }),
           });
         } catch (error) {
           console.error(`[moltbook-draft-push-error] ${error.message}`);
@@ -16903,6 +18213,10 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
                   stableId: `moltbook_draft_failed:${draft.sourceId}`,
                   title: "Draft post failed",
                   body: String(postError.message || "").slice(0, 160),
+                  buildLocalizedContent: ({ locale }) => ({
+                    title: t(locale, "server.push.moltbookDraft.failedTitle"),
+                    body: pushBodySnippet(postError.message || ""),
+                  }),
                 });
               } catch { /* ignore push error */ }
             }
@@ -16944,6 +18258,14 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         return writeJson(res, 200, buildTimelineResponse(runtime, state, config, locale));
       }
 
+      if (url.pathname === "/api/timeline/stream" && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+        return openTimelineStream({ config, runtime, req, res, session });
+      }
+
       const apiTimelineImageMatch = url.pathname.match(/^\/api\/timeline\/([^/]+)\/images\/(\d+)$/u);
       if (apiTimelineImageMatch && req.method === "GET") {
         const token = decodeURIComponent(apiTimelineImageMatch[1]);
@@ -17012,7 +18334,7 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           const payload = contentType.includes("multipart/form-data")
             ? await stageCompletionReplyImages(config, req)
             : await parseJsonBody(req);
-          await handleCompletionReply({
+          const replyResult = await handleCompletionReply({
             config,
             runtime,
             state,
@@ -17026,6 +18348,8 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
             ok: true,
             planMode: payload?.planMode === true,
             imageCount: Array.isArray(payload?.localImagePaths) ? payload.localImagePaths.length : 0,
+            alreadyAccepted: replyResult?.alreadyAccepted === true,
+            ackTimeout: replyResult?.ackTimeout === true,
           });
         } catch (error) {
           if (error.message === "completion-reply-empty") {
@@ -17066,6 +18390,20 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         const decision = apiApprovalDecisionMatch[2];
         const approval = runtime.nativeApprovalsByToken.get(token);
         if (!approval) {
+          const historicalDecision = approvalDecisionFromHistoryItem(historyItemByToken(runtime, "approval", token));
+          if (historicalDecision) {
+            if (historicalDecision === decision) {
+              return writeJson(res, 200, {
+                ok: true,
+                decision,
+                alreadyHandled: true,
+              });
+            }
+            return writeJson(res, 409, {
+              error: "approval-already-handled",
+              decision: historicalDecision,
+            });
+          }
           return writeJson(res, 404, { error: "approval-not-found" });
         }
         if (approval.resolved || approval.resolving) {
@@ -17127,7 +18465,14 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
 
         approval.resolving = true;
         try {
-          if (approval.resolveClaudeWaiter) {
+          if (approval.resolveMcpWaiter) {
+            approval.resolveMcpWaiter({
+              approved: true,
+              decision: "answered",
+              answers,
+              answerText: reasonText,
+            });
+          } else if (approval.resolveClaudeWaiter) {
             approval.resolveClaudeWaiter({
               permissionDecision: "deny",
               permissionDecisionReason: reasonText,
@@ -17163,8 +18508,10 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           if (stateChanged) {
             await saveState(config.stateFile, state);
           }
-          console.log(`[claude-question-answer] ${approval.requestKey}`);
-          activateClaudeDesktopIfMac(req);
+          console.log(`[${approval.provider === "mcp" ? "mcp" : "claude"}-question-answer] ${approval.requestKey}`);
+          if (approval.provider === "claude") {
+            activateClaudeDesktopIfMac(req);
+          }
           return writeJson(res, 200, { ok: true });
         } catch (error) {
           approval.resolving = false;
@@ -19057,6 +20404,10 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
       stableId: `moltbook_draft_posted:${draft.sourceId}`,
       title: "Moltbook posted",
       body: truncate(singleLine(pushTitle), 160),
+      buildLocalizedContent: ({ locale }) => ({
+        title: t(locale, "server.push.moltbookDraft.postedTitle"),
+        body: localizedMoltbookPostedBody(locale, draft, finalTitle),
+      }),
     });
   } catch { /* ignore push error */ }
 
@@ -19082,6 +20433,10 @@ function buildConfig(cli) {
     a2aRelayUserId: cleanText(process.env.A2A_RELAY_USER_ID || ""),
     a2aRelaySecret: cleanText(process.env.A2A_RELAY_SECRET || ""),
     a2aRelayRegisterSecret: cleanText(process.env.A2A_RELAY_REGISTER_SECRET || ""),
+    a2aProModel: cleanText(process.env.A2A_PRO_MODEL || ""),
+    a2aProPrice: cleanText(process.env.A2A_PRO_PRICE || ""),
+    a2aProPayTo: cleanText(process.env.A2A_PRO_PAY_TO || ""),
+    a2aProExpiresDays: cleanText(process.env.A2A_PRO_EXPIRES_DAYS || "7"),
     // Remote-pairing relay (PWA off-LAN). Off by default — bridges that
     // never leave the trusted LAN don't need to open an outbound connection
     // to the relay. Toggle with REMOTE_PAIRING_ENABLED=true in
@@ -19115,6 +20470,8 @@ function buildConfig(cli) {
       process.env.TIMELINE_ATTACHMENTS_DIR || path.join(path.dirname(stateFile), "timeline-attachments")
     ),
     pollIntervalMs: numberEnv("POLL_INTERVAL_MS", 2500),
+    timelineLiveSync: boolEnv("TIMELINE_LIVE_SYNC", true),
+    timelineLiveDebounceMs: numberEnv("TIMELINE_LIVE_DEBOUNCE_MS", 75),
     replaySeconds: numberEnv("REPLAY_SECONDS", 300),
     sessionIndexRefreshMs: numberEnv("SESSION_INDEX_REFRESH_MS", 30000),
     directoryScanIntervalMs: numberEnv("DIRECTORY_SCAN_INTERVAL_MS", 30000),
@@ -19173,6 +20530,10 @@ function buildConfig(cli) {
     ipcSocketPath: resolvePath(process.env.CODEX_IPC_SOCKET_PATH || defaultIpcSocketPath()),
     ipcReconnectMs: numberEnv("IPC_RECONNECT_MS", 1500),
     ipcRequestTimeoutMs: numberEnv("IPC_REQUEST_TIMEOUT_MS", 12000),
+    completionReplyAckTimeoutMs: numberEnv(
+      "COMPLETION_REPLY_ACK_TIMEOUT_MS",
+      DEFAULT_COMPLETION_REPLY_ACK_TIMEOUT_MS
+    ),
     choicePageSize: numberEnv("CHOICE_PAGE_SIZE", 5),
     completionReplyImageMaxBytes: numberEnv(
       "COMPLETION_REPLY_IMAGE_MAX_BYTES",
@@ -20109,16 +21470,20 @@ function extractRolloutMessageText(content) {
   if (!Array.isArray(content)) {
     return "";
   }
-  return cleanText(
-    content
-      .map((entry) =>
-        isPlainObject(entry) && (entry.type === "input_text" || entry.type === "output_text")
-          ? normalizeTimelineMessageText(entry.text ?? "")
-          : ""
-      )
-      .filter(Boolean)
-      .join("\n")
-  );
+  // The per-entry text is already passed through `normalizeTimelineMessageText`
+  // (which preserves newlines for the markdown renderer). The final wrap used
+  // to be `cleanText`, which collapses every \s+ — newlines included — into
+  // a single space, flattening tables / code fences / lists into one
+  // illegible line. Use a plain trim instead so the structure survives.
+  return content
+    .map((entry) =>
+      isPlainObject(entry) && (entry.type === "input_text" || entry.type === "output_text")
+        ? normalizeTimelineMessageText(entry.text ?? "")
+        : ""
+    )
+    .filter(Boolean)
+    .join("\n")
+    .trim();
 }
 
 function extractTitleOnlyJsonTitleFromRolloutContent(content) {
@@ -21091,11 +22456,13 @@ async function main() {
       `notifyPlans=${config.notifyPlans}`,
       `nativeApprovalServer=${config.nativeApprovalPublicBaseUrl}`,
       `pollMs=${config.pollIntervalMs}`,
+      `timelineLive=${config.timelineLiveSync}`,
       `replaySeconds=${config.replaySeconds}`,
     ].join(" | ")
   );
 
   let approvalServer = null;
+  let timelineLiveHandle = null;
 
   process.on("SIGINT", handleSignal);
   process.on("SIGTERM", handleSignal);
@@ -21234,6 +22601,8 @@ async function main() {
       }
     }
 
+    timelineLiveHandle = startTimelineLiveSync({ config, runtime, state });
+
     // --- A2A Relay ---
     if (config.a2aRelayUrl && config.a2aRelayUserId) {
       config.a2aAcceptPublicTasks = state.a2aAcceptPublicTasks === true;
@@ -21366,6 +22735,13 @@ async function main() {
   } finally {
     runtime.stopping = true;
 
+    if (timelineLiveHandle) {
+      try {
+        timelineLiveHandle.close();
+      } catch {}
+      timelineLiveHandle = null;
+    }
+
     stopRelayPolling();
 
     if (runtime.remotePairingHandle) {