viveworker 0.1.10 → 0.2.0

package/scripts/viveworker-bridge.mjs

@@ -64,6 +64,12 @@ const runtime = {
   threadOwnerClientIds: new Map(),
   nativeApprovalsByToken: new Map(),
   nativeApprovalsByRequestKey: new Map(),
+  claudeApprovalWaiters: new Map(),
+  claudeKnownFiles: [],
+  lastClaudeScanAt: 0,
+  claudeFileStates: new Map(),
+  claudeSessionTitles: new Map(),
+  lastClaudeSessionTitleScanAt: 0,
   fileApprovalDeltasById: new Map(),
   planRequestsByToken: new Map(),
   planRequestsByRequestKey: new Map(),
@@ -82,6 +88,7 @@ const runtime = {
   stopping: false,
 };
 const state = await loadState(config.stateFile);
+await syncClaudeAwayModeSentinel(config, state.claudeAwayMode === true);
 const migratedPairedDevicesStateChanged = migratePairedDevicesState({ config, state });
 const restoredPendingPlanStateChanged = restorePendingPlanRequests({ config, runtime, state });
 const restoredPendingUserInputStateChanged = restorePendingUserInputRequests({ config, runtime, state });
@@ -204,6 +211,7 @@ function buildSessionLocalePayload(config, state, deviceId) {
     defaultLocale: defaultLocale(config),
     deviceDetectedLocale: resolved.detectedLocale || null,
     deviceOverrideLocale: resolved.overrideLocale || null,
+    claudeAwayMode: state?.claudeAwayMode === true,
   };
 }
 
@@ -311,23 +319,35 @@ function fileEventTitle(locale, fileEventType) {
   }
 }
 
