viveworker 0.8.1 → 0.8.3

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";
@@ -21,7 +21,7 @@ import { generatePairingCredentials, shouldRotatePairing, upsertEnvText } from "
 import { renderMarkdownHtml } from "./lib/markdown-render.mjs";
 import { buildAgentCard, handleA2ARequest, resolveA2ATaskDecision, completeA2ATask, failA2ATask } from "./a2a-handler.mjs";
 import { registerWithRelay, startRelayPolling, stopRelayPolling, postRelayResult, getRelayStatus, updatePublicTasksFlag } from "./a2a-relay-client.mjs";
-import { createMoltbookClient, readScoutState, writeScoutState, rollScoutDayIfNeeded, markPostSeen, recordComposeAttempt, writeDraft, readDraft, deleteDraft, listPendingDrafts, solveVerificationPuzzle, solvePuzzleWithLLM, recordPuzzleAttempt, listInboxItems } from "./moltbook-api.mjs";
+import { createMoltbookClient, readScoutState, writeScoutState, rollScoutDayIfNeeded, markPostSeen, recordComposeAttempt, writeDraft, readDraft, deleteDraft, listPendingDrafts, solveVerificationPuzzle, solvePuzzleWithLLM, recordPuzzleAttempt, listInboxItems, updateInboxStatus, getMoltbookReplyQuotaState } from "./moltbook-api.mjs";
 import { startRemotePairingRelay, DEFAULT_RELAY_URL } from "./lib/remote-pairing/orchestrator.mjs";
 import { restartRemotePairingRelay, persistRemotePairingEnv, getRemotePairingStatus } from "./lib/remote-pairing/control.mjs";
 import { appendRemotePairingAuditEvent, readRemotePairingAuditEvents } from "./lib/remote-pairing/audit.mjs";
@@ -55,7 +55,7 @@ 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, "activity_status", "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;
@@ -64,10 +64,13 @@ 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;
+const TIMELINE_ACTIVITY_TTL_MS = 2 * 60 * 1000;
 
 // Shared memo for buildDiffThreadGroups. Each call spawns 3 git subprocesses
 // per tracked repo (`git diff --name-status`, `git status --porcelain`,
@@ -263,6 +266,7 @@ const runtime = {
   completionDetailsByToken: new Map(),
   moltbookItemsByToken: new Map(),
   moltbookDraftsByToken: new Map(),
+  moltbookReplyQuotaQueue: Promise.resolve(),
   a2aTasksByToken: new Map(),
   threadSharesByToken: new Map(),
   threadRegistry: new Map(),
@@ -270,6 +274,16 @@ const runtime = {
   recentHistoryItems: [],
   recentTimelineEntries: [],
   recentCodeEvents: [],
+  activeTimelineActivitiesByKey: new Map(),
+  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,
@@ -335,6 +349,58 @@ setInterval(async () => {
     }
   }
 }, 60_000).unref?.();
+
+async function withMoltbookReplyQuotaLock(fn) {
+  const previous = runtime.moltbookReplyQuotaQueue || Promise.resolve();
+  let release;
+  const next = new Promise((resolve) => { release = resolve; });
+  runtime.moltbookReplyQuotaQueue = previous.then(() => next, () => next);
+  await previous.catch(() => {});
+  try {
+    return await fn();
+  } finally {
+    release();
+  }
+}
+
+async function reserveMoltbookReplyQuotaSlot(draft, maxDaily = 5) {
+  if (!draft || draft.draftType === "original_post") return { reserved: false };
+  return withMoltbookReplyQuotaLock(async () => {
+    const scoutState = rollScoutDayIfNeeded(await readScoutState());
+    if ((Number(scoutState.sentToday) || 0) >= maxDaily) {
+      return {
+        reserved: false,
+        quotaReached: true,
+        day: scoutState.day,
+        sentToday: Number(scoutState.sentToday) || 0,
+        maxDaily,
+      };
+    }
+    scoutState.sentToday = (Number(scoutState.sentToday) || 0) + 1;
+    markPostSeen(scoutState, draft.postId, "reserved");
+    await writeScoutState(scoutState);
+    draft.replyQuotaReserved = true;
+    draft.replyQuotaReservedDay = scoutState.day;
+    draft.replyQuotaReservedAtMs = Date.now();
+    return {
+      reserved: true,
+      day: scoutState.day,
+      sentToday: scoutState.sentToday,
+      maxDaily,
+    };
+  });
+}
+
+async function releaseMoltbookReplyQuotaSlot(draft) {
+  if (!draft?.replyQuotaReserved || draft.draftType === "original_post") return;
+  await withMoltbookReplyQuotaLock(async () => {
+    const scoutState = rollScoutDayIfNeeded(await readScoutState());
+    if (draft.replyQuotaReservedDay && scoutState.day !== draft.replyQuotaReservedDay) return;
+    scoutState.sentToday = Math.max(0, (Number(scoutState.sentToday) || 0) - 1);
+    await writeScoutState(scoutState);
+  });
+  draft.replyQuotaReserved = false;
+}
 const initialHistoryItems = normalizeHistoryItems(state.recentHistoryItems ?? [], config.maxHistoryItems);
 const initialTimelineEntries = normalizeTimelineEntries(state.recentTimelineEntries ?? [], config.maxTimelineEntries);
 const normalizedHistoryStateChanged =
