viveworker 0.4.5 → 0.4.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.4.5",
+  "version": "0.4.7",
   "description": "Local mobile companion for Codex Desktop and Claude Desktop — approvals, code review, Moltbook drafts, and A2A (Agent-to-Agent) task relay on your LAN.",
   "author": "Yuta Hoshino <hoshino.lireneo@gmail.com>",
   "license": "MIT",

package/scripts/a2a-relay-client.mjs

@@ -29,6 +29,8 @@ const A2A_ENV_FILE = path.join(os.homedir(), ".viveworker", "a2a.env");
 
 let pollTimer = null;
 let isPolling = false;
+let lastPollOk = false;
+let lastPollAtMs = 0;
 
 // ---------------------------------------------------------------------------
 // Registration
@@ -164,6 +166,17 @@ export function stopRelayPolling() {
   console.log("[a2a-relay] Polling stopped");
 }
 
+/**
+ * Return current relay connection status for the settings UI.
+ */
+export function getRelayStatus() {
+  return {
+    polling: pollTimer !== null,
+    lastPollOk,
+    lastPollAtMs,
+  };
+}
+
 /**
  * Single poll cycle: fetch pending tasks from the relay and ingest them.
  */
@@ -186,9 +199,14 @@ async function pollOnce({ config, runtime, state, helpers }) {
     if (!res.ok) {
       const text = await res.text().catch(() => "");
       console.error(`[a2a-relay] Poll failed: HTTP ${res.status} ${text.slice(0, 200)}`);
+      lastPollOk = false;
+      lastPollAtMs = Date.now();
       return;
     }
 
+    lastPollOk = true;
+    lastPollAtMs = Date.now();
+
     const data = await res.json();
     const tasks = data.tasks || [];
 

package/scripts/viveworker-bridge.mjs

@@ -17,7 +17,7 @@ import { DEFAULT_LOCALE, SUPPORTED_LOCALES, localeDisplayName, normalizeLocale,
 import { generatePairingCredentials, shouldRotatePairing, upsertEnvText } from "./lib/pairing.mjs";
 import { renderMarkdownHtml } from "./lib/markdown-render.mjs";
 import { buildAgentCard, handleA2ARequest, resolveA2ATaskDecision, completeA2ATask, failA2ATask } from "./a2a-handler.mjs";
-import { registerWithRelay, startRelayPolling, stopRelayPolling, postRelayResult } from "./a2a-relay-client.mjs";
+import { registerWithRelay, startRelayPolling, stopRelayPolling, postRelayResult, getRelayStatus } from "./a2a-relay-client.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -28,7 +28,7 @@ const sessionCookieName = "viveworker_session";
 const deviceCookieName = "viveworker_device";
 const historyKinds = new Set(["completion", "plan_ready", "approval", "plan", "choice", "info"]);
 const timelineMessageKinds = new Set(["user_message", "assistant_commentary", "assistant_final"]);
-const timelineKinds = new Set([...timelineMessageKinds, "approval", "plan", "choice", "completion", "plan_ready", "file_event", "moltbook_reply", "moltbook_draft"]);
+const timelineKinds = new Set([...timelineMessageKinds, "approval", "plan", "choice", "completion", "plan_ready", "file_event", "moltbook_reply", "moltbook_draft", "thread_share"]);
 const SQLITE_COMPLETION_BATCH_SIZE = 200;
 const DEFAULT_DEVICE_TRUST_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const MAX_PAIRED_DEVICES = 200;
@@ -85,6 +85,8 @@ const runtime = {
   moltbookItemsByToken: new Map(),
   moltbookDraftsByToken: new Map(),
   a2aTasksByToken: new Map(),
+  threadSharesByToken: new Map(),
+  threadRegistry: new Map(),
   planDetailsByToken: new Map(),
   recentHistoryItems: [],
   recentTimelineEntries: [],
@@ -94,6 +96,7 @@ const runtime = {
   stopping: false,
 };
 const state = await loadState(config.stateFile);
+runtime.threadRegistry = await loadThreadRegistry(config.threadRegistryFile);
 await syncClaudeAwayModeSentinel(config, state.claudeAwayMode === true);
 const migratedPairedDevicesStateChanged = migratePairedDevicesState({ config, state });
 const restoredPendingPlanStateChanged = restorePendingPlanRequests({ config, runtime, state });
@@ -6970,6 +6973,20 @@ class NativeIpcClient {
 
     this.runtime.threadStates.set(normalized.conversationId, nextState);
 
+    // Register / update in the persistent thread registry.
+    const regLabel = extractThreadLabelFromState(nextState)
+      || getThreadName(this.runtime.sessionIndex, this.runtime.rolloutThreadLabels, normalized.conversationId, nextState.cwd || "", "");
+    if (registerThread(this.runtime, {
+      id: normalized.conversationId,
+      label: regLabel,
+      tool: "codex",
+      cwd: nextState.cwd || "",
+      lastSeenAtMs: Date.now(),
+      active: true,
+    })) {
+      saveThreadRegistry(this.config.threadRegistryFile, this.runtime.threadRegistry).catch(() => {});
+    }
+
     await this.onThreadStateChanged({
       conversationId: normalized.conversationId,
       previousRequests,
@@ -9067,6 +9084,24 @@ function buildPendingInboxItems(runtime, state, config, locale) {
     });
   }
 
+  for (const share of runtime.threadSharesByToken.values()) {
+    if (share.decision) continue;
+    const title = share.sourceLabel
+      ? `${share.sourceLabel} → ${share.targetLabel || share.targetTool}`
+      : `→ ${share.targetLabel || share.targetTool}`;
+    items.push({
+      kind: "thread_share",
+      token: share.token,
+      threadId: "thread_share",
+      threadLabel: "Thread Share",
+      title,
+      summary: String(share.content || "").slice(0, 160),
+      primaryLabel: t(locale, "server.action.review"),
+      createdAtMs: Number(share.createdAtMs) || now,
+      provider: "viveworker",
+    });
+  }
+
   // Moltbook reply items intentionally do not appear in the unhandled list.
   // Reply drafting is delegated to Codex/Claude Desktop via the
   // `viveworker moltbook` CLI, so they live in the timeline only.
@@ -10611,6 +10646,42 @@ async function buildApiItemDetail({ config, runtime, state, kind, token, locale
     };
   }
 
+  if (kind === "thread_share") {
+    const share = runtime.threadSharesByToken.get(token);
+    const entry = share
+      ? null
+      : runtime.recentTimelineEntries.find((e) => e.kind === "thread_share" && e.token === token);
+    const source = share || entry;
+    if (!source) return null;
+    const content = share ? share.content : entry.messageText || entry.summary || "";
+    const messageHtml = escapeHtml(content)
+      .split("\n")
+      .map((line) => `<p>${line}</p>`)
+      .join("");
+    return {
+      kind: "thread_share",
+      token,
+      threadId: "thread_share",
+      threadLabel: "Thread Share",
+      title: source.title || "Thread Share",
+      summary: source.summary || cleanText(content).slice(0, 160),
+      messageHtml,
+      provider: "viveworker",
+      shareContent: content,
+      shareType: share?.shareType || entry?.shareType || "message",
+      sourceTool: share?.sourceTool || entry?.sourceTool || "",
+      sourceLabel: share?.sourceLabel || entry?.sourceLabel || "",
+      targetTool: share?.targetTool || entry?.targetTool || "",
+      targetLabel: share?.targetLabel || entry?.targetLabel || "",
+      targetConversationId: share?.targetConversationId || entry?.targetConversationId || "",
+      contextFiles: share?.contextFiles || entry?.contextFiles || [],
+      createdAtMs: source.createdAtMs || Date.now(),
+      readOnly: !share || Boolean(share?.decision),
+      actions: [],
+      threadShareEnabled: Boolean(share) && !share.decision,
+    };
+  }
+
   const historyItem = historyItemByToken(runtime, kind, token);
   return historyItem ? buildHistoryDetail(historyItem, locale, runtime) : null;
 }
@@ -11128,6 +11199,339 @@ function createNativeApprovalServer({ config, runtime, state }) {
         }
       }
 
+      // A2A relay status for the settings UI.
+      if (url.pathname === "/api/a2a/relay-status" && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) return;
+        const relayEnabled = Boolean(config.a2aRelayUrl && config.a2aRelayUserId);
+        if (!relayEnabled) {
+          return writeJson(res, 200, { enabled: false });
+        }
+        const relay = getRelayStatus();
+        return writeJson(res, 200, {
+          enabled: true,
+          connected: relay.polling && relay.lastPollOk,
+          polling: relay.polling,
+          lastPollOk: relay.lastPollOk,
+          lastPollAtMs: relay.lastPollAtMs,
+          userId: config.a2aRelayUserId,
+          relayUrl: config.a2aRelayUrl,
+          apiKeyConfigured: Boolean(config.a2aApiKey),
+        });
+      }
+
+      // ─── Thread sharing ──────────────────────────────────────────────
+
+      function buildThreadShareContent(shareType, body) {
+        if (shareType === "plan_review") {
+          const sections = [];
+          if (body.context) sections.push(`## Context\n${body.context}`);
+          if (body.plan) sections.push(`## Plan\n${body.plan}`);
+          if (Array.isArray(body.files) && body.files.length) {
+            sections.push(`## Relevant files\n${body.files.map((f) => `- ${f}`).join("\n")}`);
+          }
+          sections.push(`## Instruction\n${body.instruction || "共有されたプランの内容を把握し、実現可能性や改善点を検討してください。"}`);
+          return sections.join("\n\n");
+        }
+        if (shareType === "handoff") {
+          const sections = [];
+          if (body.summary) sections.push(`## Summary\n${body.summary}`);
+          if (Array.isArray(body.completed) && body.completed.length) {
+            sections.push(`## Completed\n${body.completed.map((t) => `- ${t}`).join("\n")}`);
+          }
+          if (Array.isArray(body.remaining) && body.remaining.length) {
+            sections.push(`## Remaining\n${body.remaining.map((t) => `- ${t}`).join("\n")}`);
+          }
+          if (Array.isArray(body.decisions) && body.decisions.length) {
+            sections.push(`## Key decisions\n${body.decisions.map((d) => `- ${d}`).join("\n")}`);
+          }
+          if (Array.isArray(body.modifiedFiles) && body.modifiedFiles.length) {
+            sections.push(`## Modified files\n${body.modifiedFiles.map((f) => `- ${f}`).join("\n")}`);
+          }
+          sections.push(`## Instruction\n${body.instruction || "これまでの作業内容と経緯を把握した上で、次に何をすべきか検討してください。"}`);
+          return sections.join("\n\n");
+        }
+        // Default: message type — use raw content.
+        return cleanText(body?.content || "");
+      }
+
+      // List known threads (active + registry) for the share target picker.
+      if (url.pathname === "/api/threads/list" && req.method === "GET") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+        if (!hookAuth) { const session = requireApiSession(req, res, config, state); if (!session) return; }
+        const codexConnected = Boolean(runtime.ipcClient?.clientId);
+        const activeIds = new Set();
+        const threads = [];
+        // Active Codex threads (from IPC).
+        for (const [conversationId, threadState] of runtime.threadStates) {
+          activeIds.add(conversationId);
+          const label = getThreadName(
+            runtime.sessionIndex,
+            runtime.rolloutThreadLabels,
+            conversationId,
+            cleanText(threadState?.cwd || ""),
+            ""
+          );
+          threads.push({
+            conversationId,
+            label: label || conversationId.slice(0, 8),
+            tool: "codex",
+            cwd: cleanText(threadState?.cwd || ""),
+            hasOwner: runtime.threadOwnerClientIds.has(conversationId),
+            active: true,
+          });
+        }
+        // Registry entries not already covered by active threads.
+        for (const entry of runtime.threadRegistry.values()) {
+          if (!activeIds.has(entry.id)) {
+            threads.push({
+              conversationId: entry.id,
+              label: entry.label || entry.id.slice(0, 8),
+              tool: entry.tool || "codex",
+              cwd: entry.cwd || "",
+              hasOwner: false,
+              active: false,
+              lastSeenAtMs: entry.lastSeenAtMs || 0,
+            });
+          }
+        }
+        return writeJson(res, 200, { threads, codexConnected });
+      }
+
+      // Submit a thread share request (creates an approval item on the phone).
+      if (url.pathname === "/api/threads/share" && req.method === "POST") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        const hookAuth = config.sessionSecret && hookSecret === config.sessionSecret;
+        if (!hookAuth) { const session = requireApiSession(req, res, config, state); if (!session) return; }
+        const body = await parseJsonBody(req);
+        const shareType = cleanText(body?.shareType || "message");
+        const sourceTool = cleanText(body?.sourceTool || "");
+        const sourceLabel = cleanText(body?.sourceLabel || "");
+        const targetConversationId = cleanText(body?.targetConversationId || "");
+        let targetTool = cleanText(body?.targetTool || "");
+        let targetCwd = cleanText(body?.targetCwd || "");
+        const contextFiles = Array.isArray(body?.contextFiles)
+          ? body.contextFiles.map((f) => cleanText(String(f))).filter(Boolean)
+          : [];
+
+        // Auto-resolve targetTool and targetCwd from registry if not provided.
+        if (targetConversationId) {
+          const regEntry = runtime.threadRegistry.get(targetConversationId);
+          if (regEntry) {
+            if (!targetTool) targetTool = regEntry.tool || "";
+            if (!targetCwd) targetCwd = regEntry.cwd || "";
+          }
+        }
+
+        // Build content from structured fields depending on shareType.
+        const content = buildThreadShareContent(shareType, body);
+        if (!content && contextFiles.length === 0) {
+          return writeJson(res, 400, { error: "missing-content" });
+        }
+        if (!targetConversationId && !targetTool) {
+          return writeJson(res, 400, { error: "missing-target" });
+        }
+        const shareId = crypto.randomUUID();
+        const token = historyToken(`thread_share:${shareId}`);
+        const targetLabel = targetConversationId
+          ? (getThreadName(runtime.sessionIndex, runtime.rolloutThreadLabels, targetConversationId, runtime.threadStates.get(targetConversationId)?.cwd || "", "") || runtime.threadRegistry.get(targetConversationId)?.label || "")
+          : targetTool;
+        const share = {
+          token,
+          shareId,
+          shareType,
+          content: content || "",
+          contextFiles,
+          sourceTool,
+          sourceLabel,
+          targetConversationId,
+          targetTool: targetTool || "codex",
+          targetCwd,
+          targetLabel,
+          createdAtMs: Date.now(),
+          decision: null,
+          decisionWaiters: [],
+        };
+        runtime.threadSharesByToken.set(token, share);
+        try {
+          const title = sourceLabel
+            ? `${sourceLabel} → ${targetLabel || targetTool}`
+            : `→ ${targetLabel || targetTool}`;
+          recordTimelineEntry({
+            config, runtime, state,
+            entry: {
+              stableId: `thread_share:${shareId}`,
+              token,
+              kind: "thread_share",
+              threadId: "thread_share",
+              threadLabel: "Thread Share",
+              title,
+              summary: String(content).slice(0, 160),
+              messageText: content,
+              createdAtMs: share.createdAtMs,
+              readOnly: false,
+              provider: "viveworker",
+            },
+          });
+          await saveState(config.stateFile, state);
+        } catch (error) {
+          console.error(`[thread-share-timeline] ${error.message}`);
+        }
+        try {
+          await deliverWebPushItem({
+            config, state,
+            kind: "thread_share",
+            token,
+            stableId: `thread_share:${shareId}`,
+            title: `Thread Share: ${sourceLabel || sourceTool || "agent"} → ${targetLabel || targetTool}`,
+            body: String(content).slice(0, 160),
+          });
+        } catch (error) {
+          console.error(`[thread-share-push] ${error.message}`);
+        }
+        return writeJson(res, 200, { ok: true, token, shareId });
+      }
+
+      // Decision endpoint for thread share (approve / deny from phone).
+      const threadShareDecisionMatch = url.pathname.match(/^\/api\/threads\/share\/([^/]+)\/decision$/);
+      if (threadShareDecisionMatch && req.method === "POST") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) return;
+        const token = cleanText(threadShareDecisionMatch[1]);
+        const share = runtime.threadSharesByToken.get(token);
+        if (!share) {
+          return writeJson(res, 404, { error: "not-found" });
+        }
+        if (share.decision) {
+          return writeJson(res, 200, { ok: true, decision: share.decision });
+        }
+        const body = await parseJsonBody(req);
+        const decision = cleanText(body?.decision || "");
+        const editedContent = typeof body?.editedContent === "string" ? body.editedContent : null;
+        if (decision !== "approve" && decision !== "deny") {
+          return writeJson(res, 400, { error: "invalid-decision" });
+        }
+        share.decision = decision;
+        if (editedContent !== null) {
+          share.content = editedContent;
+        }
+
+        // Deliver the shared content to the target.
+        let deliveryStatus = "delivered";
+        if (decision === "approve") {
+          const prefix = share.sourceLabel ? `[Shared from ${share.sourceLabel}]\n\n` : "[Shared from another thread]\n\n";
+          // Append context file references if present.
+          if (share.contextFiles && share.contextFiles.length > 0) {
+            const fileList = share.contextFiles.map((f) => `- ${f}`).join("\n");
+            share.content = (share.content ? share.content + "\n\n" : "")
+              + `## Context files\n\nRead the following files for full conversation context:\n${fileList}`;
+          }
+          let injectedViaIpc = false;
+
+          // Try Codex IPC injection if targeting a specific thread.
+          if (share.targetConversationId && runtime.ipcClient?.clientId) {
+            const ownerClientId = runtime.threadOwnerClientIds.get(share.targetConversationId) ?? null;
+            const turnStartParams = { input: buildTurnInput(prefix + share.content) };
+            // Try direct first, then fall back to thread-follower.
+            for (const transport of ["direct", "follower"]) {
+              try {
+                if (transport === "direct" && ownerClientId) {
+                  await runtime.ipcClient.startTurnDirect(share.targetConversationId, turnStartParams, ownerClientId);
+                } else {
+                  await runtime.ipcClient.startTurn(share.targetConversationId, turnStartParams, ownerClientId);
+                }
+                injectedViaIpc = true;
+                console.log(`[thread-share] Delivered to Codex thread ${share.targetConversationId} via ${transport}`);
+                break;
+              } catch (error) {
+                console.error(`[thread-share-ipc-${transport}] ${error.message}`);
+              }
+            }
+          }
+
+          // Write to file inbox (always for claude-code targets, fallback for failed Codex delivery).
+          if (!injectedViaIpc) {
+            try {
+              const inboxDir = path.join(os.homedir(), ".viveworker", "thread-inbox");
+              await fs.mkdir(inboxDir, { recursive: true });
+              const inboxFile = path.join(inboxDir, `${share.shareId}.json`);
+              await fs.writeFile(inboxFile, JSON.stringify({
+                shareId: share.shareId,
+                content: share.content,
+                contextFiles: share.contextFiles || [],
+                targetCwd: share.targetCwd || "",
+                sourceTool: share.sourceTool,
+                sourceLabel: share.sourceLabel,
+                targetTool: share.targetTool,
+                createdAtMs: share.createdAtMs,
+                deliveredAtMs: Date.now(),
+              }, null, 2), "utf8");
+              console.log(`[thread-share] Written to inbox: ${inboxFile}`);
+            } catch (error) {
+              console.error(`[thread-share-inbox-write] ${error.message}`);
+            }
+
+            // If the user intended Codex but it wasn't reachable, notify.
+            if (share.targetConversationId && share.targetTool !== "claude-code") {
+              deliveryStatus = "inbox_fallback";
+              try {
+                await deliverWebPushItem({
+                  config, state,
+                  kind: "thread_share",
+                  token: share.token,
+                  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.`,
+                });
+              } catch (error) {
+                console.error(`[thread-share-fallback-push] ${error.message}`);
+              }
+            }
+          }
+        }
+
+        // Wake any long-poll waiters.
+        for (const waiter of share.decisionWaiters) {
+          waiter({ decision: share.decision, content: share.content });
+        }
+        share.decisionWaiters = [];
+        return writeJson(res, 200, { ok: true, decision: share.decision });
+      }
+
+      // Long-poll: wait for a thread share decision (used by the CLI or hook).
+      const threadSharePollMatch = url.pathname.match(/^\/api\/threads\/share\/([^/]+)\/poll$/);
+      if (threadSharePollMatch && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) return;
+        const token = cleanText(threadSharePollMatch[1]);
+        const share = runtime.threadSharesByToken.get(token);
+        if (!share) {
+          return writeJson(res, 404, { error: "not-found" });
+        }
+        if (share.decision) {
+          return writeJson(res, 200, { decision: share.decision, content: share.content });
+        }
+        const timeoutMs = Math.min(Number(url.searchParams.get("timeout")) || 120_000, 300_000);
+        await new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            const idx = share.decisionWaiters.indexOf(done);
+            if (idx >= 0) share.decisionWaiters.splice(idx, 1);
+            resolve();
+          }, timeoutMs);
+          timer.unref?.();
+          function done(result) {
+            clearTimeout(timer);
+            resolve(result);
+          }
+          share.decisionWaiters.push(done);
+        });
+        if (share.decision) {
+          return writeJson(res, 200, { decision: share.decision, content: share.content });
+        }
+        return writeJson(res, 200, { decision: null, timeout: true });
+      }
+
       // Activity summary for compose (original post) drafting.
       // Supports ?slot=morning|noon|evening and ?date=YYYY-MM-DD for
       // time-slot-based compose.  Defaults to full-day today.
@@ -11411,6 +11815,27 @@ function createNativeApprovalServer({ config, runtime, state }) {
           return writeJson(res, 200, {});
         }
 
+        // Register Claude Code thread in persistent registry on every event.
+        {
+          const regThreadId = String(body.threadId || body.sessionId || "");
+          const regCwd = String(body.cwd || "");
+          if (regThreadId) {
+            const regLabel = runtime.claudeSessionTitles.get(regThreadId)
+              || (regCwd ? path.basename(regCwd) : "")
+              || regThreadId.slice(0, 40);
+            if (registerThread(runtime, {
+              id: regThreadId,
+              label: regLabel,
+              tool: "claude-code",
+              cwd: regCwd,
+              lastSeenAtMs: Date.now(),
+              active: eventType !== "Stop" && eventType !== "SessionEnd",
+            })) {
+              saveThreadRegistry(config.threadRegistryFile, runtime.threadRegistry).catch(() => {});
+            }
+          }
+        }
+
         if (eventType !== "approval_request") {
           // Non-approval events (Notification, Stop, etc.) — acknowledge immediately
           return writeJson(res, 200, {});
@@ -13807,6 +14232,7 @@ function buildConfig(cli) {
     historyFile: resolvePath(process.env.HISTORY_FILE || path.join(codexHome, "history.jsonl")),
     codexLogsDbFile: resolvePath(process.env.CODEX_LOGS_DB_FILE || ""),
     stateFile,
+    threadRegistryFile: resolvePath(process.env.THREAD_REGISTRY_FILE || path.join(os.homedir(), ".viveworker", "thread-registry.json")),
     replyUploadsDir: resolvePath(process.env.REPLY_UPLOADS_DIR || path.join(path.dirname(stateFile), "uploads")),
     timelineAttachmentsDir: resolvePath(
       process.env.TIMELINE_ATTACHMENTS_DIR || path.join(path.dirname(stateFile), "timeline-attachments")
@@ -14119,6 +14545,59 @@ async function saveState(stateFile, state) {
   await fs.writeFile(stateFile, `${output}\n`, "utf8");
 }
 
+// ---------------------------------------------------------------------------
+// Thread registry — persistent record of all known threads (survives restarts)
+// ---------------------------------------------------------------------------
+
+async function loadThreadRegistry(filePath) {
+  const registry = new Map();
+  try {
+    const raw = await fs.readFile(filePath, "utf8");
+    const arr = JSON.parse(raw);
+    if (Array.isArray(arr)) {
+      for (const entry of arr) {
+        if (entry && entry.id) {
+          registry.set(entry.id, entry);
+        }
+      }
+    }
+  } catch {
+    // Missing or corrupt file — start with empty registry.
+  }
+  return registry;
+}
+
+async function saveThreadRegistry(filePath, registry) {
+  const arr = [...registry.values()].sort((a, b) => (b.lastSeenAtMs || 0) - (a.lastSeenAtMs || 0));
+  await fs.mkdir(path.dirname(filePath), { recursive: true });
+  await fs.writeFile(filePath, JSON.stringify(arr, null, 2) + "\n", "utf8");
+}
+
+/** Upsert a thread in the registry. Returns true if something changed. */
+function registerThread(runtime, entry) {
+  const existing = runtime.threadRegistry.get(entry.id);
+  const merged = {
+    id: entry.id,
+    label: entry.label || existing?.label || "",
+    tool: entry.tool || existing?.tool || "codex",
+    cwd: entry.cwd || existing?.cwd || "",
+    lastSeenAtMs: Math.max(entry.lastSeenAtMs || Date.now(), existing?.lastSeenAtMs || 0),
+    active: entry.active !== undefined ? entry.active : (existing?.active ?? true),
+  };
+  const changed = !existing
+    || existing.label !== merged.label
+    || existing.tool !== merged.tool
+    || existing.cwd !== merged.cwd
+    || existing.active !== merged.active
+    || existing.lastSeenAtMs !== merged.lastSeenAtMs;
+  if (changed) {
+    runtime.threadRegistry.set(entry.id, merged);
+  }
+  return changed;
+}
+
+// ---------------------------------------------------------------------------
+
 async function loadSessionIndex(filePath) {
   const result = new Map();
   try {

package/scripts/viveworker-claude-hook.mjs

@@ -107,8 +107,11 @@ switch (hookEventName) {
   case "PostToolUseFailure":
     await handlePostToolUse();
     break;
+  case "UserPromptSubmit":
+    await handleUserPromptSubmit();
+    break;
   default:
-    // Notification, Stop, UserPromptSubmit, SessionEnd
+    // Notification, Stop, SessionEnd
     await postEvent(hookEventName, { sessionId, toolName, cwd }, DEFAULT_EVENT_TIMEOUT_MS);
     break;
 }
@@ -399,6 +402,76 @@ async function handlePostToolUse() {
   );
 }
 
+// ---------------------------------------------------------------------------
+// UserPromptSubmit — thread inbox auto-read
+// ---------------------------------------------------------------------------
+
+async function handleUserPromptSubmit() {
+  // Check ~/.viveworker/thread-inbox/ for pending shared content from other
+  // AI tool sessions. If files are found, inject their content as additional
+  // context so the assistant sees them automatically.
+  //
+  // Targeting: if an inbox file has a `targetCwd` field, only consume it when
+  // the current session's cwd starts with that path (project match). Files
+  // without targetCwd are consumed by any session.
+  const inboxDir = path.join(os.homedir(), ".viveworker", "thread-inbox");
+  let inboxFiles = [];
+  try {
+    const entries = await fs.readdir(inboxDir);
+    inboxFiles = entries.filter((e) => e.endsWith(".json"));
+  } catch {
+    // Inbox dir doesn't exist or is unreadable — nothing to inject.
+  }
+
+  if (inboxFiles.length > 0) {
+    const parts = [];
+    for (const file of inboxFiles) {
+      const filePath = path.join(inboxDir, file);
+      try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const share = JSON.parse(raw);
+        // Skip files targeted at a different project.
+        if (share.targetCwd && !cwd.startsWith(share.targetCwd)) {
+          continue;
+        }
+        const sourceLabel = share.sourceLabel || share.sourceTool || "another session";
+        const header = `[Shared from ${sourceLabel}]`;
+        let body = share.content || "";
+        // Append context file references if the content doesn't already include them.
+        const ctxFiles = Array.isArray(share.contextFiles) ? share.contextFiles.filter(Boolean) : [];
+        if (ctxFiles.length > 0 && !body.includes("Context files")) {
+          const fileList = ctxFiles.map((f) => `- ${f}`).join("\n");
+          body += `\n\n## Context files\n\nRead the following files for full conversation context:\n${fileList}`;
+        }
+        parts.push(`${header}\n\n${body}`);
+        // Mark as consumed by removing the file.
+        await fs.unlink(filePath);
+      } catch {
+        // Skip malformed or unreadable files.
+      }
+    }
+
+    if (parts.length > 0) {
+      // Cap at 10,000 chars (Claude Code hook output limit).
+      let combined = parts.join("\n\n---\n\n");
+      if (combined.length > 9800) {
+        combined = combined.slice(0, 9800) + "\n\n… (truncated)";
+      }
+      process.stdout.write(
+        JSON.stringify({
+          hookSpecificOutput: {
+            hookEventName: "UserPromptSubmit",
+            additionalContext: combined,
+          },
+        }) + "\n"
+      );
+    }
+  }
+
+  // Forward event to bridge as usual.
+  await postEvent("UserPromptSubmit", { sessionId, toolName, cwd }, DEFAULT_EVENT_TIMEOUT_MS);
+}
+
 // ---------------------------------------------------------------------------
 // Diff computation
 // ---------------------------------------------------------------------------

package/scripts/viveworker.mjs

@@ -82,6 +82,9 @@ async function main(cliOptions) {
     case "doctor":
       await runDoctor(cliOptions);
       return;
+    case "update":
+      await runUpdate(cliOptions);
+      return;
     case "help":
     default:
       printHelp();
@@ -846,6 +849,67 @@ async function runDoctor(cliOptions) {
   }
 }
 
+async function runUpdate(cliOptions) {
+  const locale = await resolveCliLocale(cliOptions);
+  const progress = createCliProgressReporter(locale);
+
+  // 1. Check current vs latest version
+  progress.update("cli.update.progress.checkVersion");
+  const pkg = JSON.parse(await fs.readFile(path.join(packageRoot, "package.json"), "utf8"));
+  const currentVersion = pkg.version;
+  const { stdout: latestRaw } = await execCommand(["npm", "view", "viveworker", "version"], { ignoreError: true });
+  const latestVersion = (latestRaw || "").trim();
+
+  if (!latestVersion) {
+    progress.done("cli.update.checkFailed");
+    return;
+  }
+
+  if (currentVersion === latestVersion) {
+    progress.done("cli.update.alreadyLatest", { version: currentVersion });
+    return;
+  }
+
+  console.log(t(locale, "cli.update.versionInfo", { current: currentVersion, latest: latestVersion }));
+
+  // 2. Clear npx cache and re-fetch
+  progress.update("cli.update.progress.install");
+  const npxCacheResult = await execCommand(["npx", "--yes", "viveworker@latest", "--version"], { ignoreError: true });
+  if (!npxCacheResult.ok) {
+    // Fallback: try global install
+    await execCommand(["npm", "install", "-g", "viveworker@latest"], { ignoreError: true });
+  }
+
+  // 3. Restart bridge
+  const launchAgentPath = resolvePath(cliOptions.launchAgentPath || defaultLaunchAgentPath);
+  if (await fileExists(launchAgentPath)) {
+    progress.update("cli.update.progress.restartBridge");
+    await execCommand(["launchctl", "bootout", `gui/${process.getuid()}`, launchAgentPath], { ignoreError: true });
+    await execCommand(["launchctl", "bootstrap", `gui/${process.getuid()}`, launchAgentPath], { ignoreError: true });
+    await execCommand(["launchctl", "kickstart", "-k", `gui/${process.getuid()}/${defaultLabel}`], { ignoreError: true });
+  }
+
+  // 4. Restart moltbook-watcher if present
+  const watcherLabel = "com.viveworker.moltbook-watcher";
+  const watcherPlistPath = path.join(os.homedir(), "Library", "LaunchAgents", `${watcherLabel}.plist`);
+  if (await fileExists(watcherPlistPath)) {
+    progress.update("cli.update.progress.restartWatcher");
+    await execCommand(["launchctl", "bootout", `gui/${process.getuid()}`, watcherPlistPath], { ignoreError: true });
+    await execCommand(["launchctl", "bootstrap", `gui/${process.getuid()}`, watcherPlistPath], { ignoreError: true });
+  }
+
+  // 5. Restart moltbook-scout if present
+  const scoutLabel = "com.viveworker.moltbook-scout";
+  const scoutPlistPath = path.join(os.homedir(), "Library", "LaunchAgents", `${scoutLabel}.plist`);
+  if (await fileExists(scoutPlistPath)) {
+    progress.update("cli.update.progress.restartScout");
+    await execCommand(["launchctl", "bootout", `gui/${process.getuid()}`, scoutPlistPath], { ignoreError: true });
+    await execCommand(["launchctl", "bootstrap", `gui/${process.getuid()}`, scoutPlistPath], { ignoreError: true });
+  }
+
+  progress.done("cli.update.done", { version: latestVersion });
+}
+
 function parseArgs(argv) {
   const parsed = {
     command: "help",
@@ -1019,6 +1083,7 @@ ${t(locale, "cli.help.commands")}
   ${t(locale, "cli.help.stop")}
   ${t(locale, "cli.help.status")}
   ${t(locale, "cli.help.doctor")}
+  ${t(locale, "cli.help.update")}
 
 ${t(locale, "cli.help.commonOptions")}
   --port <n>

package/web/app.js

@@ -48,6 +48,7 @@ const state = {
   pairNotice: "",
   pushStatus: null,
   moltbookScoutStatus: null,
+  a2aRelayStatus: null,
   pushNotice: "",
   pushError: "",
   deviceNotice: "",
@@ -214,6 +215,7 @@ async function refreshAuthenticatedState() {
   await refreshDevices();
   await refreshPushStatus();
   await fetchMoltbookScoutStatus();
+  await fetchA2aRelayStatus();
   ensureCurrentSelection();
 }
 
@@ -331,6 +333,18 @@ async function fetchMoltbookScoutStatus() {
   }
 }
 
+async function fetchA2aRelayStatus() {
+  if (!state.session?.a2aRelayEnabled) {
+    state.a2aRelayStatus = null;
+    return;
+  }
+  try {
+    state.a2aRelayStatus = await apiGet("/api/a2a/relay-status");
+  } catch {
+    state.a2aRelayStatus = null;
+  }
+}
+
 async function getClientPushState() {
   const registration = state.serviceWorkerRegistration || (await navigator.serviceWorker?.ready.catch(() => null));
   if (registration) {
@@ -979,6 +993,9 @@ function shouldDeferRenderForActiveInteraction() {
   if (state.currentDetail?.kind === "moltbook_draft") {
     return true;
   }
+  if (state.currentDetail?.kind === "thread_share" && state.currentDetail?.threadShareEnabled) {
+    return true;
+  }
   if (
     activeElement instanceof HTMLTextAreaElement &&
     activeElement.matches("[data-claude-question-note]")
@@ -2754,6 +2771,7 @@ function buildSettingsContext() {
       serverEnabled,
     }),
     moltbookScout: state.moltbookScoutStatus,
+    a2aRelay: state.a2aRelayStatus,
   };
 }
 
@@ -2907,6 +2925,13 @@ function settingsPageMeta(page) {
         description: L("settings.moltbook.copy"),
         icon: "item",
       };
+    case "a2aRelay":
+      return {
+        id: "a2aRelay",
+        title: L("settings.a2aRelay.title"),
+        description: L("settings.a2aRelay.copy"),
+        icon: "link",
+      };
     default:
       return settingsPageMeta("notifications");
   }
@@ -2976,15 +3001,22 @@ function renderSettingsRoot(context, { mobile }) {
           `
       }
       ${renderSettingsGroup(L("settings.group.general"), generalRows)}
-      ${state.session?.moltbookEnabled ? renderSettingsGroup(L("common.sns"), [
-        renderSettingsNavRow({
+      ${(state.session?.moltbookEnabled || state.session?.a2aRelayEnabled) ? renderSettingsGroup(L("settings.group.integrations"), [
+        state.session?.moltbookEnabled ? renderSettingsNavRow({
           page: "moltbook",
           icon: "item",
           title: L("settings.moltbook.title"),
           subtitle: L("settings.moltbook.subtitle"),
           value: context.moltbookScout?.enabled ? `${context.moltbookScout.sentToday} / ${context.moltbookScout.maxDaily}` : "",
-        }),
-      ]) : ""}
+        }) : "",
+        state.session?.a2aRelayEnabled ? renderSettingsNavRow({
+          page: "a2aRelay",
+          icon: "link",
+          title: L("settings.a2aRelay.title"),
+          subtitle: L("settings.a2aRelay.subtitle"),
+          value: context.a2aRelay?.connected ? L("settings.status.connected") : L("settings.a2aRelay.status.disconnected"),
+        }) : "",
+      ].filter(Boolean)) : ""}
       ${renderSettingsGroup(L("settings.pairing.title"), deviceRows)}
       ${renderSettingsGroup(L("settings.group.advanced"), advancedRows)}
     </div>
@@ -3031,6 +3063,9 @@ function renderSettingsSubpage(context, { mobile }) {
     case "moltbook":
       content = renderSettingsMoltbookPage(context);
       break;
+    case "a2aRelay":
+      content = renderSettingsA2aRelayPage(context);
+      break;
     default:
       content = "";
   }
@@ -3282,6 +3317,38 @@ function renderSettingsMoltbookPage(context) {
   `;
 }
 
+function renderSettingsA2aRelayPage(context) {
+  const relay = context.a2aRelay;
+  if (!relay?.enabled) {
+    return `
+      <div class="settings-page">
+        <p class="settings-page-copy muted">${escapeHtml(L("settings.a2aRelay.unavailable"))}</p>
+      </div>
+    `;
+  }
+  const statusLabel = relay.connected
+    ? L("settings.status.connected")
+    : relay.polling
+      ? L("settings.a2aRelay.status.polling")
+      : L("settings.a2aRelay.status.disconnected");
+  const profileUrl = `${relay.relayUrl}/${relay.userId}`;
+  const userIdLink = `<a href="${escapeHtml(profileUrl)}" target="_blank" rel="noopener">${escapeHtml(relay.userId)}</a>`;
+  const relayHost = (() => { try { return new URL(relay.relayUrl).host; } catch { return relay.relayUrl; } })();
+  return `
+    <div class="settings-page">
+      ${renderSettingsGroup("", [
+        renderSettingsInfoRow(L("settings.row.a2aStatus"), statusLabel),
+        renderSettingsInfoRow(L("settings.row.a2aUserId"), userIdLink, { rawValue: true }),
+        renderSettingsInfoRow(L("settings.row.a2aRelay"), relayHost),
+        renderSettingsInfoRow(L("settings.row.a2aApiKey"), relay.apiKeyConfigured ? L("settings.a2aRelay.apiKey.configured") : L("settings.a2aRelay.apiKey.notConfigured")),
+        relay.lastPollAtMs
+          ? renderSettingsInfoRow(L("settings.row.a2aLastPoll"), new Date(relay.lastPollAtMs).toLocaleString(state.locale))
+          : "",
+      ].filter(Boolean))}
+    </div>
+  `;
+}
+
 function renderSettingsInfoRow(label, value, options = {}) {
   const rowClassName = ["settings-info-row", options.rowClassName || ""].filter(Boolean).join(" ");
   const valueClassName = ["settings-info-row__value", options.valueClassName || ""].filter(Boolean).join(" ");
@@ -3395,14 +3462,15 @@ function renderStandardDetailDesktop(detail) {
     <div class="detail-shell">
       ${renderDetailMetaRow(detail, kindInfo)}
       <h2 class="detail-title detail-title--desktop">${renderDetailTitle(detail)}</h2>
-      ${detail.readOnly || detail.kind === "approval" || detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" ? "" : renderDetailLead(detail, kindInfo)}
+      ${detail.readOnly || detail.kind === "approval" || detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "thread_share" ? "" : renderDetailLead(detail, kindInfo)}
       ${renderPreviousContextCard(detail)}
       ${renderInterruptedDetailNotice(detail)}
       ${renderMoltbookReplyComposer(detail)}
       ${renderMoltbookDraftComposer(detail)}
       ${renderA2ATaskDetail(detail)}
+      ${renderThreadShareDetail(detail)}
       ${
-        detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "a2a_task"
+        detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "a2a_task" || detail.kind === "thread_share"
           ? ""
           : plainIntro
             ? plainIntro
@@ -3438,8 +3506,9 @@ function renderStandardDetailMobile(detail) {
           ${renderMoltbookReplyComposer(detail, { mobile: true })}
           ${renderMoltbookDraftComposer(detail, { mobile: true })}
           ${renderA2ATaskDetail(detail, { mobile: true })}
+          ${renderThreadShareDetail(detail, { mobile: true })}
           ${
-            detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "a2a_task"
+            detail.kind === "moltbook_draft" || detail.kind === "moltbook_reply" || detail.kind === "a2a_task" || detail.kind === "thread_share"
               ? ""
               : plainIntro
                 ? plainIntro
@@ -4048,6 +4117,56 @@ function renderA2ATaskDetail(detail, options = {}) {
   `;
 }
 
+function renderThreadShareDetail(detail, options = {}) {
+  if (detail.kind !== "thread_share") return "";
+  const enabled = detail.threadShareEnabled !== false && detail.readOnly !== true;
+  const content = detail.shareContent || "";
+  const fromLabel = detail.sourceLabel || detail.sourceTool || "agent";
+  const toLabel = detail.targetLabel || detail.targetConversationId?.slice(0, 8) || detail.targetTool || "thread";
+  const contextFiles = Array.isArray(detail.contextFiles) ? detail.contextFiles : [];
+  const shareTypeLabel = {
+    plan_review: L("threadShare.type.planReview"),
+    handoff: L("threadShare.type.handoff"),
+    message: L("threadShare.type.message"),
+  }[detail.shareType] || L("threadShare.type.message");
+
+  const contextFilesHtml = contextFiles.length > 0
+    ? `<div class="reply-composer__instruction">
+        <label class="field-label">${escapeHtml(L("threadShare.contextFiles"))}</label>
+        <ul class="context-files-list">${contextFiles.map((f) => `<li class="context-file-item"><code>${escapeHtml(f)}</code></li>`).join("")}</ul>
+      </div>`
+    : "";
+
+  const buttons = enabled
+    ? `
+      <div class="actions actions--stack${options.mobile ? " actions--sticky" : ""}">
+        <button type="submit" data-action="approve" class="primary primary--wide">${escapeHtml(L("threadShare.approve"))}</button>
+        <button type="submit" data-action="deny" class="danger danger--wide">${escapeHtml(L("threadShare.deny"))}</button>
+      </div>
+    `
+    : `<p class="muted reply-composer__description">${escapeHtml(L("threadShare.resolved"))}</p>`;
+  const buttonsWrapped = enabled && options.mobile ? `<div class="detail-action-bar">${buttons}</div>` : buttons;
+
+  return `
+    <section class="detail-card detail-card--reply ${options.mobile ? "detail-card--mobile" : ""}">
+      <form class="reply-composer" data-thread-share-form data-token="${escapeHtml(detail.token || "")}">
+        <div class="reply-composer__copy">
+          <span class="eyebrow-pill eyebrow-pill--quiet">${escapeHtml(L("threadShare.eyebrow"))}</span>
+          <span class="eyebrow-pill eyebrow-pill--subtle">${escapeHtml(shareTypeLabel)}</span>
+          <p class="reply-composer__author-meta muted">${escapeHtml(fromLabel)} → ${escapeHtml(toLabel)}</p>
+          <p class="muted reply-composer__description">${enabled ? escapeHtml(L("threadShare.editHint")) : ""}</p>
+        </div>
+        ${contextFilesHtml}
+        <div class="reply-composer__instruction">
+          <label class="field-label">${escapeHtml(L("threadShare.content"))}</label>
+          <textarea name="shareContent" class="reply-composer__textarea" rows="12" ${enabled ? "" : "readonly"}>${escapeHtml(content)}</textarea>
+        </div>
+        ${buttonsWrapped}
+      </form>
+    </section>
+  `;
+}
+
 function renderCompletionReplyComposer(detail, options = {}) {
   if (detail.kind !== "completion" || detail.reply?.enabled !== true) {
     return "";
@@ -5241,6 +5360,72 @@ function bindShellInteractions() {
     });
   }
 
+  const threadShareForm = document.querySelector("[data-thread-share-form]");
+  if (threadShareForm) {
+    const token = threadShareForm.dataset.token || "";
+    let submittedAction = "approve";
+    threadShareForm.querySelectorAll("button[type='submit']").forEach((btn) => {
+      btn.addEventListener("click", () => {
+        submittedAction = btn.dataset.action || "approve";
+      });
+    });
+    threadShareForm.addEventListener("submit", async (event) => {
+      event.preventDefault();
+      if (threadShareForm.dataset.submitting === "1") return;
+      threadShareForm.dataset.submitting = "1";
+      const buttons = threadShareForm.querySelectorAll("button[type='submit']");
+      const textarea = threadShareForm.querySelector("textarea");
+      const labelCache = new Map();
+      buttons.forEach((btn) => {
+        labelCache.set(btn, btn.innerHTML);
+        btn.disabled = true;
+        if (btn.dataset.action === submittedAction) {
+          btn.innerHTML = submittedAction === "approve" ? "Sharing…" : "Denying…";
+          btn.classList.add("is-loading");
+        } else {
+          btn.classList.add("is-dimmed");
+        }
+      });
+      if (textarea) textarea.readOnly = true;
+      const editedContent = normalizeClientText(new FormData(threadShareForm).get("shareContent"));
+      try {
+        const res = await fetch(`/api/threads/share/${encodeURIComponent(token)}/decision`, {
+          method: "POST",
+          headers: { "content-type": "application/json" },
+          credentials: "same-origin",
+          body: JSON.stringify({ decision: submittedAction, editedContent }),
+        });
+        if (!res.ok) {
+          const errBody = await res.json().catch(() => ({}));
+          alert(`Thread share ${submittedAction} failed: ${errBody.error || res.status}`);
+          buttons.forEach((btn) => {
+            btn.disabled = false;
+            btn.classList.remove("is-loading", "is-dimmed");
+            btn.innerHTML = labelCache.get(btn);
+          });
+          if (textarea) textarea.readOnly = false;
+          threadShareForm.dataset.submitting = "";
+          return;
+        }
+        if (state.currentDetail?.kind === "thread_share") {
+          state.currentDetail.threadShareEnabled = false;
+          state.currentDetail.readOnly = true;
+        }
+        await refreshAuthenticatedState();
+        await renderShell();
+      } catch (error) {
+        alert(`Thread share error: ${error.message}`);
+        buttons.forEach((btn) => {
+          btn.disabled = false;
+          btn.classList.remove("is-loading", "is-dimmed");
+          btn.innerHTML = labelCache.get(btn);
+        });
+        if (textarea) textarea.readOnly = false;
+        threadShareForm.dataset.submitting = "";
+      }
+    });
+  }
+
   const replyForm = document.querySelector("[data-completion-reply-form]");
   if (replyForm) {
     const token = replyForm.dataset.token || "";
@@ -5722,6 +5907,8 @@ function kindMeta(kind) {
     case "moltbook_reply":
     case "moltbook_draft":
       return { label: L("common.sns"), tone: "neutral", icon: "item" };
+    case "thread_share":
+      return { label: L("common.threadShare"), tone: "neutral", icon: "link" };
     default:
       return { label: L("common.item"), tone: "neutral", icon: "item" };
   }

package/web/i18n.js

@@ -49,6 +49,7 @@ const translations = {
     "common.assistantFinal": "Final reply",
     "common.item": "Item",
     "common.sns": "SNS",
+    "common.threadShare": "Thread Share",
     "common.untitledItem": "Untitled item",
     "common.useDeviceLanguage": "Use device language",
     "language.option.en": "English",
@@ -373,6 +374,20 @@ const translations = {
     "moltbook.draft.greetNoon": "Nice progress! Ready to share your morning work?",
     "moltbook.draft.greetEvening": "Great work today! Let's share what you built.",
     "moltbook.draft.greetFallback": "New post ready for review",
+    "settings.group.integrations": "Integrations",
+    "settings.a2aRelay.title": "A2A Relay",
+    "settings.a2aRelay.subtitle": "Agent-to-Agent relay connection",
+    "settings.a2aRelay.copy": "View your A2A relay connection status and configuration.",
+    "settings.a2aRelay.unavailable": "A2A Relay is not configured.",
+    "settings.a2aRelay.status.disconnected": "Disconnected",
+    "settings.a2aRelay.status.polling": "Connecting...",
+    "settings.a2aRelay.apiKey.configured": "Configured",
+    "settings.a2aRelay.apiKey.notConfigured": "Not configured",
+    "settings.row.a2aStatus": "Status",
+    "settings.row.a2aUserId": "User ID",
+    "settings.row.a2aRelay": "Relay",
+    "settings.row.a2aApiKey": "API Key",
+    "settings.row.a2aLastPoll": "Last poll",
     "a2a.task.eyebrow": "A2A Task Request",
     "a2a.task.from": "From",
     "a2a.task.instruction": "Task",
@@ -386,6 +401,16 @@ const translations = {
     "a2a.task.statusFailed": "Failed",
     "a2a.task.statusCanceled": "Canceled",
     "a2a.task.statusRejected": "Rejected",
+    "threadShare.eyebrow": "Thread Share",
+    "threadShare.content": "Shared content",
+    "threadShare.approve": "Approve & Share",
+    "threadShare.deny": "Deny",
+    "threadShare.editHint": "Review the content below. Edit if needed, then approve to share or deny to skip.",
+    "threadShare.resolved": "This share request has been resolved.",
+    "threadShare.contextFiles": "Context files (read by recipient)",
+    "threadShare.type.message": "Message",
+    "threadShare.type.planReview": "Plan Review",
+    "threadShare.type.handoff": "Handoff",
     "notice.notificationsEnabled": "Notifications are enabled on this device.",
     "notice.notificationsDisabled": "Notifications are disabled on this device.",
     "notice.testNotificationSent": "Test notification sent.",
@@ -485,13 +510,23 @@ const translations = {
     "server.page.choiceMissing": "Choice input token not found",
     "server.page.approvalHandled": "Approval already handled",
     "server.page.detailMissing": "Completion detail not found",
-    "cli.help.usage": "Usage: viveworker <setup|start|stop|status|doctor> [options]",
+    "cli.help.usage": "Usage: viveworker <setup|start|stop|status|doctor|update> [options]",
     "cli.help.commands": "Commands:",
     "cli.help.setup": "setup         Create config, generate pairing info, register launchd, start the bridge",
     "cli.help.start": "start         Start the bridge using the saved config",
     "cli.help.stop": "stop          Stop the bridge",
     "cli.help.status": "status        Print launchd/background status and health",
     "cli.help.doctor": "doctor        Diagnose the local setup",
+    "cli.help.update": "update        Update to the latest version and restart all services",
+    "cli.update.progress.checkVersion": "Checking for updates...",
+    "cli.update.progress.install": "Installing latest version...",
+    "cli.update.progress.restartBridge": "Restarting bridge...",
+    "cli.update.progress.restartWatcher": "Restarting Moltbook watcher...",
+    "cli.update.progress.restartScout": "Restarting Moltbook scout...",
+    "cli.update.checkFailed": "Could not check the latest version from npm",
+    "cli.update.alreadyLatest": "Already up to date (v{version})",
+    "cli.update.versionInfo": "Updating v{current} -> v{latest}",
+    "cli.update.done": "Updated to v{version} — all services restarted",
     "cli.help.commonOptions": "Common options:",
     "cli.setup.complete": "viveworker setup complete",
     "cli.setup.progress.prepare": "Preparing local viveworker setup...",
@@ -642,6 +677,7 @@ const translations = {
     "common.assistantFinal": "最終回答",
     "common.item": "項目",
     "common.sns": "SNS",
+    "common.threadShare": "スレッド共有",
     "common.untitledItem": "無題の項目",
     "common.useDeviceLanguage": "端末の言語を使う",
     "language.option.en": "English",
@@ -962,6 +998,20 @@ const translations = {
     "moltbook.draft.greetNoon": "午前中お疲れ様でした！進捗をシェアしませんか？",
     "moltbook.draft.greetEvening": "今日もお疲れ様でした！成果をシェアしませんか？",
     "moltbook.draft.greetFallback": "投稿ドラフトができました",
+    "settings.group.integrations": "連携サービス",
+    "settings.a2aRelay.title": "A2A Relay",
+    "settings.a2aRelay.subtitle": "Agent-to-Agent リレー接続",
+    "settings.a2aRelay.copy": "A2A リレーの接続状態と設定を確認できます。",
+    "settings.a2aRelay.unavailable": "A2A Relay が設定されていません。",
+    "settings.a2aRelay.status.disconnected": "切断",
+    "settings.a2aRelay.status.polling": "接続中...",
+    "settings.a2aRelay.apiKey.configured": "設定済み",
+    "settings.a2aRelay.apiKey.notConfigured": "未設定",
+    "settings.row.a2aStatus": "ステータス",
+    "settings.row.a2aUserId": "ユーザー ID",
+    "settings.row.a2aRelay": "リレー",
+    "settings.row.a2aApiKey": "API キー",
+    "settings.row.a2aLastPoll": "最終ポーリング",
     "a2a.task.eyebrow": "A2A タスクリクエスト",
     "a2a.task.from": "送信元",
     "a2a.task.instruction": "タスク内容",
@@ -975,6 +1025,16 @@ const translations = {
     "a2a.task.statusFailed": "失敗",
     "a2a.task.statusCanceled": "キャンセル",
     "a2a.task.statusRejected": "拒否済み",
+    "threadShare.eyebrow": "スレッド共有",
+    "threadShare.content": "共有内容",
+    "threadShare.approve": "承認して共有",
+    "threadShare.deny": "拒否",
+    "threadShare.editHint": "内容を確認してください。必要に応じて編集し、承認で共有、拒否でスキップします。",
+    "threadShare.resolved": "この共有リクエストは処理済みです。",
+    "threadShare.contextFiles": "コンテキストファイル（受信側が読み込みます）",
+    "threadShare.type.message": "メッセージ",
+    "threadShare.type.planReview": "プランレビュー",
+    "threadShare.type.handoff": "引き継ぎ",
     "notice.notificationsEnabled": "この端末で通知を有効にしました。",
     "notice.notificationsDisabled": "この端末の通知を無効にしました。",
     "notice.testNotificationSent": "テスト通知を送信しました。",
@@ -1074,13 +1134,23 @@ const translations = {
     "server.page.choiceMissing": "選択入力トークンが見つかりません",
     "server.page.approvalHandled": "この承認はすでに処理済みです",
     "server.page.detailMissing": "完了詳細が見つかりません",
-    "cli.help.usage": "Usage: viveworker <setup|start|stop|status|doctor> [options]",
+    "cli.help.usage": "Usage: viveworker <setup|start|stop|status|doctor|update> [options]",
     "cli.help.commands": "Commands:",
     "cli.help.setup": "setup         設定を作成し、ペアリング情報を生成し、launchd に登録して bridge を起動します",
     "cli.help.start": "start         保存済み設定で bridge を起動します",
     "cli.help.stop": "stop          bridge を停止します",
     "cli.help.status": "status        launchd / バックグラウンド状態と health を表示します",
     "cli.help.doctor": "doctor        ローカル設定を診断します",
+    "cli.help.update": "update        最新バージョンに更新し、全サービスを再起動します",
+    "cli.update.progress.checkVersion": "更新を確認しています...",
+    "cli.update.progress.install": "最新バージョンをインストールしています...",
+    "cli.update.progress.restartBridge": "bridge を再起動しています...",
+    "cli.update.progress.restartWatcher": "Moltbook watcher を再起動しています...",
+    "cli.update.progress.restartScout": "Moltbook scout を再起動しています...",
+    "cli.update.checkFailed": "npm から最新バージョンを確認できませんでした",
+    "cli.update.alreadyLatest": "すでに最新です (v{version})",
+    "cli.update.versionInfo": "v{current} -> v{latest} に更新します",
+    "cli.update.done": "v{version} に更新しました — 全サービスを再起動しました",
     "cli.help.commonOptions": "共通オプション:",
     "cli.setup.complete": "viveworker の setup が完了しました",
     "cli.setup.progress.prepare": "viveworker のローカル設定を準備しています...",