-function fileEventDetailCopy(locale, fileEventType) {
+function fileEventDetailCopy(locale, fileEventType, provider) {
+  const vars = { provider: providerDisplayName(locale, provider) };
   switch (normalizeTimelineFileEventType(fileEventType)) {
     case "read":
-      return t(locale, "detail.fileEvent.read");
+      return t(locale, "detail.fileEvent.read", vars);
     case "write":
-      return t(locale, "detail.fileEvent.write");
+      return t(locale, "detail.fileEvent.write", vars);
     case "create":
-      return t(locale, "detail.fileEvent.create");
+      return t(locale, "detail.fileEvent.create", vars);
     case "delete":
-      return t(locale, "detail.fileEvent.delete");
+      return t(locale, "detail.fileEvent.delete", vars);
     case "rename":
-      return t(locale, "detail.fileEvent.rename");
+      return t(locale, "detail.fileEvent.rename", vars);
     default:
       return t(locale, "detail.detailUnavailable");
   }
 }
 
+function diffThreadDetailCopy(locale, sourceMode, count) {
+  switch (cleanText(sourceMode || "")) {
+    case "git_current":
+      return t(locale, "detail.diffThread.copy.current", { count });
+    case "non_git_latest":
+      return t(locale, "detail.diffThread.copy.latest", { count });
+    default:
+      return t(locale, "detail.diffThread.copy", { count });
+  }
+}
+
 function inferTimelineOutcome(kind, summary = "", messageText = "") {
   const normalizedKind = cleanText(kind || "");
   if (!normalizedKind) {
@@ -1764,10 +1784,218 @@ function resolveCurrentChangeOwner(change, candidates) {
   return null;
 }
 
+function normalizeCodeFallbackFileRef({ fileRef, cwd = "" }) {
+  const normalizedFileRef = cleanTimelineFileRef(fileRef);
+  if (!normalizedFileRef) {
+    return "";
+  }
+  if (path.isAbsolute(normalizedFileRef)) {
+    return resolvePath(normalizedFileRef);
+  }
+  const normalizedCwd = resolvePath(cleanText(cwd || ""));
+  if (!normalizedCwd) {
+    return normalizedFileRef;
+  }
+  return resolvePath(path.resolve(normalizedCwd, normalizedFileRef));
+}
+
+function buildNonGitCodeChangeEntries(item) {
+  const changeType = normalizeTimelineFileEventType(item?.fileEventType || "");
+  if (!["write", "create", "delete", "rename"].includes(changeType)) {
+    return [];
+  }
+
+  const normalizedCwd = cleanText(item?.cwd || "");
+  const normalizedFileRefs = normalizeTimelineFileRefs(item?.fileRefs ?? []).map((fileRef) =>
+    normalizeCodeFallbackFileRef({ fileRef, cwd: normalizedCwd })
+  );
+  const normalizedPreviousFileRefs = normalizeTimelineFileRefs(item?.previousFileRefs ?? []).map((fileRef) =>
+    normalizeCodeFallbackFileRef({ fileRef, cwd: normalizedCwd })
+  );
+  const sections = splitUnifiedDiffTextByFile(item?.diffText ?? "");
+  const rawChanges = [];
+
+  if (changeType === "rename") {
+    const pairCount = Math.max(normalizedFileRefs.length, normalizedPreviousFileRefs.length);
+    for (let index = 0; index < pairCount; index += 1) {
+      const newFileRef = cleanTimelineFileRef(normalizedFileRefs[index] || "");
+      const oldFileRef = cleanTimelineFileRef(normalizedPreviousFileRefs[index] || "");
+      if (!newFileRef && !oldFileRef) {
+        continue;
+      }
+      rawChanges.push({
+        changeType,
+        fileRef: newFileRef || oldFileRef,
+        oldFileRef,
+        newFileRef: newFileRef || oldFileRef,
+      });
+    }
+  } else {
+    const targetRefs =
+      normalizedFileRefs.length > 0
+        ? normalizedFileRefs
+        : changeType === "delete"
+          ? normalizedPreviousFileRefs
+          : [];
+    for (const fileRef of targetRefs) {
+      const normalizedFileRef = cleanTimelineFileRef(fileRef || "");
+      if (!normalizedFileRef) {
+        continue;
+      }
+      rawChanges.push({
+        changeType,
+        fileRef: normalizedFileRef,
+        oldFileRef: changeType === "delete" ? normalizedFileRef : "",
+        newFileRef: changeType === "delete" ? "" : normalizedFileRef,
+      });
+    }
+  }
+
+  const allowWholeItemDiff = sections.length === 0 && rawChanges.length <= 1;
+  const baseDiffSource = normalizeTimelineDiffSource(item?.diffSource ?? "");
+  const baseAddedLines = Math.max(0, Number(item?.diffAddedLines) || 0);
+  const baseRemovedLines = Math.max(0, Number(item?.diffRemovedLines) || 0);
+  const threadId = cleanText(item?.threadId || "");
+  const threadLabel = cleanText(item?.threadLabel || "");
+  const createdAtMs = Number(item?.createdAtMs) || 0;
+
+  return rawChanges.map((change) => {
+    const section = findMatchingCurrentDiffSection(sections, change);
+    const diffText = normalizeTimelineDiffText(section?.diffText || (allowWholeItemDiff ? item?.diffText ?? "" : ""));
+    const counts = diffText
+      ? diffLineCounts(diffText)
+      : {
+          addedLines: allowWholeItemDiff ? baseAddedLines : 0,
+          removedLines: allowWholeItemDiff ? baseRemovedLines : 0,
+        };
+    return {
+      threadId,
+      threadLabel,
+      createdAtMs,
+      changeType,
+      fileRef: cleanTimelineFileRef(change.fileRef || change.newFileRef || change.oldFileRef || ""),
+      oldFileRef: cleanTimelineFileRef(change.oldFileRef || ""),
+      newFileRef: cleanTimelineFileRef(change.newFileRef || change.fileRef || ""),
+      diffText,
+      diffAvailable: item?.diffAvailable === true || Boolean(diffText),
+      diffSource: baseDiffSource,
+      diffAddedLines: counts.addedLines,
+      diffRemovedLines: counts.removedLines,
+    };
+  });
+}
+
+function nonGitCodeChangeIdentity(change) {
+  const anchorFileRef = cleanTimelineFileRef(change?.newFileRef || change?.fileRef || change?.oldFileRef || "");
+  return anchorFileRef ? `file:${anchorFileRef}` : "";
+}
+
+function mergeDiffThreadSourceMode(currentMode, nextMode) {
+  const normalizedCurrentMode = cleanText(currentMode || "");
+  const normalizedNextMode = cleanText(nextMode || "");
+  if (!normalizedCurrentMode) {
+    return normalizedNextMode;
+  }
+  if (!normalizedNextMode || normalizedCurrentMode === normalizedNextMode) {
+    return normalizedCurrentMode;
+  }
+  return "mixed";
+}
+
+function ensureDiffThreadGroup(groupsByThread, { threadId = "", threadLabel = "", fallbackKey = "", sourceMode = "" }) {
+  const normalizedThreadId = cleanText(threadId || "");
+  const normalizedThreadLabel = cleanText(threadLabel || "");
+  const normalizedFallbackKey = cleanText(fallbackKey || "");
+  const threadKey = normalizedThreadId || `unknown:${normalizedThreadLabel || normalizedFallbackKey || "thread"}`;
+  let threadGroup = groupsByThread.get(threadKey);
+  if (!threadGroup) {
+    threadGroup = {
+      kind: "diff_thread",
+      token: diffThreadToken(normalizedThreadId, normalizedThreadLabel),
+      threadId: normalizedThreadId,
+      threadLabel: normalizedThreadLabel,
+      sourceMode: cleanText(sourceMode || ""),
+      filesByRef: new Map(),
+    };
+    groupsByThread.set(threadKey, threadGroup);
+    return threadGroup;
+  }
+
+  if (!threadGroup.threadLabel && normalizedThreadLabel) {
+    threadGroup.threadLabel = normalizedThreadLabel;
+  }
+  threadGroup.sourceMode = mergeDiffThreadSourceMode(threadGroup.sourceMode, sourceMode);
+  return threadGroup;
+}
+
+function addChangeToDiffThreadGroup({ groupsByThread, threadId, threadLabel, fallbackKey = "", sourceMode = "", change, createdAtMs }) {
+  const normalizedChangeType = normalizeTimelineFileEventType(change?.changeType || "");
+  const normalizedFileRef = cleanTimelineFileRef(change?.fileRef || change?.newFileRef || change?.oldFileRef || "");
+  const normalizedOldFileRef = cleanTimelineFileRef(change?.oldFileRef || "");
+  const normalizedNewFileRef = cleanTimelineFileRef(change?.newFileRef || normalizedFileRef);
+  if (!normalizedChangeType || !(normalizedFileRef || normalizedOldFileRef || normalizedNewFileRef)) {
+    return;
+  }
+
+  const group = ensureDiffThreadGroup(groupsByThread, {
+    threadId,
+    threadLabel,
+    fallbackKey: normalizedFileRef || normalizedNewFileRef || normalizedOldFileRef || fallbackKey,
+    sourceMode,
+  });
+
+  const fileGroupKey = `file:${normalizedNewFileRef || normalizedFileRef || normalizedOldFileRef}`;
+  if (!fileGroupKey) {
+    return;
+  }
+
+  const latestChangedAtMs = Number(createdAtMs) || 0;
+  const fileGroup = {
+    fileRef: normalizedFileRef || normalizedNewFileRef || normalizedOldFileRef,
+    oldFileRef: normalizedOldFileRef,
+    newFileRef: normalizedNewFileRef || normalizedFileRef,
+    fileLabel:
+      path.basename(
+        normalizedChangeType === "delete"
+          ? normalizedOldFileRef || normalizedFileRef
+          : normalizedNewFileRef || normalizedFileRef || normalizedOldFileRef
+      ) ||
+      normalizedNewFileRef ||
+      normalizedOldFileRef ||
+      normalizedFileRef,
+    changeType: normalizedChangeType,
+    fileEventTypes: [normalizedChangeType],
+    addedLines: Math.max(0, Number(change?.diffAddedLines) || 0),
+    removedLines: Math.max(0, Number(change?.diffRemovedLines) || 0),
+    latestChangedAtMs,
+    sections: [
+      {
+        createdAtMs: latestChangedAtMs,
+        diffText: normalizeTimelineDiffText(change?.diffText ?? ""),
+        diffAvailable: change?.diffAvailable === true || Boolean(change?.diffText),
+        diffSource: normalizeTimelineDiffSource(change?.diffSource ?? ""),
+        addedLines: Math.max(0, Number(change?.diffAddedLines) || 0),
+        removedLines: Math.max(0, Number(change?.diffRemovedLines) || 0),
+        fileEventType: normalizedChangeType,
+      },
+    ],
+  };
+  group.filesByRef.set(fileGroupKey, fileGroup);
+}
+
 function handleSignal() {
   runtime.stopping = true;
 }
 
+function normalizeProvider(value) {
+  const normalized = String(value || "").toLowerCase();
+  return normalized === "claude" ? "claude" : "codex";
+}
+
+function providerDisplayName(locale, provider) {
+  return t(locale, normalizeProvider(provider) === "claude" ? "common.claude" : "common.codex");
+}
+
 function normalizeHistoryItems(rawItems, maxItems) {
   if (!Array.isArray(rawItems)) {
     return [];
@@ -1834,6 +2062,7 @@ function normalizeHistoryItem(raw) {
     readOnly: raw.readOnly !== false,
     primaryLabel: cleanText(raw.primaryLabel ?? "") || "詳細",
     tone: cleanText(raw.tone ?? "") || "secondary",
+    provider: normalizeProvider(raw.provider),
   };
 }
 
@@ -1986,6 +2215,7 @@ function normalizeTimelineEntry(raw) {
     primaryLabel: cleanText(raw.primaryLabel ?? "") || "詳細",
     tone: cleanText(raw.tone ?? "") || "secondary",
     cwd: resolvePath(cleanText(raw.cwd || "")),
+    provider: normalizeProvider(raw.provider),
   };
 }
 
@@ -2211,6 +2441,7 @@ function recordActionHistoryItem({
   diffAddedLines = 0,
   diffRemovedLines = 0,
   outcome = "",
+  provider = "codex",
 }) {
   const item = {
     stableId,
@@ -2228,6 +2459,7 @@ function recordActionHistoryItem({
     diffAddedLines,
     diffRemovedLines,
     outcome,
+    provider: normalizeProvider(provider),
     createdAtMs: Date.now(),
     readOnly: true,
     primaryLabel: "詳細",
@@ -2513,6 +2745,21 @@ async function scanOnce({ config, runtime, state }) {
     dirty = dirty || changed;
   }
 
+  if (config.webUiEnabled) {
+    if (now - runtime.lastClaudeScanAt >= config.directoryScanIntervalMs) {
+      runtime.claudeKnownFiles = await listClaudeTranscriptFiles(config.claudeProjectsDir);
+      runtime.lastClaudeScanAt = now;
+    }
+    if (now - runtime.lastClaudeSessionTitleScanAt >= config.directoryScanIntervalMs) {
+      await refreshClaudeSessionTitles(runtime);
+      runtime.lastClaudeSessionTitleScanAt = now;
+    }
+    for (const filePath of runtime.claudeKnownFiles) {
+      const changed = await processClaudeTranscriptFile({ filePath, config, runtime, state, now });
+      dirty = dirty || changed;
+    }
+  }
+
   if (config.webUiEnabled) {
     const sqliteTimelineChanged = await processSqliteTimelineLog({
       config,
@@ -2735,6 +2982,230 @@ function fileEventCallIdFromStableId(stableId) {
   return match ? cleanText(match[1]) : "";
 }
 
+async function refreshClaudeSessionTitles(runtime) {
+  // Read ~/Library/Application Support/Claude/claude-code-sessions/*/*/local_*.json
+  // Each file maps cliSessionId → title (auto-generated by Claude Desktop).
+  const baseDir = path.join(
+    os.homedir(),
+    "Library",
+    "Application Support",
+    "Claude",
+    "claude-code-sessions"
+  );
+  try {
+    const topEntries = await fs.readdir(baseDir, { withFileTypes: true });
+    for (const top of topEntries) {
+      if (!top.isDirectory()) continue;
+      const topPath = path.join(baseDir, top.name);
+      let midEntries;
+      try {
+        midEntries = await fs.readdir(topPath, { withFileTypes: true });
+      } catch {
+        continue;
+      }
+      for (const mid of midEntries) {
+        if (!mid.isDirectory()) continue;
+        const midPath = path.join(topPath, mid.name);
+        let files;
+        try {
+          files = await fs.readdir(midPath, { withFileTypes: true });
+        } catch {
+          continue;
+        }
+        for (const file of files) {
+          if (!file.isFile() || !file.name.startsWith("local_") || !file.name.endsWith(".json")) continue;
+          try {
+            const raw = await fs.readFile(path.join(midPath, file.name), "utf8");
+            const data = JSON.parse(raw);
+            const cliSessionId = cleanText(data?.cliSessionId || "");
+            const title = cleanText(data?.title || "");
+            if (cliSessionId && title) {
+              runtime.claudeSessionTitles.set(cliSessionId, title);
+            }
+          } catch {
+            // skip unreadable/invalid
+          }
+        }
+      }
+    }
+  } catch {
+    // base dir missing — Claude Desktop not installed
+  }
+}
+
+async function listClaudeTranscriptFiles(claudeProjectsDir) {
+  try {
+    const result = [];
+    const entries = await fs.readdir(claudeProjectsDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const projectPath = path.join(claudeProjectsDir, entry.name);
+      try {
+        const files = await fs.readdir(projectPath, { withFileTypes: true });
+        for (const file of files) {
+          if (!file.isFile() || !file.name.endsWith(".jsonl")) continue;
+          result.push(path.join(projectPath, file.name));
+        }
+      } catch {
+        // skip unreadable project dirs
+      }
+    }
+    return result;
+  } catch {
+    return [];
+  }
+}
+
+async function processClaudeTranscriptFile({ filePath, config, runtime, state, now }) {
+  let fileState = runtime.claudeFileStates.get(filePath);
+  if (!fileState) {
+    // Derive a default threadLabel from the project directory path
+    // e.g. ~/.claude/projects/-Users-y-hoshino-Work-kanade/session.jsonl → "kanade"
+    const projectDirName = path.basename(path.dirname(filePath));
+    const decodedProjectDir = projectDirName.replace(/^-/u, "").replace(/-/gu, "/");
+    const defaultThreadLabel = path.basename(decodedProjectDir) || "";
+
+    // On startup, use the same "recent only" strategy as processRolloutFile to avoid
+    // re-processing old entries that would be immediately discarded by the 250-entry limit.
+    let initialOffset = 0;
+    let startupCutoffMs = 0;
+    try {
+      const stat = await fs.stat(filePath);
+      const shouldReplayRecent = stat.mtimeMs >= now - config.replaySeconds * 1000;
+      if (shouldReplayRecent) {
+        // Recently active transcript: start from near the end and apply a time cutoff
+        initialOffset = Math.max(0, stat.size - config.maxReadBytes);
+        startupCutoffMs = now - config.replaySeconds * 1000;
+      } else {
+        // Inactive transcript: skip to end, only process future appends
+        initialOffset = stat.size;
+      }
+    } catch {
+      // stat failed — start from beginning with no cutoff
+    }
+
+    fileState = { offset: initialOffset, threadId: "", threadLabel: defaultThreadLabel, cwd: "", startupCutoffMs, remainder: "" };
+    runtime.claudeFileStates.set(filePath, fileState);
+  }
+
+  let fileContent;
+  let newOffset;
+  try {
+    const stat = await fs.stat(filePath);
+    if (stat.size <= fileState.offset) return false;
+    if (stat.size - fileState.offset > config.maxReadBytes) {
+      fileState.offset = Math.max(0, stat.size - config.maxReadBytes);
+      fileState.remainder = "";
+    }
+    const readLen = stat.size - fileState.offset;
+    const buf = Buffer.alloc(readLen);
+    const fh = await fs.open(filePath, "r");
+    try {
+      const { bytesRead } = await fh.read(buf, 0, readLen, fileState.offset);
+      fileContent = buf.slice(0, bytesRead).toString("utf8");
+    } finally {
+      await fh.close();
+    }
+    newOffset = stat.size;
+  } catch {
+    return false;
+  }
+
+  const merged = (fileState.remainder || "") + fileContent;
+  const lines = merged.split("\n");
+  // Last element is the in-progress partial line (or "" if file ends with \n).
+  // Stash it as the next remainder so a future scan can complete it.
+  fileState.remainder = lines.pop() ?? "";
+  fileState.offset = newOffset;
+  let dirty = false;
+
+  for (const line of lines) {
+    const trimmed = line.trim();
+    if (!trimmed) continue;
+
+    let record;
+    try {
+      record = JSON.parse(trimmed);
+    } catch {
+      continue;
+    }
+
+    // Apply startup cutoff: skip entries older than replaySeconds on first scan
+    if (fileState.startupCutoffMs && record.timestamp) {
+      const recordMs = Date.parse(record.timestamp);
+      if (recordMs && recordMs < fileState.startupCutoffMs) {
+        // Still update threadId/cwd state so later entries inherit correct context
+        if (record.sessionId) fileState.threadId = record.sessionId;
+        if (record.cwd) {
+          fileState.cwd = record.cwd;
+          fileState.threadLabel = path.basename(record.cwd);
+        }
+        continue;
+      }
+    }
+
+    if (record.sessionId) fileState.threadId = record.sessionId;
+    if (record.cwd) {
+      fileState.cwd = record.cwd;
+      fileState.threadLabel = path.basename(record.cwd);
+    }
+
+    // Only process Claude Desktop sessions
+    if (record.entrypoint !== "claude-desktop") continue;
+
+    const type = record.type;
+    if (type !== "user" && type !== "assistant") continue;
+    // Skip Claude Code's meta records (e.g. Stop hook feedback injected as a
+    // synthetic user message). They are not real user input.
+    if (record.isMeta === true) continue;
+
+    const msg = record.message || {};
+    const content = msg.content;
+    const uuid = cleanText(record.uuid || "");
+    const createdAtMs = record.timestamp ? Date.parse(record.timestamp) : now;
+    const threadId = cleanText(fileState.threadId || record.sessionId || "");
+    // Prefer Claude Desktop's auto-generated session title (e.g. "Sync Codex app from Mac to iPhone")
+    // when available; fall back to the cwd-derived basename (e.g. "viveworker").
+    const claudeTitle = threadId ? runtime.claudeSessionTitles.get(threadId) || "" : "";
+    const threadLabel = claudeTitle || fileState.threadLabel || "";
+
+    let text = "";
+    if (typeof content === "string") {
+      text = content;
+    } else if (Array.isArray(content)) {
+      for (const block of content) {
+        if (block?.type === "text" && block.text) text += block.text;
+      }
+    }
+    text = cleanText(text);
+    if (!text) continue;
+
+    const kind = type === "user" ? "user_message" : "assistant_final";
+    const stableId = `${kind}:${threadId}:${uuid}`;
+    const entry = normalizeTimelineEntry({
+      stableId,
+      token: historyToken(stableId),
+      kind,
+      threadId,
+      threadLabel,
+      title: threadLabel || "Claude",
+      summary: truncate(singleLine(text), 180),
+      messageText: text,
+      createdAtMs,
+      readOnly: true,
+      cwd: fileState.cwd,
+      provider: "claude",
+    });
+    if (entry) {
+      dirty = recordTimelineEntry({ config, runtime, state, entry }) || dirty;
+    }
+  }
+
+  // Clear startup cutoff after first scan so subsequent incremental reads are unfiltered
+  fileState.startupCutoffMs = 0;
+  return dirty;
+}
+
 async function processSqliteCompletionLog({ config, runtime, state, now }) {
   const logsDbFile = cleanText(runtime.logsDbFile || config.codexLogsDbFile || "");
   if (!logsDbFile) {
@@ -3492,8 +3963,13 @@ async function copyTimelineAttachmentToPersistentDir(config, sourcePath) {
     config.timelineAttachmentsDir,
     `${Date.now()}-${crypto.randomUUID()}${extension}`
   );
-  await fs.copyFile(normalizedSourcePath, destinationPath);
-  return destinationPath;
+  try {
+    await fs.copyFile(normalizedSourcePath, destinationPath);
+    return destinationPath;
+  } catch (error) {
+    console.warn(`[timeline-image-copy-skipped] ${error?.message || error}`);
+    return "";
+  }
 }
 
 async function normalizePersistedTimelineImagePaths({ config, state, imagePaths = [] }) {
@@ -3536,7 +4012,7 @@ async function normalizePersistedTimelineImagePaths({ config, state, imagePaths
 
     let persistentPath = existingSourcePath;
     if (!existingSourcePath.startsWith(`${config.timelineAttachmentsDir}${path.sep}`)) {
-      persistentPath = await copyTimelineAttachmentToPersistentDir(config, existingSourcePath);
+      persistentPath = await copyTimelineAttachmentToPersistentDir(config, existingSourcePath) || existingSourcePath;
     }
 
     aliases[normalizedPath] = persistentPath;
@@ -4077,7 +4553,7 @@ function buildRolloutEvent({ record, filePath, fileState, sessionIndex, config,
     const message = formatMessage(
       [
         t(config.defaultLocale, "server.message.approveOnMac"),
-        justification || t(config.defaultLocale, "server.message.approvalNeededInCodex"),
+        justification || t(config.defaultLocale, "server.message.approvalNeededInCodex", { provider: providerDisplayName(config.defaultLocale, "codex") }),
         cmd ? t(config.defaultLocale, "server.message.commandPrefix", { command: cmd }) : null,
         approval.extraCount > 0 ? t(config.defaultLocale, "server.message.extraApprovals", { count: approval.extraCount }) : null,
       ],
@@ -4594,6 +5070,7 @@ async function createNativeApproval({ config, runtime, conversationId, request,
     createdAtMs: now,
     resolved: false,
     resolving: false,
+    provider: "codex",
   };
 }
 
@@ -6769,7 +7246,91 @@ function getNativeThreadLabel({ runtime, conversationId, cwd }) {
   if (cwd) {
     return truncate(cleanText(path.basename(cwd)), 90) || shortId(normalizedConversationId);
   }
-  return shortId(normalizedConversationId) || "Codex task";
+  return shortId(normalizedConversationId) || t(DEFAULT_LOCALE, "server.fallback.codexTask", { provider: providerDisplayName(DEFAULT_LOCALE, "codex") });
+}
+
+function threadStateArchiveStatus(threadState) {
+  if (!isPlainObject(threadState)) {
+    return "";
+  }
+
+  const booleanCandidates = [
+    threadState.archived,
+    threadState.isArchived,
+    threadState.hidden,
+    threadState.isHidden,
+    threadState.deleted,
+    threadState.isDeleted,
+    threadState.closed,
+    threadState.isClosed,
+    threadState.thread?.archived,
+    threadState.thread?.isArchived,
+    threadState.thread?.hidden,
+    threadState.thread?.isHidden,
+    threadState.thread?.deleted,
+    threadState.thread?.isDeleted,
+    threadState.metadata?.archived,
+    threadState.metadata?.isArchived,
+    threadState.metadata?.hidden,
+    threadState.metadata?.isHidden,
+    threadState.metadata?.deleted,
+    threadState.metadata?.isDeleted,
+  ];
+  if (booleanCandidates.some((value) => value === true)) {
+    return "archived";
+  }
+
+  const statusCandidates = [
+    threadState.status,
+    threadState.state,
+    threadState.visibility,
+    threadState.lifecycle,
+    threadState.thread?.status,
+    threadState.thread?.state,
+    threadState.thread?.visibility,
+    threadState.metadata?.status,
+    threadState.metadata?.state,
+    threadState.metadata?.visibility,
+  ]
+    .map((value) => cleanText(value || "").toLowerCase())
+    .filter(Boolean);
+
+  for (const status of statusCandidates) {
+    if (["archived", "hidden", "deleted", "closed"].includes(status)) {
+      return status;
+    }
+  }
+
+  return "";
+}
+
+function shouldExcludeCodeThread(runtime, threadId) {
+  const normalizedThreadId = cleanText(threadId || "");
+  if (!normalizedThreadId) {
+    return false;
+  }
+
+  const threadState = runtime.threadStates.get(normalizedThreadId) ?? null;
+  if (threadStateArchiveStatus(threadState)) {
+    return true;
+  }
+
+  const currentSessionHasThread = Array.isArray(runtime.knownFiles)
+    ? runtime.knownFiles.some((filePath) => extractThreadIdFromRolloutPath(filePath) === normalizedThreadId)
+    : false;
+  if (currentSessionHasThread) {
+    return false;
+  }
+
+  if (threadState) {
+    return false;
+  }
+
+  if (runtime.sessionIndex instanceof Map && runtime.sessionIndex.size > 0) {
+    return runtime.sessionIndex.has(normalizedThreadId);
+  }
+
+  return false;
 }
 
 async function findRolloutThreadCwd(runtime, conversationId) {
@@ -8373,6 +8934,7 @@ function buildPendingInboxItems(runtime, state, config, locale) {
       summary: formatNotificationBody(approval.messageText, 100) || approval.messageText,
       primaryLabel: t(locale, "server.action.review"),
       createdAtMs: Number(approval.createdAtMs) || now,
+      provider: normalizeProvider(approval.provider),
     });
   }
 
@@ -8392,6 +8954,7 @@ function buildPendingInboxItems(runtime, state, config, locale) {
       summary: formatNotificationBody(planRequest.messageText, 100) || planRequest.messageText,
       primaryLabel: t(locale, "server.action.review"),
       createdAtMs: Number(planRequest.createdAtMs) || now,
+      provider: "codex",
     });
   }
 
@@ -8415,6 +8978,7 @@ function buildPendingInboxItems(runtime, state, config, locale) {
       summary: userInputRequest.notificationText || formatNotificationBody(userInputRequest.messageText, 100),
       primaryLabel: t(locale, userInputRequest.supported ? "server.action.select" : "server.action.detail"),
       createdAtMs: Number(userInputRequest.createdAtMs) || now,
+      provider: "codex",
     });
   }
 
@@ -8438,6 +9002,7 @@ function buildCompletedInboxItems(runtime, state, config, locale) {
       fileRefs: normalizeTimelineFileRefs(item.fileRefs ?? []),
       primaryLabel: t(locale, "server.action.detail"),
       createdAtMs: item.createdAtMs,
+      provider: normalizeProvider(item.provider),
     }));
 }
 
@@ -8447,6 +9012,7 @@ async function buildDiffInboxItems(runtime, state, config, locale) {
     token: group.token,
     threadId: group.threadId,
     threadLabel: group.threadLabel || "",
+    sourceMode: cleanText(group.sourceMode || ""),
     title: cleanText(group.threadLabel || "") || kindTitle(locale, "diff_thread"),
     summary: t(locale, "diff.threadSummary", { count: group.changedFileCount }),
     changedFileCount: group.changedFileCount,
@@ -8487,10 +9053,12 @@ async function buildDiffThreadGroups(runtime, state, config) {
     .slice()
     .sort((left, right) => Number(right.createdAtMs ?? 0) - Number(left.createdAtMs ?? 0));
   const candidatesByRepoRoot = new Map();
+  const nonGitRelevantItems = [];
 
   for (const item of relevantItems) {
     const repoRoot = await resolveCodeEventRepoRoot(item, repoRootCache);
     if (!repoRoot) {
+      nonGitRelevantItems.push(item);
       continue;
     }
     const candidates = expandCodeEventOwnershipCandidates(item, repoRoot);
@@ -8512,112 +9080,42 @@ async function buildDiffThreadGroups(runtime, state, config) {
         continue;
       }
 
-      const threadId = cleanText(owner.threadId || "");
-      const threadLabel = cleanText(owner.threadLabel || "");
-      const threadKey = threadId || `unknown:${threadLabel || cleanText(change.fileRef || change.newFileRef || change.oldFileRef || "")}`;
-      let threadGroup = groupsByThread.get(threadKey);
-      if (!threadGroup) {
-        threadGroup = {
-          kind: "diff_thread",
-          token: diffThreadToken(threadId, threadLabel),
-          threadId,
-          threadLabel,
-          changedFileCount: 0,
-          latestChangedAtMs: 0,
-          latestChangedAtMsForSummary: 0,
-          latestChangeType: "",
-          latestChangeFileRefs: [],
-          diffAddedLines: 0,
-          diffRemovedLines: 0,
-          filesByRef: new Map(),
-        };
-        groupsByThread.set(threadKey, threadGroup);
-      } else if (!threadGroup.threadLabel && threadLabel) {
-        threadGroup.threadLabel = threadLabel;
-      }
+      addChangeToDiffThreadGroup({
+        groupsByThread,
+        threadId: cleanText(owner.threadId || ""),
+        threadLabel: cleanText(owner.threadLabel || ""),
+        fallbackKey: cleanText(change.fileRef || change.newFileRef || change.oldFileRef || ""),
+        sourceMode: "git_current",
+        change,
+        createdAtMs: Number(owner.createdAtMs) || 0,
+      });
+    }
+  }
 
-      const fileGroupKey =
-        normalizeTimelineFileEventType(change.changeType) === "rename"
-          ? codeOwnershipKeyForRename(change.oldFileRef || "", change.newFileRef || change.fileRef || "")
-          : `${normalizeTimelineFileEventType(change.changeType)}:${cleanTimelineFileRef(change.fileRef || change.newFileRef || change.oldFileRef || "")}`;
-      if (!fileGroupKey) {
+  const latestNonGitChangesByIdentity = new Map();
+  for (const item of nonGitRelevantItems) {
+    const changes = buildNonGitCodeChangeEntries(item);
+    for (const change of changes) {
+      const identity = nonGitCodeChangeIdentity(change);
+      if (!identity || latestNonGitChangesByIdentity.has(identity)) {
         continue;
       }
-
-      const latestOwnerChangeAtMs = Number(owner.createdAtMs) || 0;
-      const normalizedFileRef = cleanTimelineFileRef(change.fileRef || change.newFileRef || change.oldFileRef || "");
-      const normalizedOldFileRef = cleanTimelineFileRef(change.oldFileRef || "");
-      const normalizedNewFileRef = cleanTimelineFileRef(change.newFileRef || normalizedFileRef);
-      let fileGroup = threadGroup.filesByRef.get(fileGroupKey);
-      if (!fileGroup) {
-        fileGroup = {
-          fileRef: normalizedFileRef,
-          oldFileRef: normalizedOldFileRef,
-          newFileRef: normalizedNewFileRef,
-          fileLabel:
-            path.basename(
-              normalizeTimelineFileEventType(change.changeType) === "delete"
-                ? normalizedOldFileRef || normalizedFileRef
-                : normalizedNewFileRef || normalizedFileRef
-            ) ||
-            normalizedNewFileRef ||
-            normalizedOldFileRef ||
-            normalizedFileRef,
-          changeType: normalizeTimelineFileEventType(change.changeType),
-          fileEventTypes: new Set(),
-          addedLines: 0,
-          removedLines: 0,
-          latestChangedAtMs: latestOwnerChangeAtMs,
-          sections: [],
-        };
-        threadGroup.filesByRef.set(fileGroupKey, fileGroup);
-      }
-
-      const changeType = normalizeTimelineFileEventType(change.changeType);
-      if (changeType) {
-        fileGroup.fileEventTypes.add(changeType);
-      }
-      fileGroup.changeType = changeType || fileGroup.changeType;
-      fileGroup.addedLines = Math.max(0, Number(change.diffAddedLines) || 0);
-      fileGroup.removedLines = Math.max(0, Number(change.diffRemovedLines) || 0);
-      fileGroup.latestChangedAtMs = latestOwnerChangeAtMs;
-      fileGroup.fileRef = normalizedFileRef;
-      fileGroup.oldFileRef = normalizedOldFileRef;
-      fileGroup.newFileRef = normalizedNewFileRef;
-      fileGroup.sections = [
-        {
-          createdAtMs: latestOwnerChangeAtMs,
-          diffText: normalizeTimelineDiffText(change.diffText ?? ""),
-          diffAvailable: change.diffAvailable === true || Boolean(change.diffText),
-          diffSource: normalizeTimelineDiffSource(change.diffSource ?? ""),
-          addedLines: Math.max(0, Number(change.diffAddedLines) || 0),
-          removedLines: Math.max(0, Number(change.diffRemovedLines) || 0),
-          fileEventType: changeType,
-        },
-      ];
-
-      threadGroup.latestChangedAtMs = Math.max(threadGroup.latestChangedAtMs, latestOwnerChangeAtMs);
-      threadGroup.diffAddedLines += Math.max(0, Number(change.diffAddedLines) || 0);
-      threadGroup.diffRemovedLines += Math.max(0, Number(change.diffRemovedLines) || 0);
-
-      if (latestOwnerChangeAtMs > threadGroup.latestChangedAtMsForSummary) {
-        threadGroup.latestChangedAtMsForSummary = latestOwnerChangeAtMs;
-        threadGroup.latestChangeType = changeType || "";
-        threadGroup.latestChangeFileRefs = [normalizedFileRef || normalizedNewFileRef || normalizedOldFileRef];
-      } else if (latestOwnerChangeAtMs === (threadGroup.latestChangedAtMsForSummary || 0)) {
-        if (changeType && threadGroup.latestChangeType && threadGroup.latestChangeType !== changeType) {
-          threadGroup.latestChangeType = "";
-        } else if (!threadGroup.latestChangeType && changeType && threadGroup.latestChangeFileRefs.length === 0) {
-          threadGroup.latestChangeType = changeType;
-        }
-        const latestFileRef = normalizedFileRef || normalizedNewFileRef || normalizedOldFileRef;
-        if (latestFileRef && !threadGroup.latestChangeFileRefs.includes(latestFileRef)) {
-          threadGroup.latestChangeFileRefs.push(latestFileRef);
-        }
-      }
+      latestNonGitChangesByIdentity.set(identity, change);
     }
   }
 
+  for (const change of latestNonGitChangesByIdentity.values()) {
+    addChangeToDiffThreadGroup({
+      groupsByThread,
+      threadId: cleanText(change.threadId || ""),
+      threadLabel: cleanText(change.threadLabel || ""),
+      fallbackKey: cleanText(change.fileRef || change.newFileRef || change.oldFileRef || ""),
+      sourceMode: "non_git_latest",
+      change,
+      createdAtMs: Number(change.createdAtMs) || 0,
+    });
+  }
+
   return [...groupsByThread.values()]
     .map((group) => {
       const files = [...group.filesByRef.values()]
@@ -8627,7 +9125,9 @@ async function buildDiffThreadGroups(runtime, state, config) {
           newFileRef: fileGroup.newFileRef,
           fileLabel: fileGroup.fileLabel,
           changeType: normalizeTimelineFileEventType(fileGroup.changeType),
-          fileEventTypes: [...fileGroup.fileEventTypes.values()],
+          fileEventTypes: Array.isArray(fileGroup.fileEventTypes)
+            ? fileGroup.fileEventTypes
+            : [...fileGroup.fileEventTypes.values()],
           addedLines: fileGroup.addedLines,
           removedLines: fileGroup.removedLines,
           latestChangedAtMs: fileGroup.latestChangedAtMs,
@@ -8635,20 +9135,33 @@ async function buildDiffThreadGroups(runtime, state, config) {
         }))
         .sort((left, right) => Number(right.latestChangedAtMs ?? 0) - Number(left.latestChangedAtMs ?? 0));
 
+      const latestChangedAtMs = Math.max(0, ...files.map((fileGroup) => Number(fileGroup.latestChangedAtMs) || 0));
+      const latestFiles = files.filter((fileGroup) => Number(fileGroup.latestChangedAtMs || 0) === latestChangedAtMs);
+      const latestChangeTypes = [...new Set(latestFiles.map((fileGroup) => normalizeTimelineFileEventType(fileGroup.changeType)).filter(Boolean))];
+      const latestChangeFileRefs = normalizeTimelineFileRefs(
+        latestFiles
+          .map((fileGroup) => cleanTimelineFileRef(fileGroup.fileRef || fileGroup.newFileRef || fileGroup.oldFileRef || ""))
+          .filter(Boolean)
+      );
+      const diffAddedLines = files.reduce((sum, fileGroup) => sum + Math.max(0, Number(fileGroup.addedLines) || 0), 0);
+      const diffRemovedLines = files.reduce((sum, fileGroup) => sum + Math.max(0, Number(fileGroup.removedLines) || 0), 0);
+
       return {
         kind: "diff_thread",
         token: group.token,
         threadId: group.threadId,
         threadLabel: group.threadLabel,
+        sourceMode: cleanText(group.sourceMode || ""),
         changedFileCount: files.length,
-        latestChangedAtMs: group.latestChangedAtMs,
-        latestChangeType: group.latestChangeType,
-        latestChangeFileRefs: normalizeTimelineFileRefs(group.latestChangeFileRefs),
-        diffAddedLines: group.diffAddedLines,
-        diffRemovedLines: group.diffRemovedLines,
+        latestChangedAtMs,
+        latestChangeType: latestChangeTypes.length === 1 ? latestChangeTypes[0] : "",
+        latestChangeFileRefs,
+        diffAddedLines,
+        diffRemovedLines,
         files,
       };
     })
+    .filter((group) => !shouldExcludeCodeThread(runtime, group.threadId))
     .filter((group) => group.changedFileCount > 0)
     .sort((left, right) => Number(right.latestChangedAtMs ?? 0) - Number(left.latestChangedAtMs ?? 0));
 }
@@ -8681,6 +9194,7 @@ function buildOperationalTimelineEntries(runtime, state, config, locale) {
         messageText: approval.messageText,
         outcome: "pending",
         createdAtMs: Number(approval.createdAtMs) || now,
+        provider: normalizeProvider(approval.provider),
       })
     );
   }
@@ -8704,6 +9218,7 @@ function buildOperationalTimelineEntries(runtime, state, config, locale) {
         messageText: planRequest.messageText,
         outcome: "pending",
         createdAtMs: Number(planRequest.createdAtMs) || now,
+        provider: "codex",
       })
     );
   }
@@ -8731,6 +9246,7 @@ function buildOperationalTimelineEntries(runtime, state, config, locale) {
         messageText: userInputRequest.messageText,
         outcome: "pending",
         createdAtMs: Number(userInputRequest.createdAtMs) || now,
+        provider: "codex",
       })
     );
   }