@@ -503,6 +569,8 @@ function kindTitle(locale, kind) {
       return t(locale, "server.title.assistantCommentary");
     case "assistant_final":
       return t(locale, "server.title.assistantFinal");
+    case "activity_status":
+      return t(locale, "server.title.activityStatus");
     case "ambient_suggestions":
       return t(locale, "server.title.ambientSuggestions");
     case "approval":
@@ -517,6 +585,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":
@@ -672,6 +742,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":
@@ -704,13 +886,19 @@ function normalizeTimelineOutcome(value) {
 
 function normalizeTimelineFileEventType(value) {
   const normalized = cleanText(value || "").toLowerCase();
-  return ["read", "write", "create", "delete", "rename"].includes(normalized) ? normalized : "";
+  return ["read", "search", "git", "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 "git":
+      return t(locale, "fileEvent.command");
+    case "command":
+      return t(locale, "fileEvent.command");
     case "write":
       return t(locale, "fileEvent.write");
     case "create":
@@ -729,6 +917,12 @@ 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 "git":
+      return t(locale, "detail.fileEvent.command", vars);
+    case "command":
+      return t(locale, "detail.fileEvent.command", vars);
     case "write":
       return t(locale, "detail.fileEvent.write", vars);
     case "create":
@@ -1398,7 +1592,7 @@ function evaluateTrustedReadCommandPolicy({ commandText, cwd, workspaceRoot }) {
     return null;
   }
 
-  const command = cleanText(tokens[0]);
+  const command = commandBaseName(tokens[0]);
   if (!command || /^[A-Za-z_][A-Za-z0-9_]*=.*/u.test(command)) {
     return null;
   }
@@ -1436,6 +1630,86 @@ 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)
+  ) {
+    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);
@@ -1454,15 +1728,19 @@ function extractReadFileRefsFromCommand(commandText) {
     return [];
   }
 
-  if (command === "cat" || command === "nl") {
-    return normalizeTimelineFileRefs(tokens.slice(1).filter((token) => !String(token || "").startsWith("-")));
+  if (command === "cat" || command === "nl" || command === "wc" || command === "less" || command === "more" || command === "ls") {
+    return normalizeTimelineFileRefs(readCommandPathArgs(tokens));
+  }
+
+  if (command === "head" || command === "tail") {
+    return normalizeTimelineFileRefs(readCommandPathArgs(tokens, { valueOptions: new Set(["-n", "--lines", "-c", "--bytes"]) }));
   }
 
   if (command === "sed") {
     if (!tokens.includes("-n")) {
       return [];
     }
-    return normalizeTimelineFileRefs(tokens.slice(1).filter((token) => !String(token || "").startsWith("-")));
+    return normalizeTimelineFileRefs(sedCommandPathArgs(tokens));
   }
 
   if (command === "rg") {
@@ -1493,6 +1771,57 @@ function extractReadFileRefsFromCommand(commandText) {
   return [];
 }
 
+function readCommandPathArgs(tokens, { valueOptions = new Set() } = {}) {
+  const args = [];
+  for (let index = 1; index < tokens.length; index += 1) {
+    const token = cleanText(tokens[index] || "");
+    if (!token) {
+      continue;
+    }
+    if (token === "--") {
+      args.push(...tokens.slice(index + 1));
+      break;
+    }
+    if (token.startsWith("-")) {
+      const optionName = token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
+      if (valueOptions.has(optionName) && !token.includes("=")) {
+        index += 1;
+      }
+      continue;
+    }
+    args.push(token);
+  }
+  return args;
+}
+
+function sedCommandPathArgs(tokens) {
+  const args = [];
+  let scriptSeen = false;
+  for (let index = 1; index < tokens.length; index += 1) {
+    const token = cleanText(tokens[index] || "");
+    if (!token) {
+      continue;
+    }
+    if (token === "--") {
+      args.push(...tokens.slice(index + 1));
+      break;
+    }
+    if (token.startsWith("-")) {
+      if (token === "-e" || token === "-f") {
+        index += 1;
+        scriptSeen = true;
+      }
+      continue;
+    }
+    if (!scriptSeen) {
+      scriptSeen = true;
+      continue;
+    }
+    args.push(token);
+  }
+  return args;
+}
+
 function autoPilotApprovalMessage(locale, commandText) {
   const prefix = t(locale, "server.message.autoPilotTrustedReadApproved");
   const commandBlock = cleanText(commandText || "")
@@ -1664,6 +1993,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) {
@@ -2068,6 +2427,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,
   };
@@ -3132,6 +3492,8 @@ function migrateRecentCodeEventsState({ config, runtime, state }) {
 
 function timelineKindSortPriority(kind) {
   switch (cleanText(kind || "")) {
+    case "activity_status":
+      return 90;
     case "completion":
       return 70;
     case "approval":
@@ -3141,6 +3503,8 @@ function timelineKindSortPriority(kind) {
       return 60;
     case "ambient_suggestions":
       return 52;
+    case "command_event":
+      return 46;
     case "file_event":
       return 45;
     case "assistant_final":
@@ -3163,7 +3527,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;
@@ -3172,7 +3538,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);
@@ -3242,6 +3607,8 @@ function normalizeTimelineEntry(raw) {
     tone: cleanText(raw.tone ?? "") || "secondary",
     cwd: resolvePath(cleanText(raw.cwd || "")),
     provider: normalizeProvider(raw.provider),
+    ...(raw.activityPhase != null ? { activityPhase: cleanText(raw.activityPhase) } : {}),
+    ...(raw.commandText != null ? { commandText: cleanText(raw.commandText) } : {}),
     // Moltbook-specific fields — preserved for detail view fallback after
     // the in-memory draft/item expires.
     ...(raw.draftText != null ? { draftText: cleanText(raw.draftText) } : {}),
@@ -3264,107 +3631,408 @@ function normalizeTimelineEntry(raw) {
   return shouldHideInternalTimelineItem(normalized) ? null : normalized;
 }
 
-function recordTimelineEntry({ config, runtime, state, entry }) {
-  const normalized = normalizeTimelineEntry(entry);
-  if (!normalized) {
-    return false;
+class TimelineBus {
+  constructor() {
+    this.clients = new Set();
   }
 
-  const nextItems = normalizeTimelineEntries(
-    [normalized, ...runtime.recentTimelineEntries.filter((item) => item.stableId !== normalized.stableId)],
-    config.maxTimelineEntries
-  );
-  // Note: diffText is intentionally omitted from the projection — the
-  // line-count fields (`diffAddedLines` / `diffRemovedLines`) are a sufficient
-  // proxy for "diff content changed" and avoid materialising a megabyte-class
-  // intermediate string on every record call.
-  const changed = timelineProjectionChanged(nextItems, runtime.recentTimelineEntries, [
-    "stableId",
-    "title",
-    "createdAtMs",
-    "diffAvailable",
-    "diffSource",
-    "diffAddedLines",
-    "diffRemovedLines",
-    "previousFileRefs",
-    "cwd",
-  ]);
-  runtime.recentTimelineEntries = nextItems;
-  state.recentTimelineEntries = nextItems;
-  return changed;
-}
-
-function recordCodeEvent({ config, runtime, state, entry }) {
-  if (!isCodeEventEntry(entry)) {
-    return false;
+  addClient(client) {
+    this.clients.add(client);
+    return () => {
+      this.clients.delete(client);
+    };
   }
-  const normalized = normalizeTimelineEntry(entry);
-  if (!normalized) {
-    return false;
+
+  emit(eventName, payload) {
+    for (const client of [...this.clients]) {
+      try {
+        client.send(eventName, payload);
+      } catch {
+        try {
+          client.close?.();
+        } catch {}
+        this.clients.delete(client);
+      }
+    }
   }
 
-  const nextItems = normalizeCodeEvents(
-    [normalized, ...runtime.recentCodeEvents.filter((item) => item.stableId !== normalized.stableId)],
-    config.maxCodeEvents
-  );
-  // See `recordTimelineEntry` for the rationale on dropping `diffText` from
-  // the projection — same megabyte-stringify hot path; same line-count proxy.
-  const changed = timelineProjectionChanged(nextItems, runtime.recentCodeEvents, [
-    "stableId",
-    "title",
-    "createdAtMs",
-    "diffAvailable",
-    "diffSource",
-    "diffAddedLines",
-    "diffRemovedLines",
-    "previousFileRefs",
-    "cwd",
-  ]);
-  runtime.recentCodeEvents = nextItems;
-  state.recentCodeEvents = nextItems;
-  if (changed) {
-    invalidateDiffThreadGroupsCache();
+  closeAll() {
+    for (const client of [...this.clients]) {
+      try {
+        client.close?.();
+      } catch {}
+    }
+    this.clients.clear();
   }
-  return changed;
 }
 
-function syncRecentCodeEventsFromTimeline({ config, runtime, state }) {
-  const timelineCodeEvents = normalizeCodeEvents(runtime.recentTimelineEntries, config.maxCodeEvents);
-  if (timelineCodeEvents.length === 0 && runtime.recentCodeEvents.length === 0) {
-    return false;
+function ensureTimelineBus(runtime) {
+  if (!runtime.timelineBus) {
+    runtime.timelineBus = new TimelineBus();
   }
+  return runtime.timelineBus;
+}
 
-  const nextItems = normalizeCodeEvents(
-    [
-      ...timelineCodeEvents,
-      ...runtime.recentCodeEvents.filter(
-        (entry) => !timelineCodeEvents.some((timelineEntry) => timelineEntry.stableId === entry.stableId)
-      ),
-    ],
-    config.maxCodeEvents
-  );
-  // See `recordTimelineEntry` for the rationale on dropping `diffText`.
-  const changed = timelineProjectionChanged(nextItems, runtime.recentCodeEvents, [
-    "stableId",
-    "title",
-    "createdAtMs",
-    "threadLabel",
-    "diffAvailable",
-    "diffSource",
-    "diffAddedLines",
-    "diffRemovedLines",
-    "previousFileRefs",
-    "cwd",
-  ]);
-  runtime.recentCodeEvents = nextItems;
-  state.recentCodeEvents = nextItems;
-  if (changed) {
-    invalidateDiffThreadGroupsCache();
+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;
   }
-  return changed;
+  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 timelineEntryByToken(runtime, token, kind = "") {
+function timelineActivityKey(provider, threadId) {
+  const normalizedProvider = normalizeProvider(provider) || "codex";
+  const normalizedThreadId = cleanText(threadId || "");
+  if (!normalizedThreadId) {
+    return "";
+  }
+  return `${normalizedProvider}:${normalizedThreadId}`;
+}
+
+function timelineActivityTitle(locale, phase) {
+  switch (cleanText(phase || "")) {
+    case "thinking":
+      return t(locale, "server.activity.thinking");
+    case "reading":
+      return t(locale, "server.activity.reading");
+    case "searching":
+      return t(locale, "server.activity.searching");
+    case "editing":
+      return t(locale, "server.activity.editing");
+    case "running_command":
+      return t(locale, "server.activity.runningCommand");
+    case "awaiting_approval":
+      return t(locale, "server.activity.awaitingApproval");
+    default:
+      return t(locale, "server.activity.working");
+  }
+}
+
+function timelineActivitySummary(activity) {
+  const phase = cleanText(activity?.phase || "");
+  const refs = normalizeTimelineFileRefs(activity?.fileRefs || []);
+  if (refs.length === 1 && ["reading", "searching", "editing"].includes(phase)) {
+    return compactPath(refs[0]);
+  }
+  if (refs.length > 1 && ["reading", "searching", "editing"].includes(phase)) {
+    return `${refs.length} files`;
+  }
+  const commandText = cleanText(activity?.commandText || "");
+  if (commandText && phase !== "running_command") {
+    return timelineCommandSummary(commandText);
+  }
+  return cleanText(activity?.summary || "");
+}
+
+function buildTimelineActivityEntry(activity, locale = DEFAULT_LOCALE) {
+  if (!isPlainObject(activity)) {
+    return null;
+  }
+  const provider = normalizeProvider(activity.provider);
+  const threadId = cleanText(activity.threadId || "");
+  const key = cleanText(activity.key || timelineActivityKey(provider, threadId));
+  if (!key || !threadId) {
+    return null;
+  }
+  const phase = cleanText(activity.phase || "working");
+  const updatedAtMs = Number(activity.updatedAtMs) || Date.now();
+  return normalizeTimelineEntry({
+    stableId: `activity_status:${key}`,
+    token: historyToken(`activity_status:${key}`),
+    kind: "activity_status",
+    threadId,
+    threadLabel: cleanText(activity.threadLabel || ""),
+    title: timelineActivityTitle(locale, phase),
+    summary: timelineActivitySummary(activity),
+    messageText: cleanText(activity.commandText || activity.summary || ""),
+    fileRefs: normalizeTimelineFileRefs(activity.fileRefs || []),
+    commandText: cleanText(activity.commandText || ""),
+    activityPhase: phase,
+    createdAtMs: updatedAtMs,
+    cwd: cleanText(activity.cwd || ""),
+    readOnly: true,
+    provider,
+  });
+}
+
+function publishTimelineActivityUpdate({ config, runtime, activity, source = "activity-status" }) {
+  const entry = buildTimelineActivityEntry(activity, DEFAULT_LOCALE);
+  if (entry) {
+    publishTimelineUpdate({ config, runtime, entry, source });
+  }
+}
+
+function upsertTimelineActivity({
+  config,
+  runtime,
+  provider,
+  threadId,
+  threadLabel = "",
+  phase = "working",
+  summary = "",
+  commandText = "",
+  fileRefs = [],
+  cwd = "",
+  source = "activity-status",
+  atMs = Date.now(),
+}) {
+  if (!config?.webUiEnabled || !runtime) {
+    return false;
+  }
+  if (!(runtime.activeTimelineActivitiesByKey instanceof Map)) {
+    runtime.activeTimelineActivitiesByKey = new Map();
+  }
+  const normalizedProvider = normalizeProvider(provider) || "codex";
+  const normalizedThreadId = cleanText(threadId || "");
+  const key = timelineActivityKey(normalizedProvider, normalizedThreadId);
+  if (!key) {
+    return false;
+  }
+  const next = {
+    key,
+    provider: normalizedProvider,
+    threadId: normalizedThreadId,
+    threadLabel: cleanText(threadLabel || ""),
+    phase: cleanText(phase || "working"),
+    summary: cleanText(summary || ""),
+    commandText: cleanText(commandText || ""),
+    fileRefs: normalizeTimelineFileRefs(fileRefs),
+    cwd: cleanText(cwd || ""),
+    updatedAtMs: Number(atMs) || Date.now(),
+  };
+  const previous = runtime.activeTimelineActivitiesByKey.get(key);
+  const changed =
+    !previous ||
+    previous.phase !== next.phase ||
+    previous.summary !== next.summary ||
+    previous.commandText !== next.commandText ||
+    previous.threadLabel !== next.threadLabel ||
+    previous.cwd !== next.cwd ||
+    JSON.stringify(previous.fileRefs || []) !== JSON.stringify(next.fileRefs || []);
+  runtime.activeTimelineActivitiesByKey.set(key, next);
+  if (changed) {
+    publishTimelineActivityUpdate({ config, runtime, activity: next, source });
+  }
+  return changed;
+}
+
+function clearTimelineActivity({ config, runtime, provider, threadId, source = "activity-clear", atMs = Date.now() }) {
+  if (!runtime?.activeTimelineActivitiesByKey) {
+    return false;
+  }
+  const key = timelineActivityKey(provider, threadId);
+  if (!key || !runtime.activeTimelineActivitiesByKey.has(key)) {
+    return false;
+  }
+  const previous = runtime.activeTimelineActivitiesByKey.get(key);
+  runtime.activeTimelineActivitiesByKey.delete(key);
+  publishTimelineActivityUpdate({
+    config,
+    runtime,
+    activity: {
+      ...(isPlainObject(previous) ? previous : {}),
+      key,
+      provider: normalizeProvider(provider),
+      threadId: cleanText(threadId || ""),
+      phase: "working",
+      updatedAtMs: Number(atMs) || Date.now(),
+    },
+    source,
+  });
+  return true;
+}
+
+function timelineActivityFromCommand({ commandText, cwd = "" }) {
+  const classified = classifyTimelineCommand(commandText);
+  const fileEventType = cleanText(classified.fileEventType || "");
+  const phase = fileEventType === "read"
+    ? "reading"
+    : fileEventType === "search"
+      ? "searching"
+      : "running_command";
+  return {
+    phase,
+    commandText: classified.commandText || commandText,
+    fileRefs: classified.fileRefs || [],
+    cwd,
+  };
+}
+
+function timelineActivityFromClaudeTool(toolName, input = {}) {
+  const lowerToolName = cleanText(toolName || "").toLowerCase();
+  if (lowerToolName === "bash") {
+    return timelineActivityFromCommand({ commandText: cleanText(input.command || ""), cwd: cleanText(input.cwd || "") });
+  }
+  if (["read", "ls"].includes(lowerToolName)) {
+    return {
+      phase: "reading",
+      summary: cleanText(toolName || ""),
+      fileRefs: normalizeTimelineFileRefs([input.file_path || input.path || input.filePath].filter(Boolean)),
+    };
+  }
+  if (["grep", "glob", "websearch", "webfetch"].includes(lowerToolName)) {
+    return {
+      phase: "searching",
+      summary: cleanText(input.pattern || input.query || input.url || toolName || ""),
+      fileRefs: normalizeTimelineFileRefs([input.path || input.file_path || input.filePath].filter(Boolean)),
+    };
+  }
+  if (["write", "edit", "multiedit", "todowrite"].includes(lowerToolName)) {
+    return {
+      phase: "editing",
+      summary: cleanText(toolName || ""),
+      fileRefs: normalizeTimelineFileRefs([input.file_path || input.path || input.filePath].filter(Boolean)),
+    };
+  }
+  if (["askuserquestion", "exitplanmode"].includes(lowerToolName)) {
+    return { phase: "awaiting_approval", summary: cleanText(toolName || "") };
+  }
+  return { phase: "working", summary: cleanText(toolName || "") };
+}
+
+function timelineActivityFromClaudeContent(content) {
+  if (!Array.isArray(content)) {
+    return null;
+  }
+  for (const block of content) {
+    if (!isPlainObject(block) || block.type !== "tool_use") {
+      continue;
+    }
+    return timelineActivityFromClaudeTool(block.name || "", isPlainObject(block.input) ? block.input : {});
+  }
+  return null;
+}
+
+function recordTimelineEntry({ config, runtime, state, entry, source = "unknown" }) {
+  const normalized = normalizeTimelineEntry(entry);
+  if (!normalized) {
+    return false;
+  }
+
+  const nextItems = normalizeTimelineEntries(
+    [normalized, ...runtime.recentTimelineEntries.filter((item) => item.stableId !== normalized.stableId)],
+    config.maxTimelineEntries
+  );
+  // Note: diffText is intentionally omitted from the projection — the
+  // line-count fields (`diffAddedLines` / `diffRemovedLines`) are a sufficient
+  // proxy for "diff content changed" and avoid materialising a megabyte-class
+  // intermediate string on every record call.
+  const changed = timelineProjectionChanged(nextItems, runtime.recentTimelineEntries, [
+    "stableId",
+    "title",
+    "summary",
+    "messageText",
+    "fileEventType",
+    "fileRefs",
+    "createdAtMs",
+    "diffAvailable",
+    "diffSource",
+    "diffAddedLines",
+    "diffRemovedLines",
+    "previousFileRefs",
+    "cwd",
+  ]);
+  runtime.recentTimelineEntries = nextItems;
+  state.recentTimelineEntries = nextItems;
+  if (changed) {
+    publishTimelineUpdate({ config, runtime, entry: normalized, source });
+  }
+  return changed;
+}
+
+function recordCodeEvent({ config, runtime, state, entry }) {
+  if (!isCodeEventEntry(entry)) {
+    return false;
+  }
+  const normalized = normalizeTimelineEntry(entry);
+  if (!normalized) {
+    return false;
+  }
+
+  const nextItems = normalizeCodeEvents(
+    [normalized, ...runtime.recentCodeEvents.filter((item) => item.stableId !== normalized.stableId)],
+    config.maxCodeEvents
+  );
+  // See `recordTimelineEntry` for the rationale on dropping `diffText` from
+  // the projection — same megabyte-stringify hot path; same line-count proxy.
+  const changed = timelineProjectionChanged(nextItems, runtime.recentCodeEvents, [
+    "stableId",
+    "title",
+    "createdAtMs",
+    "diffAvailable",
+    "diffSource",
+    "diffAddedLines",
+    "diffRemovedLines",
+    "previousFileRefs",
+    "cwd",
+  ]);
+  runtime.recentCodeEvents = nextItems;
+  state.recentCodeEvents = nextItems;
+  if (changed) {
+    invalidateDiffThreadGroupsCache();
+  }
+  return changed;
+}
+
+function syncRecentCodeEventsFromTimeline({ config, runtime, state }) {
+  const timelineCodeEvents = normalizeCodeEvents(runtime.recentTimelineEntries, config.maxCodeEvents);
+  if (timelineCodeEvents.length === 0 && runtime.recentCodeEvents.length === 0) {
+    return false;
+  }
+
+  const nextItems = normalizeCodeEvents(
+    [
+      ...timelineCodeEvents,
+      ...runtime.recentCodeEvents.filter(
+        (entry) => !timelineCodeEvents.some((timelineEntry) => timelineEntry.stableId === entry.stableId)
+      ),
+    ],
+    config.maxCodeEvents
+  );
+  // See `recordTimelineEntry` for the rationale on dropping `diffText`.
+  const changed = timelineProjectionChanged(nextItems, runtime.recentCodeEvents, [
+    "stableId",
+    "title",
+    "createdAtMs",
+    "threadLabel",
+    "diffAvailable",
+    "diffSource",
+    "diffAddedLines",
+    "diffRemovedLines",
+    "previousFileRefs",
+    "cwd",
+  ]);
+  runtime.recentCodeEvents = nextItems;
+  state.recentCodeEvents = nextItems;
+  if (changed) {
+    invalidateDiffThreadGroupsCache();
+  }
+  return changed;
+}
+
+function timelineEntryByToken(runtime, token, kind = "") {
   const normalizedToken = cleanText(token ?? "");
   const normalizedKind = cleanText(kind ?? "");
   return runtime.recentTimelineEntries.find(
@@ -3411,6 +4079,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) {
@@ -3573,6 +4253,7 @@ function recordActionHistoryItem({
     runtime,
     state,
     entry: item,
+    source: "event",
   });
   return historyChanged || timelineChanged;
 }
@@ -3732,7 +4413,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;
   }
@@ -3749,8 +4443,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;
     }
 
@@ -3778,8 +4482,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) {
@@ -3931,6 +4637,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 {
@@ -3954,6 +4861,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:
@@ -4031,7 +4939,19 @@ async function processRolloutFile({ filePath, config, runtime, state, now }) {
             runtime,
             state,
             entry: timelineEntry,
+            source: "codex-rollout",
           }) || dirty;
+        upsertTimelineActivity({
+          config,
+          runtime,
+          provider: "codex",
+          threadId: timelineEntry.threadId,
+          threadLabel: timelineEntry.threadLabel,
+          phase: "thinking",
+          cwd: fileState.cwd || "",
+          source: "codex-user-message",
+          atMs: Date.parse(record.timestamp ?? "") || Date.now(),
+        });
       }
 
       const fileTimelineEntries = await buildRolloutFileTimelineEntries({
@@ -4048,6 +4968,7 @@ async function processRolloutFile({ filePath, config, runtime, state, now }) {
             runtime,
             state,
             entry: fileTimelineEntry,
+            source: "codex-rollout",
           }) || dirty;
         dirty =
           recordCodeEvent({
@@ -4234,6 +5155,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) {
@@ -4349,6 +5373,37 @@ 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;
+      }
+      const toolActivity = timelineActivityFromClaudeContent(content);
+      if (toolActivity) {
+        upsertTimelineActivity({
+          config,
+          runtime,
+          provider: "claude",
+          threadId,
+          threadLabel,
+          phase: toolActivity.phase,
+          summary: toolActivity.summary,
+          commandText: toolActivity.commandText,
+          fileRefs: toolActivity.fileRefs,
+          cwd: fileState.cwd,
+          source: "claude-tool-start",
+          atMs: createdAtMs,
+        });
+      }
+    }
+
     let text = "";
     if (typeof content === "string") {
       text = content;
@@ -4386,6 +5441,28 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
       : stopReason === "end_turn"
         ? "assistant_final"
         : "assistant_commentary";
+    if (kind === "user_message") {
+      upsertTimelineActivity({
+        config,
+        runtime,
+        provider: "claude",
+        threadId,
+        threadLabel,
+        phase: "thinking",
+        cwd: fileState.cwd,
+        source: "claude-user-message",
+        atMs: createdAtMs,
+      });
+    } else if (kind === "assistant_final") {
+      clearTimelineActivity({
+        config,
+        runtime,
+        provider: "claude",
+        threadId,
+        source: "claude-final",
+        atMs: createdAtMs,
+      });
+    }
     // Use kind-independent stableId so re-scans with corrected classification
     // replace old entries rather than creating duplicates.
     const stableId = `claude_msg:${threadId}:${uuid}`;
@@ -4404,7 +5481,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") {
@@ -4713,6 +5790,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
@@ -4864,6 +5942,7 @@ async function processHistoryTimelineFile({ config, runtime, state, now }) {
         runtime,
         state,
         entry,
+        source: "codex-history",
       }) || dirty;
   }
 
@@ -5038,6 +6117,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,
       };
@@ -5610,6 +6690,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 [];
@@ -5630,30 +6751,102 @@ 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);
+    const activity = timelineActivityFromCommand({ commandText, cwd: cleanText(args.workdir || fileState.cwd || "") });
+    upsertTimelineActivity({
+      config,
+      runtime,
+      provider: "codex",
+      threadId,
+      threadLabel,
+      phase: activity.phase,
+      commandText: activity.commandText,
+      fileRefs: activity.fileRefs,
+      cwd: activity.cwd,
+      source: "codex-tool-start",
+      atMs: createdAtMs,
+    });
+    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);
+    upsertTimelineActivity({
+      config,
+      runtime,
+      provider: "codex",
+      threadId,
+      threadLabel,
+      phase: "editing",
+      summary: cleanText(payload?.name || "apply_patch"),
+      cwd: fileState.cwd || "",
+      source: "codex-tool-start",
+      atMs: createdAtMs,
+    });
     return [];
   }
 
   if (payloadType === "function_call_output") {
+    if (findStoredToolEventInput(fileState, callId)) {
+      upsertTimelineActivity({
+        config,
+        runtime,
+        provider: "codex",
+        threadId,
+        threadLabel,
+        phase: "thinking",
+        cwd: fileState.cwd || "",
+        source: "codex-tool-output",
+        atMs: createdAtMs,
+      });
+      return [];
+    }
     const commandText = extractCommandLineFromFunctionOutput(payload.output ?? "");
-    const fileRefs = extractReadFileRefsFromCommand(commandText);
-    if (fileRefs.length === 0) {
+    if (!commandText) {
       return [];
     }
+    const classified = classifyTimelineCommand(commandText);
+    upsertTimelineActivity({
+      config,
+      runtime,
+      provider: "codex",
+      threadId,
+      threadLabel,
+      phase: "thinking",
+      cwd: fileState.cwd || "",
+      source: "codex-tool-output",
+      atMs: createdAtMs,
+    });
     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);
   }
@@ -5801,6 +6994,18 @@ async function buildRolloutFileTimelineEntries({ config, record, fileState, runt
       fileState.applyPatchInputsByCallId.delete(callId);
     }
 
+    upsertTimelineActivity({
+      config,
+      runtime,
+      provider: "codex",
+      threadId,
+      threadLabel,
+      phase: "thinking",
+      cwd: fileState.cwd || "",
+      source: "codex-tool-output",
+      atMs: createdAtMs,
+    });
+
     return entries.filter(Boolean);
   }
 
@@ -5857,8 +7062,24 @@ async function processScannedEvent({ config, runtime, state, event }) {
   let dirty = false;
 
   if (event.kind === "task_complete") {
+    clearTimelineActivity({
+      config,
+      runtime,
+      provider: "codex",
+      threadId: event.threadId ?? event.conversationId ?? "",
+      source: "codex-task-complete",
+      atMs: event.timestampMs || Date.now(),
+    });
     attachCompletionDetails({ config, runtime, event });
   } else if (event.kind === "plan_ready") {
+    clearTimelineActivity({
+      config,
+      runtime,
+      provider: "codex",
+      threadId: event.threadId ?? event.conversationId ?? "",
+      source: "codex-plan-ready",
+      atMs: event.timestampMs || Date.now(),
+    });
     attachPlanDetails({ config, runtime, event });
   }
 
@@ -5884,6 +7105,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 }) => ({
@@ -6102,6 +7325,8 @@ function buildRolloutEvent({ record, filePath, fileState, sessionIndex, config,
       threadLabel: context.threadLabel,
       message,
       detailText,
+      threadId,
+      turnId,
       priority: config.completePriority,
       tags: config.completeTags,
       clickUrl: config.clickUrl,
@@ -6335,7 +7560,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;
   }
@@ -6671,7 +7896,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;
     }
@@ -8469,7 +9698,7 @@ class NativeIpcClient {
     );
   }
 
-  async startTurn(conversationId, turnStartParams, ownerClientId = null) {
+  async startTurn(conversationId, turnStartParams, ownerClientId = null, options = {}) {
     return this.sendThreadFollowerRequest(
       "thread-follower-start-turn",
       {
@@ -8477,11 +9706,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) ??
@@ -8489,7 +9719,7 @@ class NativeIpcClient {
     return this.sendRequest(
       "turn/start",
       buildDirectTurnStartPayload(conversationId, turnStartParams),
-      { targetClientId }
+      { targetClientId, ...options }
     );
   }
 
@@ -8519,12 +9749,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,
     });
   }
 
@@ -9407,9 +10638,10 @@ function formatNativeApprovalMessage(kind, params, locale = config?.defaultLocal
 }
 
 function formatCommandApprovalMessage(params, locale = config?.defaultLocale || DEFAULT_LOCALE) {
+  const safeParams = isPlainObject(params) ? params : {};
   const parts = [];
-  const reason = truncate(cleanText(params.reason ?? params.justification ?? ""), 220);
-  const command = truncate(cleanText(params.command ?? params.cmd ?? ""), 1200);
+  const reason = truncate(cleanText(safeParams.reason ?? safeParams.justification ?? ""), 220);
+  const command = truncate(cleanText(safeParams.command ?? safeParams.cmd ?? ""), 1200);
   if (reason) {
     parts.push(reason);
   } else {
@@ -9422,21 +10654,41 @@ function formatCommandApprovalMessage(params, locale = config?.defaultLocale ||
 }
 
 function formatFileApprovalMessage(params, locale = config?.defaultLocale || DEFAULT_LOCALE) {
+  const safeParams = isPlainObject(params) ? params : {};
   const parts = [];
-  const reason = truncate(cleanText(params.reason ?? ""), 220);
+  const reason = truncate(cleanText(safeParams.reason ?? ""), 220);
   if (reason) {
     parts.push(reason);
   } else {
     parts.push(t(locale, "server.message.fileApprovalNeeded"));
   }
-  if (params.grantRoot) {
-    parts.push(t(locale, "server.message.pathPrefix", { path: compactPath(params.grantRoot) }));
-  } else if (params.cwd) {
-    parts.push(t(locale, "server.message.pathPrefix", { path: compactPath(params.cwd) }));
+  if (safeParams.grantRoot) {
+    parts.push(t(locale, "server.message.pathPrefix", { path: compactPath(safeParams.grantRoot) }));
+  } else if (safeParams.cwd) {
+    parts.push(t(locale, "server.message.pathPrefix", { path: compactPath(safeParams.cwd) }));
   }
   return truncate(parts.join("\n"), 1024);
 }
 
+function claudeApprovalRawParams(body, kind) {
+  const toolInput = isPlainObject(body?.toolInput) ? cloneJson(body.toolInput) : {};
+  const rawParams = {
+    ...toolInput,
+    ...(body?.cwd ? { cwd: String(body.cwd) } : {}),
+  };
+  const messageText = cleanText(body?.messageText || "");
+  if (messageText && !cleanText(rawParams.reason ?? rawParams.justification ?? "")) {
+    rawParams.reason = messageText;
+  }
+  if (kind === "command" && !cleanText(rawParams.command ?? rawParams.cmd ?? "")) {
+    const commandText = cleanText(toolInput.command ?? toolInput.cmd ?? "");
+    if (commandText) {
+      rawParams.command = commandText;
+    }
+  }
+  return rawParams;
+}
+
 function extractApprovalFileRefs(params) {
   if (!isPlainObject(params)) {
     return [];
@@ -10866,6 +12118,10 @@ async function handleMcpProviderEvent({ config, runtime, state, body, res }) {
       stableId,
       title,
       body: messageText,
+      buildLocalizedContent: ({ locale }) => ({
+        title: localizedMcpNotifyTitle(locale, title),
+        body: pushBodySnippet(messageText),
+      }),
     }).catch((error) => {
       console.error(`[mcp-notify-push] ${error.message}`);
       return false;
@@ -10897,10 +12153,7 @@ async function handleMcpProviderEvent({ config, runtime, state, body, res }) {
       stableId: pendingApprovalStableId(approval),
       title: approval.title || "MCP",
       body: approval.messageText,
-      buildLocalizedContent: () => ({
-        title: approval.title || "MCP",
-        body: approval.messageText,
-      }),
+      buildLocalizedContent: ({ locale }) => localizedMcpApprovalPushContent(locale, approval),
     }).catch((error) => {
       console.error(`[mcp-approval-push] ${approval.requestKey} | ${error.message}`);
     });
@@ -11265,6 +12518,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()) {
@@ -11846,6 +13110,26 @@ function buildTimelineThreads(entries, config) {
     .slice(0, config.maxTimelineThreads);
 }
 
+function buildActiveTimelineActivityEntries(runtime, locale) {
+  if (!(runtime?.activeTimelineActivitiesByKey instanceof Map)) {
+    return [];
+  }
+  const now = Date.now();
+  const entries = [];
+  for (const [key, activity] of [...runtime.activeTimelineActivitiesByKey.entries()]) {
+    const updatedAtMs = Number(activity?.updatedAtMs) || 0;
+    if (!updatedAtMs || now - updatedAtMs > TIMELINE_ACTIVITY_TTL_MS) {
+      runtime.activeTimelineActivitiesByKey.delete(key);
+      continue;
+    }
+    const entry = buildTimelineActivityEntry(activity, locale);
+    if (entry) {
+      entries.push(entry);
+    }
+  }
+  return entries;
+}
+
 function buildTimelineResponse(runtime, state, config, locale) {
   const messageEntries = normalizeTimelineEntries(
     state.recentTimelineEntries ?? runtime.recentTimelineEntries,
@@ -11853,7 +13137,11 @@ function buildTimelineResponse(runtime, state, config, locale) {
   );
   runtime.recentTimelineEntries = messageEntries;
   const entries = normalizeTimelineEntries(
-    [...messageEntries, ...buildOperationalTimelineEntries(runtime, state, config, locale)],
+    [
+      ...buildActiveTimelineActivityEntries(runtime, locale),
+      ...messageEntries,
+      ...buildOperationalTimelineEntries(runtime, state, config, locale),
+    ],
     config.maxTimelineEntries
   ).map((entry) => ({
     kind: entry.kind,
@@ -11871,6 +13159,9 @@ function buildTimelineResponse(runtime, state, config, locale) {
     outcome: entry.outcome || "",
     createdAtMs: entry.createdAtMs,
     provider: normalizeProvider(entry.provider),
+    ...(entry.activityPhase != null ? { activityPhase: entry.activityPhase } : {}),
+    ...(entry.commandText != null ? { commandText: entry.commandText } : {}),
+    ...timelineAutoPilotProjection(entry),
     ...(entry.draftType != null ? { draftType: entry.draftType } : {}),
   }));
 
@@ -11880,6 +13171,24 @@ function buildTimelineResponse(runtime, state, config, locale) {
   };
 }
 
+function timelineAutoPilotProjection(entry) {
+  if (cleanText(entry?.kind || "") !== "approval" || cleanText(entry?.outcome || "") !== "approved") {
+    return {};
+  }
+  const stableId = cleanText(entry?.stableId || "");
+  if (stableId.includes(":autopilot-write")) {
+    const lane = cleanText(stableId.match(/:autopilot-write:([a-z_-]+)$/u)?.[1] || "");
+    return {
+      autoPilotMode: "write",
+      ...(lane ? { autoPilotWriteLane: lane } : {}),
+    };
+  }
+  if (stableId.endsWith(":autopilot")) {
+    return { autoPilotMode: "read" };
+  }
+  return {};
+}
+
 function buildPendingApprovalDetail(runtime, state, approval, locale) {
   const previousContext = buildPreviousApprovalContext(runtime, approval);
   const approvalKind = cleanText(approval.kind || "");
@@ -12338,6 +13647,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 =
@@ -12455,6 +13806,13 @@ function buildAmbientSuggestionsDetail(entry, locale) {
 
 function buildTimelineFileEventDetail(entry, locale) {
   const fileEventType = normalizeTimelineFileEventType(entry?.fileEventType ?? "");
+  const commandText = ["read", "search", "git"].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,
@@ -12463,9 +13821,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 ?? ""),
@@ -12476,6 +13835,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 {
@@ -12849,6 +14227,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 || "");
@@ -12939,30 +14336,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(
@@ -13660,9 +15059,26 @@ async function handleNativeApprovalDecision({ config, runtime, state, approval,
     });
   } 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
-      // call with a reason that tells Claude the user already decided on mobile.
+      // ExitPlanMode CANNOT actually be auto-bypassed via the PreToolUse
+      // hook. We tested both "allow" and "deny" verdicts on Claude Desktop:
+      //
+      //   - permissionDecision: "allow"
+      //       Claude Desktop ignores the verdict and re-shows its native
+      //       plan dialog on the Mac, asking for approval a second time
+      //       even though the user already tapped on mobile.
+      //   - permissionDecision: "deny"
+      //       The native dialog is suppressed, but Claude Desktop also
+      //       does not exit plan mode internally, so Edit/Write stay
+      //       blocked — the session cannot make progress.
+      //
+      // Neither verdict gives us "phone tap → plan mode exits → editing
+      // resumes" by itself. Until we can drive the Mac dialog through an
+      // external mechanism (AppleScript / Accessibility API), the chosen
+      // workaround is "deny + reason": Claude reads the reason as
+      // instructions ("user already approved on mobile, proceed without
+      // calling ExitPlanMode again"). That at least lets the desktop user
+      // finish the flow with one extra Mac click on the native dialog
+      // instead of getting a duplicate dialog from a stale "allow".
       approval.resolveClaudeWaiter({
         permissionDecision: "deny",
         permissionDecisionReason:
@@ -13718,6 +15134,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) {
@@ -13899,6 +15319,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 || {},
@@ -14168,7 +15590,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;
@@ -14378,6 +15800,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(),
@@ -14550,7 +16073,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";
@@ -15459,6 +16982,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 }
@@ -16064,6 +17610,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}`);
@@ -16163,6 +17716,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}`);
@@ -16255,7 +17812,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) => ({
@@ -16424,7 +17981,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}`);
         });
@@ -16514,10 +18071,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}`);
         });
@@ -16589,6 +18143,13 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           const threadId = String(body.threadId || body.sessionId || "");
           console.log(`[claude-stop] threadId=${threadId} pendingTotal=${runtime.nativeApprovalsByToken.size}`);
           if (threadId) {
+            clearTimelineActivity({
+              config,
+              runtime,
+              provider: "claude",
+              threadId,
+              source: "claude-stop",
+            });
             const pending = [];
             for (const approval of runtime.nativeApprovalsByToken.values()) {
               if (!approval.resolved && approval.conversationId === threadId) {
@@ -16659,6 +18220,21 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           // for this session/tool as accepted (so iPhone moves it to completed).
           const threadId = String(body.threadId || body.sessionId || "");
           const toolName = String(body.toolName || "");
+          const eventCwd = String(body.cwd || "");
+          const threadLabel =
+            runtime.claudeSessionTitles.get(threadId) ||
+            (eventCwd ? path.basename(eventCwd) : "") ||
+            threadId.slice(0, 40);
+          upsertTimelineActivity({
+            config,
+            runtime,
+            provider: "claude",
+            threadId,
+            threadLabel,
+            phase: "thinking",
+            cwd: eventCwd,
+            source: "claude-post-tool",
+          });
           const fingerprint = claudeToolFingerprint(toolName, body.toolInput);
           console.log(`[claude-post-tool] threadId=${threadId} tool=${toolName} fp=${fingerprint.slice(0, 80)} pendingTotal=${runtime.nativeApprovalsByToken.size}`);
           const match = findClaudePendingApprovalForTool(runtime, threadId, toolName, fingerprint);
@@ -16694,6 +18270,31 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           }
         }
 
+        if (eventType === "PreToolUse") {
+          const threadId = String(body.threadId || body.sessionId || "");
+          const eventCwd = String(body.cwd || "");
+          const toolName = String(body.toolName || "");
+          const toolActivity = timelineActivityFromClaudeTool(toolName, isPlainObject(body.toolInput) ? body.toolInput : {});
+          const threadLabel =
+            runtime.claudeSessionTitles.get(threadId) ||
+            (eventCwd ? path.basename(eventCwd) : "") ||
+            threadId.slice(0, 40);
+          upsertTimelineActivity({
+            config,
+            runtime,
+            provider: "claude",
+            threadId,
+            threadLabel,
+            phase: toolActivity.phase,
+            summary: toolActivity.summary,
+            commandText: toolActivity.commandText,
+            fileRefs: toolActivity.fileRefs,
+            cwd: eventCwd,
+            source: "claude-pre-tool",
+          });
+          return writeJson(res, 200, {});
+        }
+
         if (eventType !== "approval_request") {
           // Non-approval events (Notification, Stop, etc.) — acknowledge immediately
           return writeJson(res, 200, {});
@@ -16705,6 +18306,8 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         const threadId = String(body.threadId || "");
         const requestId = String(body.requestId || crypto.randomUUID());
         const requestKey = `${threadId}:${requestId}`;
+        const approvalKind = String(body.approvalKind || "command");
+        const rawParams = claudeApprovalRawParams(body, approvalKind);
 
         const approval = {
           token,
@@ -16712,13 +18315,14 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           conversationId: threadId,
           requestId,
           ownerClientId: null,
-          kind: String(body.approvalKind || "command"),
+          kind: approvalKind,
           threadLabel:
             runtime.claudeSessionTitles.get(threadId) ||
             (body.cwd ? path.basename(String(body.cwd))  : "") ||
             String(body.threadId || "").slice(0, 40),
           title: config.approvalTitle,
           messageText: String(body.messageText || ""),
+          rawParams,
           fileRefs: Array.isArray(body.fileRefs) ? body.fileRefs : [],
           previousFileRefs: [],
           diffText: String(body.diffText || ""),
@@ -16741,6 +18345,20 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
           readOnly: body.notifyOnly === true,
         };
 
+        upsertTimelineActivity({
+          config,
+          runtime,
+          provider: "claude",
+          threadId,
+          threadLabel: approval.threadLabel,
+          phase: "awaiting_approval",
+          summary: approval.messageText,
+          fileRefs: approval.fileRefs,
+          cwd: approval.cwd,
+          source: "claude-approval-request",
+          atMs: approval.createdAtMs,
+        });
+
         const claudeAutoPilotMatch =
           approval.kind === "command"
             ? maybeAutoApproveTrustedRead({
@@ -16797,21 +18415,28 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         runtime.nativeApprovalsByToken.set(token, approval);
         runtime.nativeApprovalsByRequestKey.set(requestKey, approval);
 
-        deliverWebPushItem({
-          config,
-          state,
-          kind: "approval",
-          tab: "inbox",
-          subtab: "pending",
-          token: approval.token,
-          stableId: pendingApprovalStableId(approval),
-          title: approval.title,
-          body: approval.messageText,
-          buildLocalizedContent: ({ locale }) => ({
-            title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
+        try {
+          const pushChanged = await deliverWebPushItem({
+            config,
+            state,
+            kind: "approval",
+            tab: "inbox",
+            subtab: "pending",
+            token: approval.token,
+            stableId: pendingApprovalStableId(approval),
+            title: approval.title,
             body: approval.messageText,
-          }),
-        }).catch(() => {});
+            buildLocalizedContent: ({ locale }) => ({
+              title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
+              body: formatNativeApprovalMessage(approval.kind, approval.rawParams, locale),
+            }),
+          });
+          if (pushChanged) {
+            await saveState(config.stateFile, state);
+          }
+        } catch (error) {
+          console.error(`[claude-approval-push] ${approval.requestKey} | ${error.message}`);
+        }
 
         // Notify-only path: phone gets a read-only entry + push, but the
         // hook does not block on a decision. The PostToolUse handler will
@@ -16938,6 +18563,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}`);
@@ -17033,6 +18659,22 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         if (draftType === "reply" && !postId) {
           return writeJson(res, 400, { error: "missing-postId-for-reply" });
         }
+        if (draftType !== "original_post") {
+          const scoutState = rollScoutDayIfNeeded(await readScoutState());
+          const quota = await getMoltbookReplyQuotaState({ state: scoutState, maxDaily: 5 });
+          if (quota.quotaReached) {
+            await writeScoutState(scoutState);
+            return writeJson(res, 409, {
+              error: "moltbook-reply-quota-reached",
+              sentToday: quota.sentToday,
+              pendingToday: quota.pendingToday,
+              usedToday: quota.usedToday,
+              maxDaily: quota.maxDaily,
+              day: quota.day,
+            });
+          }
+          await writeScoutState(scoutState);
+        }
         const token = historyToken(`moltbook_draft:${sourceId}`);
         const postTitle = cleanText(body.postTitle || "");
         const postUrl = cleanText(body.postUrl || `https://www.moltbook.com/post/${postId}`);
@@ -17097,20 +18739,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,
@@ -17121,6 +18750,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}`);
@@ -17177,6 +18810,17 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
         const action = String(body.action || "") === "approve" ? "approve" : "deny";
         const editedText = cleanText(body.editedText || "");
         const editedTitle = cleanText(body.editedTitle || "");
+        if (action === "approve" && draft.draftType !== "original_post") {
+          const quota = await reserveMoltbookReplyQuotaSlot(draft, 5);
+          if (quota.quotaReached) {
+            return writeJson(res, 409, {
+              error: "moltbook-reply-quota-reached",
+              sentToday: quota.sentToday,
+              maxDaily: quota.maxDaily,
+              day: quota.day,
+            });
+          }
+        }
         const decision = {
           action,
           text: action === "approve" ? editedText || draft.draftText : "",
@@ -17210,6 +18854,15 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
               await executeMoltbookDraftPost(draft, config, runtime, state);
             } catch (postError) {
               console.error(`[moltbook-draft-post-error] ${postError.message}`);
+              await releaseMoltbookReplyQuotaSlot(draft).catch((error) => console.error(`[moltbook-quota-release] ${error.message}`));
+              if (draft.parentCommentId) {
+                await updateInboxStatus(draft.parentCommentId, "pending", {
+                  source: "mobile-draft-approve",
+                  draftStatus: "failed",
+                  draftToken: draft.token,
+                  draftError: String(postError.message || "").slice(0, 500),
+                }).catch((error) => console.error(`[moltbook-inbox-post-failed] ${error.message}`));
+              }
               try {
                 await deliverWebPushItem({
                   config, state, kind: "moltbook_draft", token: draft.token,
@@ -17218,6 +18871,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 */ }
             }
@@ -17225,6 +18882,14 @@ if (url.pathname === "/api/hazbase/logout" && req.method === "POST") {
             setTimeout(() => runtime.moltbookDraftsByToken.delete(token), 120_000).unref?.();
           })();
         } else {
+          if (draft.parentCommentId) {
+            await updateInboxStatus(draft.parentCommentId, "skipped", {
+              source: "mobile-draft-deny",
+              draftStatus: "denied",
+              draftToken: draft.token,
+              skippedAt: new Date().toISOString(),
+            }).catch((error) => console.error(`[moltbook-inbox-denied] ${error.message}`));
+          }
           // Deny — clean up.
           await deleteDraft(token).catch(() => {});
           setTimeout(() => runtime.moltbookDraftsByToken.delete(token), 120_000).unref?.();
@@ -17259,6 +18924,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]);
@@ -17327,7 +19000,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,
@@ -17341,6 +19014,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") {
@@ -17381,6 +19056,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) {
@@ -19283,9 +20972,21 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
     createdPostId = draft.postId || null;
     createdCommentId = comment?.id || null;
     console.log(`[moltbook-draft-post] Posted reply (commentId=${comment?.id}) to post ${draft.postId}`);
+    if (draft.parentCommentId) {
+      await updateInboxStatus(draft.parentCommentId, "replied", {
+        source: "mobile-draft-approve",
+        replyText: finalText,
+        replyCommentId: createdCommentId || "",
+        replyVerification: verification || null,
+        draftStatus: "posted",
+        draftToken: draft.token,
+      }).catch((error) => console.error(`[moltbook-inbox-replied] ${error.message}`));
+    }
 
     const scoutState = rollScoutDayIfNeeded(await readScoutState());
-    scoutState.sentToday += 1;
+    if (!draft.replyQuotaReserved) {
+      scoutState.sentToday += 1;
+    }
     markPostSeen(scoutState, draft.postId, "published");
     // Append the reply to `recentComposeTitles` so it shows up in the
     // "最近の投稿" list with its reply badge. `recordComposeAttempt` knows
@@ -19381,6 +21082,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 */ }
 
@@ -19406,6 +21111,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
@@ -19439,6 +21148,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),
@@ -19497,6 +21208,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",
@@ -21419,11 +23134,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);
@@ -21562,6 +23279,8 @@ async function main() {
       }
     }
 
+    timelineLiveHandle = startTimelineLiveSync({ config, runtime, state });
+
     // --- A2A Relay ---
     if (config.a2aRelayUrl && config.a2aRelayUserId) {
       config.a2aAcceptPublicTasks = state.a2aAcceptPublicTasks === true;
@@ -21694,6 +23413,13 @@ async function main() {
   } finally {
     runtime.stopping = true;
 
+    if (timelineLiveHandle) {
+      try {
+        timelineLiveHandle.close();
+      } catch {}
+      timelineLiveHandle = null;
+    }
+
     stopRelayPolling();
 
     if (runtime.remotePairingHandle) {