@@ -8751,6 +9267,7 @@ function buildOperationalTimelineEntries(runtime, state, config, locale) {
         messageText: historyItem.messageText,
         outcome: historyItem.outcome,
         createdAtMs: historyItem.createdAtMs,
+        provider: normalizeProvider(historyItem.provider),
       })
     );
   }
@@ -8789,7 +9306,7 @@ function buildTimelineThreads(entries, config) {
     }
     const preferredLabel =
       sanitizeTimelineThreadFilterLabel(entry.threadLabel || "", threadId) ||
-      t(DEFAULT_LOCALE, "server.fallback.codexTask");
+      t(DEFAULT_LOCALE, "server.fallback.codexTask", { provider: providerDisplayName(DEFAULT_LOCALE, entry?.provider) });
     const existing = byThread.get(threadId);
     if (!existing) {
       byThread.set(threadId, {
@@ -8838,6 +9355,7 @@ function buildTimelineResponse(runtime, state, config, locale) {
     diffRemovedLines: Math.max(0, Number(entry.diffRemovedLines) || 0),
     outcome: entry.outcome || "",
     createdAtMs: entry.createdAtMs,
+    provider: normalizeProvider(entry.provider),
   }));
 
   return {
@@ -8848,9 +9366,11 @@ function buildTimelineResponse(runtime, state, config, locale) {
 
 function buildPendingApprovalDetail(runtime, approval, locale) {
   const previousContext = buildPreviousApprovalContext(runtime, approval);
-  return {
+  const approvalKind = cleanText(approval.kind || "");
+  const detail = {
     kind: "approval",
-    approvalKind: cleanText(approval.kind || ""),
+    approvalKind,
+    provider: normalizeProvider(approval.provider),
     token: approval.token,
     title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
     threadLabel: approval.threadLabel || "",
@@ -8863,12 +9383,28 @@ function buildPendingApprovalDetail(runtime, approval, locale) {
     diffAddedLines: Math.max(0, Number(approval.diffAddedLines) || 0),
     diffRemovedLines: Math.max(0, Number(approval.diffRemovedLines) || 0),
     previousContext,
-    readOnly: false,
-    actions: [
-      { label: t(locale, "server.action.approve"), tone: "primary", url: `/api/items/approval/${encodeURIComponent(approval.token)}/accept`, body: {} },
-      { label: t(locale, "server.action.reject"), tone: "danger", url: `/api/items/approval/${encodeURIComponent(approval.token)}/decline`, body: {} },
-    ],
+    readOnly: approval.readOnly === true,
+    actions: approval.readOnly === true
+      ? []
+      : [
+          { label: t(locale, "server.action.approve"), tone: "primary", url: `/api/items/approval/${encodeURIComponent(approval.token)}/accept`, body: {} },
+          { label: t(locale, "server.action.reject"), tone: "danger", url: `/api/items/approval/${encodeURIComponent(approval.token)}/decline`, body: {} },
+        ],
   };
+  if (approvalKind === "plan") {
+    const planText = String(approval.planText || "");
+    detail.planText = planText;
+    detail.planHtml = planText
+      ? renderMessageHtml(planText, `<p>${escapeHtml(t(locale, "detail.planReady"))}</p>`)
+      : "";
+  }
+  if (approvalKind === "question") {
+    detail.questions = Array.isArray(approval.questions) ? approval.questions : [];
+    detail.answerUrl = `/api/items/question/${encodeURIComponent(approval.token)}/answer`;
+    // Question answers are submitted via answerUrl; remove approve/reject actions.
+    detail.actions = [];
+  }
+  return detail;
 }
 
 function buildPreviousApprovalContext(runtime, approval) {
@@ -9151,7 +9687,7 @@ function buildTimelineFileEventDetail(entry, locale) {
     threadLabel: entry.threadLabel || "",
     fileEventType,
     createdAtMs: Number(entry.createdAtMs) || 0,
-    messageHtml: renderMessageHtml(fileEventDetailCopy(locale, fileEventType), `<p>${escapeHtml(t(locale, "detail.detailUnavailable"))}</p>`),
+    messageHtml: renderMessageHtml(fileEventDetailCopy(locale, fileEventType, entry?.provider), `<p>${escapeHtml(t(locale, "detail.detailUnavailable"))}</p>`),
     fileRefs: normalizeTimelineFileRefs(entry.fileRefs ?? []),
     previousFileRefs: normalizeTimelineFileRefs(entry.previousFileRefs ?? []),
     diffAvailable: Boolean(entry.diffAvailable),
@@ -9165,18 +9701,20 @@ function buildTimelineFileEventDetail(entry, locale) {
 }
 
 function buildDiffThreadDetail(group, locale) {
+  const changedFileCount = Math.max(0, Number(group.changedFileCount) || 0);
   return {
     kind: "diff_thread",
     token: group.token,
     threadId: cleanText(group.threadId || ""),
     title: cleanText(group.threadLabel || "") || kindTitle(locale, "diff_thread"),
     threadLabel: group.threadLabel || "",
+    sourceMode: cleanText(group.sourceMode || ""),
     createdAtMs: Number(group.latestChangedAtMs) || 0,
-    changedFileCount: Math.max(0, Number(group.changedFileCount) || 0),
+    changedFileCount,
     diffAddedLines: Math.max(0, Number(group.diffAddedLines) || 0),
     diffRemovedLines: Math.max(0, Number(group.diffRemovedLines) || 0),
     messageHtml: renderMessageHtml(
-      t(locale, "detail.diffThread.copy", { count: Math.max(0, Number(group.changedFileCount) || 0) }),
+      diffThreadDetailCopy(locale, group.sourceMode, changedFileCount),
       `<p>${escapeHtml(t(locale, "detail.detailUnavailable"))}</p>`
     ),
     files: Array.isArray(group.files)
@@ -9278,7 +9816,7 @@ async function submitGenericUserInputDecision({ config, runtime, state, userInpu
     title: userInputRequest.title,
     messageText: userInputRequest.testRequest
       ? `${t(config.defaultLocale, "server.message.choiceSubmittedTest")}\n\n${buildChoiceHistoryText(userInputRequest, submittedAnswers)}`
-      : `${t(config.defaultLocale, "server.message.choiceSubmitted")}\n\n${buildChoiceHistoryText(userInputRequest, submittedAnswers)}`,
+      : `${t(config.defaultLocale, "server.message.choiceSubmitted", { provider: providerDisplayName(config.defaultLocale, "codex") })}\n\n${buildChoiceHistoryText(userInputRequest, submittedAnswers)}`,
     summary: userInputRequest.testRequest
       ? t(config.defaultLocale, "server.message.choiceSummaryReceivedTest")
       : t(config.defaultLocale, "server.message.choiceSummarySubmitted"),
@@ -9716,8 +10254,98 @@ async function handlePlanDecision({ config, runtime, state, planRequest, decisio
   console.log(`[plan-decision] ${planRequest.requestKey} | ${decision} | ${decisionTransport}`);
 }
 
+function claudeToolFingerprint(toolName, toolInput) {
+  if (!toolInput || typeof toolInput !== "object") return "";
+  if (toolName === "Bash") {
+    return String(toolInput.command || "").slice(0, 500);
+  }
+  if (toolName === "Write" || toolName === "Edit" || toolName === "MultiEdit") {
+    return String(toolInput.file_path || toolInput.path || "");
+  }
+  if (toolName === "AskUserQuestion") {
+    // PostToolUse may include the user's `answers` in toolInput, which would
+    // change a naive JSON.stringify fingerprint. Hash only the question texts.
+    try {
+      const qs = Array.isArray(toolInput.questions) ? toolInput.questions : [];
+      return JSON.stringify(qs.map((q) => String(q?.question || q?.header || ""))).slice(0, 500);
+    } catch {
+      return "";
+    }
+  }
+  if (toolName === "ExitPlanMode") {
+    return String(toolInput.plan || "").slice(0, 500);
+  }
+  try {
+    return JSON.stringify(toolInput).slice(0, 500);
+  } catch {
+    return "";
+  }
+}
+
+function formatClaudeQuestionAnswers(questions, answers) {
+  if (!Array.isArray(questions) || !Array.isArray(answers)) return "";
+  const lines = [];
+  for (let i = 0; i < questions.length; i++) {
+    const q = questions[i] || {};
+    const ans = answers[i] || {};
+    const questionText = String(q.question || q.header || "").trim();
+    if (!questionText) continue;
+    const options = Array.isArray(q.options) ? q.options : [];
+    const optionIndices = Array.isArray(ans.optionIndices) ? ans.optionIndices : [];
+    const labels = optionIndices
+      .map((idx) => options[idx]?.label)
+      .filter((label) => typeof label === "string" && label.length > 0);
+    const note = typeof ans.note === "string" ? ans.note.trim() : "";
+    let answerLine = "";
+    if (labels.length > 0) {
+      answerLine = labels.join(", ");
+    }
+    if (note) {
+      answerLine = answerLine ? `${answerLine} (note: ${note})` : note;
+    }
+    if (!answerLine) {
+      answerLine = "(no answer)";
+    }
+    lines.push(`Q${i + 1}: ${questionText}`);
+    lines.push(`A: ${answerLine}`);
+  }
+  return lines.join("\n");
+}
+
+function findClaudePendingApprovalForTool(runtime, threadId, toolName, fingerprint) {
+  let match = null;
+  for (const approval of runtime.nativeApprovalsByToken.values()) {
+    if (approval.resolved) continue;
+    if (approval.conversationId !== threadId) continue;
+    if (approval.claudeToolName && toolName && approval.claudeToolName !== toolName) continue;
+    if (approval.claudeToolFingerprint && fingerprint && approval.claudeToolFingerprint !== fingerprint) continue;
+    if (!match || approval.createdAtMs > match.createdAtMs) match = approval;
+  }
+  return match;
+}
+
 async function handleNativeApprovalDecision({ config, runtime, state, approval, decision }) {
-  await runtime.ipcClient?.sendApprovalDecision(approval, decision);
+  if (approval.resolveClaudeWaiter) {
+    if (approval.provider === "claude" && approval.kind === "plan") {
+      // ExitPlanMode cannot be truly auto-approved via permissionDecision: "allow"
+      // (Claude still shows the native PC plan dialog). Instead, deny the tool
+      // call with a reason that tells Claude the user already decided on mobile.
+      approval.resolveClaudeWaiter({
+        permissionDecision: "deny",
+        permissionDecisionReason:
+          decision === "accept"
+            ? "User approved the plan via the viveworker mobile app. Proceed with implementing the plan exactly as proposed and do not call ExitPlanMode again."
+            : "User rejected the plan via the viveworker mobile app. Revise the plan based on the conversation context before calling ExitPlanMode again.",
+      });
+    } else {
+      approval.resolveClaudeWaiter(decision);
+    }
+  } else if (approval.provider === "claude") {
+    // notifyOnly Claude approvals have no long-poll waiter and no ipcClient
+    // back-channel — the desktop user already answered. Nothing to send.
+  } else {
+    await runtime.ipcClient?.sendApprovalDecision(approval, decision);
+  }
   approval.resolved = true;
   approval.resolving = false;
   runtime.nativeApprovalsByToken.delete(approval.token);
@@ -9731,8 +10359,8 @@ async function handleNativeApprovalDecision({ config, runtime, state, approval,
     token: approval.token,
     title: approval.title,
     threadLabel: approval.threadLabel || "",
-    messageText: `${approvalDecisionMessage(decision, config.defaultLocale)}\n\n${approval.messageText}`,
-    summary: approvalDecisionMessage(decision, config.defaultLocale),
+    messageText: `${approvalDecisionMessage(decision, config.defaultLocale, approval.provider)}\n\n${approval.messageText}`,
+    summary: approvalDecisionMessage(decision, config.defaultLocale, approval.provider),
     fileRefs: normalizeTimelineFileRefs(approval.fileRefs ?? []),
     diffText: normalizeTimelineDiffText(approval.diffText ?? ""),
     diffSource: normalizeTimelineDiffSource(approval.diffSource ?? ""),
@@ -9740,6 +10368,7 @@ async function handleNativeApprovalDecision({ config, runtime, state, approval,
     diffAddedLines: Math.max(0, Number(approval.diffAddedLines) || 0),
     diffRemovedLines: Math.max(0, Number(approval.diffRemovedLines) || 0),
     outcome: decision === "accept" ? "approved" : "rejected",
+    provider: approval.provider || "codex",
   });
   if (stateChanged) {
     await saveState(config.stateFile, state);
@@ -10150,6 +10779,26 @@ function createNativeApprovalServer({ config, runtime, state }) {
         });
       }
 
+      if (url.pathname === "/api/settings/claude-away-mode" && req.method === "POST") {
+        const session = requireMutatingApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+        let payload;
+        try {
+          payload = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+        const enabled = payload?.enabled === true;
+        if (state.claudeAwayMode !== enabled) {
+          state.claudeAwayMode = enabled;
+          await saveState(config.stateFile, state);
+        }
+        await syncClaudeAwayModeSentinel(config, enabled);
+        return writeJson(res, 200, { ok: true, enabled });
+      }
+
       if (url.pathname === "/api/push/status" && req.method === "GET") {
         const session = requireApiSession(req, res, config, state);
         if (!session) {
@@ -10271,6 +10920,221 @@ function createNativeApprovalServer({ config, runtime, state }) {
         });
       }
 
+      if (url.pathname === "/api/providers/claude/events" && req.method === "POST") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+          return writeJson(res, 401, { error: "unauthorized" });
+        }
+
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+
+        const eventType = String(body.eventType || body.hookEventName || "");
+
+        if (eventType === "Stop" || eventType === "SessionEnd") {
+          // Agent turn ended — any still-pending native approvals for this
+          // session were not resolved by PostToolUse, meaning the user
+          // denied them on PC. Resolve as deny so iPhone clears them.
+          const threadId = String(body.threadId || body.sessionId || "");
+          console.log(`[claude-stop] threadId=${threadId} pendingTotal=${runtime.nativeApprovalsByToken.size}`);
+          if (threadId) {
+            const pending = [];
+            for (const approval of runtime.nativeApprovalsByToken.values()) {
+              if (!approval.resolved && approval.conversationId === threadId) {
+                pending.push(approval);
+              }
+            }
+            console.log(`[claude-stop] matched=${pending.length}`);
+            for (const approval of pending) {
+              try {
+                await handleNativeApprovalDecision({ config, runtime, state, approval, decision: "reject" });
+              } catch (error) {
+                console.error(`[claude-stop-resolve-error] ${approval.requestKey} | ${error.message}`);
+              }
+            }
+          }
+          return writeJson(res, 200, {});
+        }
+
+        if (eventType === "file_event") {
+          const threadId = String(body.threadId || body.sessionId || "");
+          const filePath = String(body.filePath || "");
+          const fileEventType = String(body.fileEventType || "");
+          if (!threadId || !filePath || !fileEventType) {
+            return writeJson(res, 200, {});
+          }
+          const eventCwd = String(body.cwd || "");
+          const createdAtMs = Number(body.createdAtMs) || Date.now();
+          const threadLabel =
+            runtime.claudeSessionTitles.get(threadId) ||
+            getNativeThreadLabel({ runtime, conversationId: threadId, cwd: eventCwd }) ||
+            (eventCwd ? path.basename(eventCwd) : "") ||
+            threadId.slice(0, 40);
+          const stableId = `file_event:${fileEventType}:${threadId}:${historyToken(`${threadId}:${createdAtMs}:${filePath}`)}`;
+          const token = historyToken(`file_event:${fileEventType}:${threadId}:${createdAtMs}:${filePath}`);
+          const entry = {
+            stableId,
+            token,
+            kind: "file_event",
+            fileEventType,
+            threadId,
+            threadLabel,
+            title: fileEventTitle(DEFAULT_LOCALE, fileEventType),
+            summary: "",
+            fileRefs: [filePath],
+            diffText: String(body.diffText || ""),
+            diffSource: "claude-hook",
+            diffAvailable: body.diffAvailable === true || Boolean(body.diffText),
+            diffAddedLines: Math.max(0, Number(body.diffAddedLines) || 0),
+            diffRemovedLines: Math.max(0, Number(body.diffRemovedLines) || 0),
+            createdAtMs,
+            cwd: eventCwd,
+            readOnly: true,
+            provider: "claude",
+          };
+          const changed = recordTimelineEntry({ config, runtime, state, entry });
+          if (changed) {
+            try {
+              await saveState(config.stateFile, state);
+            } catch (error) {
+              console.error(`[claude-file-event-save] ${error.message}`);
+            }
+          }
+          return writeJson(res, 200, { ok: true });
+        }
+
+        if (eventType === "PostToolUse" || eventType === "PostToolUseFailure") {
+          // The tool actually ran on PC — resolve any pending native approval
+          // 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 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);
+          console.log(`[claude-post-tool] match=${match ? match.requestKey : "none"}`);
+          if (match) {
+            try {
+              await handleNativeApprovalDecision({ config, runtime, state, approval: match, decision: "accept" });
+            } catch (error) {
+              console.error(`[claude-post-tool-resolve-error] ${match.requestKey} | ${error.message}`);
+            }
+          }
+          return writeJson(res, 200, {});
+        }
+
+        if (eventType !== "approval_request") {
+          // Non-approval events (Notification, Stop, etc.) — acknowledge immediately
+          return writeJson(res, 200, {});
+        }
+
+        // Approval request — register in shared map so UI can display it,
+        // then long-poll until user decides (or 10 min timeout)
+        const token = crypto.randomBytes(18).toString("hex");
+        const threadId = String(body.threadId || "");
+        const requestId = String(body.requestId || crypto.randomUUID());
+        const requestKey = `${threadId}:${requestId}`;
+
+        const approval = {
+          token,
+          requestKey,
+          conversationId: threadId,
+          requestId,
+          ownerClientId: null,
+          kind: String(body.approvalKind || "command"),
+          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 || ""),
+          fileRefs: Array.isArray(body.fileRefs) ? body.fileRefs : [],
+          previousFileRefs: [],
+          diffText: String(body.diffText || ""),
+          diffAvailable: Boolean(body.diffAvailable),
+          diffSource: String(body.diffSource || "claude_permission_request"),
+          diffAddedLines: Math.max(0, Number(body.diffAddedLines) || 0),
+          diffRemovedLines: Math.max(0, Number(body.diffRemovedLines) || 0),
+          createdAtMs: Number(body.createdAtMs) || Date.now(),
+          resolved: false,
+          resolving: false,
+          resolveClaudeWaiter: null,
+          claudeToolName: String(body.toolName || ""),
+          claudeToolFingerprint: claudeToolFingerprint(String(body.toolName || ""), body.toolInput),
+          provider: "claude",
+          planText: String(body.planText || ""),
+          questions: Array.isArray(body.questions) ? body.questions : [],
+          notifyOnly: body.notifyOnly === true,
+          readOnly: body.notifyOnly === true,
+        };
+
+        runtime.nativeApprovalsByToken.set(token, approval);
+        runtime.nativeApprovalsByRequestKey.set(requestKey, approval);
+
+        deliverWebPushItem({
+          config,
+          state,
+          kind: "approval",
+          token: approval.token,
+          stableId: pendingApprovalStableId(approval),
+          title: approval.title,
+          body: approval.messageText,
+          buildLocalizedContent: ({ locale }) => ({
+            title: formatLocalizedTitle(locale, "server.title.approval", approval.threadLabel),
+            body: approval.messageText,
+          }),
+        }).catch(() => {});
+
+        // Notify-only path: phone gets a read-only entry + push, but the
+        // hook does not block on a decision. The PostToolUse handler will
+        // clean it up once the desktop user finishes the tool call.
+        if (approval.notifyOnly) {
+          return writeJson(res, 200, { ok: true, notifyOnly: true });
+        }
+
+        const CLAUDE_APPROVAL_WAIT_MS = 600_000; // 10 min
+
+        const decisionPromise = new Promise((resolve) => {
+          approval.resolveClaudeWaiter = resolve;
+        });
+
+        const timeoutPromise = new Promise((resolve) => {
+          setTimeout(() => resolve("deny"), CLAUDE_APPROVAL_WAIT_MS);
+        });
+
+        const decision = await Promise.race([decisionPromise, timeoutPromise]);
+
+        // Clean up if timed out (waiter was never called)
+        if (!approval.resolved) {
+          approval.resolved = true;
+          approval.resolving = false;
+          runtime.nativeApprovalsByToken.delete(token);
+          runtime.nativeApprovalsByRequestKey.delete(requestKey);
+        }
+
+        // The waiter may resolve with either a string ("accept" / "reject" /
+        // "deny") or an object { permissionDecision, permissionDecisionReason }.
+        // The latter is used by the AskUserQuestion answer flow so the user's
+        // chosen text is fed back to Claude.
+        if (decision && typeof decision === "object") {
+          const responseBody = {
+            permissionDecision:
+              decision.permissionDecision === "allow" ? "allow" : "deny",
+          };
+          if (typeof decision.permissionDecisionReason === "string" && decision.permissionDecisionReason) {
+            responseBody.permissionDecisionReason = decision.permissionDecisionReason;
+          }
+          return writeJson(res, 200, responseBody);
+        }
+
+        return writeJson(res, 200, {
+          permissionDecision: decision === "accept" ? "allow" : "deny",
+        });
+      }
+
       if (url.pathname === "/api/inbox" && req.method === "GET") {
         const session = requireApiSession(req, res, config, state);
         if (!session) {
@@ -10414,6 +11278,9 @@ function createNativeApprovalServer({ config, runtime, state }) {
         approval.resolving = true;
         try {
           await handleNativeApprovalDecision({ config, runtime, state, approval, decision });
+          if (approval.provider === "claude") {
+            activateClaudeDesktopIfMac(req);
+          }
           return writeJson(res, 200, { ok: true, decision });
         } catch (error) {
           approval.resolving = false;
@@ -10421,6 +11288,85 @@ function createNativeApprovalServer({ config, runtime, state }) {
         }
       }
 
+      const apiQuestionAnswerMatch = url.pathname.match(/^\/api\/items\/question\/([^/]+)\/answer$/u);
+      if (apiQuestionAnswerMatch && req.method === "POST") {
+        const session = requireMutatingApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+
+        const token = decodeURIComponent(apiQuestionAnswerMatch[1]);
+        const approval = runtime.nativeApprovalsByToken.get(token);
+        if (!approval) {
+          return writeJson(res, 404, { error: "question-not-found" });
+        }
+        if (approval.kind !== "question") {
+          return writeJson(res, 409, { error: "not-a-question" });
+        }
+        if (approval.resolved || approval.resolving) {
+          return writeJson(res, 409, { error: "question-already-handled" });
+        }
+
+        let payload;
+        try {
+          payload = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+
+        const answers = Array.isArray(payload?.answers) ? payload.answers : [];
+        const reasonText = formatClaudeQuestionAnswers(approval.questions, answers);
+        if (!reasonText) {
+          return writeJson(res, 400, { error: "no-answers" });
+        }
+
+        approval.resolving = true;
+        try {
+          if (approval.resolveClaudeWaiter) {
+            approval.resolveClaudeWaiter({
+              permissionDecision: "deny",
+              permissionDecisionReason: reasonText,
+            });
+          }
+          approval.resolved = true;
+          approval.resolving = false;
+          runtime.nativeApprovalsByToken.delete(approval.token);
+          runtime.nativeApprovalsByRequestKey.delete(approval.requestKey);
+
+          const stateChanged = recordActionHistoryItem({
+            config,
+            runtime,
+            state,
+            kind: "approval",
+            stableId: `approval:${approval.requestKey}:${Date.now()}`,
+            token: approval.token,
+            title: approval.title,
+            threadLabel: approval.threadLabel || "",
+            messageText: reasonText,
+            summary: t(config.defaultLocale, "server.message.questionAnswered", {
+              provider: providerDisplayName(config.defaultLocale, approval.provider),
+            }),
+            fileRefs: [],
+            diffText: "",
+            diffSource: "",
+            diffAvailable: false,
+            diffAddedLines: 0,
+            diffRemovedLines: 0,
+            outcome: "answered",
+            provider: approval.provider || "claude",
+          });
+          if (stateChanged) {
+            await saveState(config.stateFile, state);
+          }
+          console.log(`[claude-question-answer] ${approval.requestKey}`);
+          activateClaudeDesktopIfMac(req);
+          return writeJson(res, 200, { ok: true });
+        } catch (error) {
+          approval.resolving = false;
+          return writeJson(res, 500, { error: error.message });
+        }
+      }
+
       const apiPlanDecisionMatch = url.pathname.match(/^\/api\/items\/plan\/([^/]+)\/(implement|decline)$/u);
       if (apiPlanDecisionMatch && req.method === "POST") {
         const session = requireMutatingApiSession(req, res, config, state);
@@ -10698,7 +11644,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
                 title: userInputRequest.title,
                 body: userInputRequest.testRequest
                   ? `${t(config.defaultLocale, "server.message.choiceSubmittedTest")}\n\n${formatSubmittedTestAnswers(userInputRequest, userInputRequest.draftAnswers)}`
-                  : t(config.defaultLocale, "server.message.choiceSubmitted"),
+                  : t(config.defaultLocale, "server.message.choiceSubmitted", { provider: providerDisplayName(config.defaultLocale, "codex") }),
                 tone: "ok",
               })
             );
@@ -11211,6 +12157,28 @@ function writeJson(res, statusCode, body) {
   res.end(`${JSON.stringify(body)}\n`);
 }
 
+// Return focus to the Claude Desktop app when a Mac client just submitted a
+// plan / question / approval decision, so the user can resume in Claude
+// without manually switching apps. iOS / Android paired devices are skipped
+// (UA match). If Claude is not running, we do nothing — the AppleScript
+// `exists (process "Claude")` guard prevents an unwanted launch.
+function activateClaudeDesktopIfMac(req) {
+  try {
+    const ua = String(req?.headers?.["user-agent"] || "");
+    if (/iPhone|iPad|iPod|Android/iu.test(ua)) return;
+    if (!/Macintosh|Mac OS X/iu.test(ua)) return;
+    const script = `tell application "System Events"
+  if exists (processes where name is "Claude") then
+    tell application "Claude" to activate
+  end if
+end tell`;
+    const child = spawn("osascript", ["-e", script], { stdio: "ignore" });
+    child.unref();
+  } catch {
+    // Best effort.
+  }
+}
+
 function writeHtml(res, statusCode, html) {
   res.statusCode = statusCode;
   res.setHeader("Content-Type", "text/html; charset=utf-8");
@@ -11233,7 +12201,7 @@ function stopHttpServer(server) {
   });
 }
 
-function renderApprovalPage({ eyebrow, title, messageText, token, basePath, actions, locale = DEFAULT_LOCALE }) {
+function renderApprovalPage({ eyebrow, title, messageText, token, basePath, actions, locale = DEFAULT_LOCALE, provider = "codex" }) {
   const messageHtml = renderMessageHtml(messageText, `<p>${escapeHtml(t(locale, "detail.approvalRequested"))}</p>`);
   const actionsHtml = actions
     .map(
@@ -11338,7 +12306,7 @@ function renderApprovalPage({ eyebrow, title, messageText, token, basePath, acti
         <div class="message">
           ${messageHtml}
         </div>
-        <p class="hint">${escapeHtml(t(locale, "summary.approval"))}</p>
+        <p class="hint">${escapeHtml(t(locale, "summary.approval", { provider: providerDisplayName(locale, provider) }))}</p>
         <div class="actions">
           ${actionsHtml}
           <a class="button link" href="#" onclick="history.back(); return false;">${escapeHtml(t(locale, "common.back"))}</a>
@@ -11721,7 +12689,7 @@ function renderMessagePage({ eyebrow, title, messageText, locale = DEFAULT_LOCAL
 </html>`;
 }
 
-function renderStatusPage({ title, body, tone }) {
+function renderStatusPage({ title, body, tone, provider = "codex", locale = DEFAULT_LOCALE }) {
   return `<!doctype html>
 <html lang="en">
   <head>
@@ -11784,7 +12752,7 @@ function renderStatusPage({ title, body, tone }) {
   </head>
   <body>
     <section class="card">
-      <span class="chip">Codex</span>
+      <span class="chip">${escapeHtml(providerDisplayName(locale, provider))}</span>
       <h1>${escapeHtml(title)}</h1>
       <p>${escapeHtml(body)}</p>
       <p class="muted">このページは閉じて大丈夫です。</p>
@@ -11871,16 +12839,18 @@ function markdownMessageStyles() {
       }`;
 }
 
-function approvalDecisionMessage(decision, locale = config?.defaultLocale || DEFAULT_LOCALE) {
+function approvalDecisionMessage(decision, locale = config?.defaultLocale || DEFAULT_LOCALE, provider = "codex") {
+  const vars = { provider: providerDisplayName(locale, provider) };
   if (decision === "accept") {
-    return t(locale, "server.message.approvalAccepted");
+    return t(locale, "server.message.approvalAccepted", vars);
   }
-  return t(locale, "server.message.approvalRejected");
+  return t(locale, "server.message.approvalRejected", vars);
 }
 
-function planDecisionMessage(decision, locale = config?.defaultLocale || DEFAULT_LOCALE) {
+function planDecisionMessage(decision, locale = config?.defaultLocale || DEFAULT_LOCALE, provider = "codex") {
+  const vars = { provider: providerDisplayName(locale, provider) };
   if (decision === "implement") {
-    return t(locale, "server.message.planImplemented");
+    return t(locale, "server.message.planImplemented", vars);
   }
   return t(locale, "server.message.planDismissed");
 }
@@ -11896,14 +12866,15 @@ function decisionLabel(decision, locale = config?.defaultLocale || DEFAULT_LOCAL
   return decision === "accept" ? t(locale, "server.action.approve") : t(locale, "server.action.reject");
 }
 
-function approvalDecisionConfirm(decision, locale = config?.defaultLocale || DEFAULT_LOCALE) {
+function approvalDecisionConfirm(decision, locale = config?.defaultLocale || DEFAULT_LOCALE, provider = "codex") {
+  const vars = { provider: providerDisplayName(locale, provider) };
   if (decision === "implement") {
     return t(locale, "server.confirm.planImplement");
   }
   if (decision === "accept") {
-    return t(locale, "server.confirm.approve");
+    return t(locale, "server.confirm.approve", vars);
   }
-  return t(locale, "server.confirm.reject");
+  return t(locale, "server.confirm.reject", vars);
 }
 
 function resolvePlanDecisionAnswer(planRequest, decision) {
@@ -12162,6 +13133,7 @@ function buildConfig(cli) {
     pairingToken: process.env.PAIRING_TOKEN || "",
     pairingExpiresAtMs: numberEnv("PAIRING_EXPIRES_AT_MS", 0),
     sessionSecret: process.env.SESSION_SECRET || "",
+    claudeProjectsDir: resolvePath(process.env.CLAUDE_PROJECTS_DIR || path.join(os.homedir(), ".claude", "projects")),
   };
 }
 
@@ -12344,6 +13316,7 @@ async function loadState(stateFile) {
       historyFileSourceFile: cleanText(parsed.historyFileSourceFile ?? ""),
       pairingConsumedAt: Number(parsed.pairingConsumedAt) || 0,
       pairingConsumedCredential: cleanText(parsed.pairingConsumedCredential ?? ""),
+      claudeAwayMode: parsed.claudeAwayMode === true,
     };
   } catch {
     return {
@@ -12370,10 +13343,30 @@ async function loadState(stateFile) {
       historyFileSourceFile: "",
       pairingConsumedAt: 0,
       pairingConsumedCredential: "",
+      claudeAwayMode: false,
     };
   }
 }
 
+function claudeAwayModeSentinelPath(config) {
+  const dir = config?.configDir || path.join(os.homedir(), ".viveworker");
+  return path.join(dir, "claude-away-mode");
+}
+
+async function syncClaudeAwayModeSentinel(config, enabled) {
+  const sentinel = claudeAwayModeSentinelPath(config);
+  try {
+    if (enabled) {
+      await fs.mkdir(path.dirname(sentinel), { recursive: true });
+      await fs.writeFile(sentinel, "on\n", "utf8");
+    } else {
+      await fs.unlink(sentinel).catch(() => {});
+    }
+  } catch (error) {
+    console.error(`[claude-away-mode-sentinel-error] ${error.message}`);
+  }
+}
+
 async function saveState(stateFile, state) {
   const output = JSON.stringify(state, null, 2);
   await fs.mkdir(path.dirname(stateFile), { recursive: true });
@@ -12772,7 +13765,7 @@ function getThreadName(sessionIndex, rolloutThreadLabels, threadId, cwd, filePat
 }
 
 function describeContext({ threadName }) {
-  const threadLabel = truncate(cleanText(threadName || ""), 90) || "Codex task";
+  const threadLabel = truncate(cleanText(threadName || ""), 90) || t(DEFAULT_LOCALE, "server.fallback.codexTask", { provider: providerDisplayName(DEFAULT_LOCALE, "codex") });
   return { threadLabel };
 }
 
@@ -12855,10 +13848,11 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
       if (!threadId) {
         return entry;
       }
-      const nativeThreadLabel = getNativeThreadLabel({
+      const claudeTitle = runtime.claudeSessionTitles.get(threadId) || "";
+      const nativeThreadLabel = claudeTitle || getNativeThreadLabel({
         runtime,
         conversationId: threadId,
-        cwd: "",
+        cwd: cleanText(entry.cwd || ""),
       });
       const threadLabel = preferTitleOnlyJsonThreadLabel(nativeThreadLabel, threadId, entry.messageText, entry.summary);
       const title = threadLabel || kindTitle(config.defaultLocale, entry.kind);
@@ -12890,10 +13884,11 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
       if (!threadId) {
         return entry;
       }
-      const nativeThreadLabel = getNativeThreadLabel({
+      const claudeTitle = runtime.claudeSessionTitles.get(threadId) || "";
+      const nativeThreadLabel = claudeTitle || getNativeThreadLabel({
         runtime,
         conversationId: threadId,
-        cwd: "",
+        cwd: cleanText(entry.cwd || ""),
       });
       const threadLabel = preferTitleOnlyJsonThreadLabel(nativeThreadLabel, threadId, entry.messageText, entry.summary);
       const title = threadLabel || kindTitle(config.defaultLocale, entry.kind);
@@ -13301,7 +14296,7 @@ async function main() {
 
   console.log(
     [
-      "Codex ntfy bridge",
+      "viveworker bridge",
       `dryRun=${config.dryRun}`,
       `once=${config.once}`,
       `codexHome=${config.codexHome}`,