viveworker 0.2.1 → 0.4.0

package/scripts/viveworker-bridge.mjs

@@ -16,6 +16,8 @@ import webPush from "web-push";
 import { DEFAULT_LOCALE, SUPPORTED_LOCALES, localeDisplayName, normalizeLocale, resolveLocalePreference, t } from "../web/i18n.js";
 import { generatePairingCredentials, shouldRotatePairing, upsertEnvText } from "./lib/pairing.mjs";
 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";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -26,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"]);
+const timelineKinds = new Set([...timelineMessageKinds, "approval", "plan", "choice", "completion", "plan_ready", "file_event", "moltbook_reply", "moltbook_draft"]);
 const SQLITE_COMPLETION_BATCH_SIZE = 200;
 const DEFAULT_DEVICE_TRUST_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const MAX_PAIRED_DEVICES = 200;
@@ -39,6 +41,7 @@ const MAX_COMPLETION_REPLY_IMAGE_COUNT = 4;
 const cli = parseCliArgs(process.argv.slice(2));
 const envFile = resolveEnvFile(cli.envFile);
 loadEnvFile(envFile);
+loadEnvFile(path.join(os.homedir(), ".viveworker", "a2a.env"));
 await maybeRotateStartupPairingEnv(envFile);
 
 const config = buildConfig(cli);
@@ -79,6 +82,9 @@ const runtime = {
   userInputRequestsByToken: new Map(),
   userInputRequestsByRequestKey: new Map(),
   completionDetailsByToken: new Map(),
+  moltbookItemsByToken: new Map(),
+  moltbookDraftsByToken: new Map(),
+  a2aTasksByToken: new Map(),
   planDetailsByToken: new Map(),
   recentHistoryItems: [],
   recentTimelineEntries: [],
@@ -212,6 +218,9 @@ function buildSessionLocalePayload(config, state, deviceId) {
     deviceDetectedLocale: resolved.detectedLocale || null,
     deviceOverrideLocale: resolved.overrideLocale || null,
     claudeAwayMode: state?.claudeAwayMode === true,
+    moltbookEnabled: Boolean(config.moltbookApiKey),
+    a2aEnabled: Boolean(config.a2aApiKey),
+    a2aRelayEnabled: Boolean(config.a2aRelayUrl && config.a2aRelayUserId),
   };
 }
 
@@ -280,6 +289,8 @@ function notificationIconPrefix(kind) {
       return "☑️";
     case "completion":
       return "✅";
+    case "a2a_task":
+      return "🤝";
     default:
       return "";
   }
@@ -1989,11 +2000,18 @@ function handleSignal() {
 
 function normalizeProvider(value) {
   const normalized = String(value || "").toLowerCase();
-  return normalized === "claude" ? "claude" : "codex";
+  if (normalized === "claude") return "claude";
+  if (normalized === "moltbook") return "moltbook";
+  if (normalized === "a2a") return "a2a";
+  return "codex";
 }
 
 function providerDisplayName(locale, provider) {
-  return t(locale, normalizeProvider(provider) === "claude" ? "common.claude" : "common.codex");
+  const p = normalizeProvider(provider);
+  if (p === "claude") return t(locale, "common.claude");
+  if (p === "moltbook") return "Moltbook";
+  if (p === "a2a") return "A2A";
+  return t(locale, "common.codex");
 }
 
 function normalizeHistoryItems(rawItems, maxItems) {
@@ -2085,17 +2103,31 @@ function normalizeTimelineEntries(rawItems, maxItems) {
       }
       return timelineKindSortPriority(right.kind) - timelineKindSortPriority(left.kind);
     });
+  // Per-provider eviction: each provider (codex, claude, moltbook) gets up
+  // to `maxItems` entries, so entries from one busy provider don't push out
+  // entries from another.  Total capacity is maxItems * providerCount.
   const deduped = [];
   const seen = new Set();
+  const perProviderCount = {};
+  const knownProviders = new Set(["codex", "claude", "moltbook", "a2a"]);
+  const saturatedProviders = new Set();
   for (const item of normalized) {
     if (seen.has(item.stableId)) {
       continue;
     }
+    const prov = item.provider || "codex";
+    if (saturatedProviders.has(prov)) {
+      continue;
+    }
+    const count = (perProviderCount[prov] || 0) + 1;
+    perProviderCount[prov] = count;
+    if (count > maxItems) {
+      saturatedProviders.add(prov);
+      if (saturatedProviders.size >= knownProviders.size) break;
+      continue;
+    }
     seen.add(item.stableId);
     deduped.push(item);
-    if (deduped.length >= maxItems) {
-      break;
-    }
   }
   return deduped;
 }
@@ -2174,14 +2206,18 @@ function normalizeTimelineEntry(raw) {
     formatNotificationBody(messageText, 180) ||
     (kind === "file_event" ? "" : cleanText(raw.title ?? "")) ||
     "";
-  const threadLabel = preferTitleOnlyJsonThreadLabel(
-    cleanText(raw.threadLabel ?? ""),
-    threadId,
-    raw.messageText,
-    raw.summary,
-    raw.detailText,
-    raw.message
-  );
+  const rawProvider = normalizeProvider(raw.provider);
+  const threadLabel =
+    rawProvider === "moltbook"
+      ? cleanText(raw.threadLabel ?? "")
+      : preferTitleOnlyJsonThreadLabel(
+          cleanText(raw.threadLabel ?? ""),
+          threadId,
+          raw.messageText,
+          raw.summary,
+          raw.detailText,
+          raw.message
+        );
   const title =
     cleanText(raw.title ?? "") ||
     (kind === "file_event" ? fileEventTitle(DEFAULT_LOCALE, fileEventType) : "") ||
@@ -2216,6 +2252,20 @@ function normalizeTimelineEntry(raw) {
     tone: cleanText(raw.tone ?? "") || "secondary",
     cwd: resolvePath(cleanText(raw.cwd || "")),
     provider: normalizeProvider(raw.provider),
+    // Moltbook-specific fields — preserved for detail view fallback after
+    // the in-memory draft/item expires.
+    ...(raw.draftText != null ? { draftText: cleanText(raw.draftText) } : {}),
+    ...(raw.intent != null ? { intent: cleanText(raw.intent) } : {}),
+    ...(raw.postId != null ? { postId: cleanText(raw.postId) } : {}),
+    ...(raw.postUrl != null ? { postUrl: cleanText(raw.postUrl) } : {}),
+    ...(raw.postTitle != null ? { postTitle: cleanText(raw.postTitle) } : {}),
+    ...(raw.postAuthor != null ? { postAuthor: cleanText(raw.postAuthor) } : {}),
+    ...(raw.postBody != null ? { postBody: cleanText(raw.postBody) } : {}),
+    ...(raw.commentAuthor != null ? { commentAuthor: cleanText(raw.commentAuthor) } : {}),
+    ...(raw.contextText != null ? { contextText: cleanText(raw.contextText) } : {}),
+    ...(raw.draftType != null ? { draftType: cleanText(raw.draftType) } : {}),
+    ...(raw.submoltName != null ? { submoltName: cleanText(raw.submoltName) } : {}),
+    ...(raw.slot != null ? { slot: cleanText(raw.slot) } : {}),
   };
 }
 
@@ -3066,7 +3116,7 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
     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.
+    // re-processing old entries that would be immediately discarded by the per-provider entry limit.
     let initialOffset = 0;
     let startupCutoffMs = 0;
     try {
@@ -3179,6 +3229,10 @@ async function processClaudeTranscriptFile({ filePath, config, runtime, state, n
     }
     text = cleanText(text);
     if (!text) continue;
+    // Skip Claude Code internal system messages (task notifications, system
+    // reminders, etc.) — these are XML-like tags injected into the
+    // conversation that should not appear on the user-facing timeline.
+    if (/^<(?:task-notification|system-reminder)\b/i.test(text.trim())) continue;
 
     const kind = type === "user" ? "user_message" : "assistant_final";
     const stableId = `${kind}:${threadId}:${uuid}`;
@@ -8982,6 +9036,41 @@ function buildPendingInboxItems(runtime, state, config, locale) {
     });
   }
 
+  for (const draft of runtime.moltbookDraftsByToken.values()) {
+    if (draft.decision) continue;
+    const title = draft.postTitle ? `draft → ${draft.postTitle}` : "Moltbook draft";
+    items.push({
+      kind: "moltbook_draft",
+      token: draft.token,
+      threadId: "moltbook",
+      threadLabel: "Moltbook",
+      title,
+      summary: draft.contextSummary || String(draft.draftText || "").slice(0, 160),
+      primaryLabel: t(locale, "server.action.review"),
+      createdAtMs: Number(draft.createdAtMs) || now,
+      provider: "moltbook",
+    });
+  }
+
+  for (const task of runtime.a2aTasksByToken.values()) {
+    if (task.status !== "submitted") continue;
+    items.push({
+      kind: "a2a_task",
+      token: task.token,
+      threadId: "a2a",
+      threadLabel: "A2A",
+      title: `A2A: ${cleanText(task.instruction || "").slice(0, 80)}`,
+      summary: cleanText(task.instruction || "").slice(0, 160),
+      primaryLabel: t(locale, "server.action.review"),
+      createdAtMs: Number(task.createdAtMs) || now,
+      provider: "a2a",
+    });
+  }
+
+  // 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.
+
   return items.sort((left, right) => Number(right.createdAtMs ?? 0) - Number(left.createdAtMs ?? 0));
 }
 
@@ -9301,7 +9390,7 @@ function buildTimelineThreads(entries, config) {
   const byThread = new Map();
   for (const entry of entries) {
     const threadId = cleanText(entry.threadId || "");
-    if (!threadId) {
+    if (!threadId || threadId === "moltbook" || threadId.startsWith("draft:") || (entry.kind || "").startsWith("moltbook_")) {
       continue;
     }
     const preferredLabel =
@@ -10414,6 +10503,113 @@ async function buildApiItemDetail({ config, runtime, state, kind, token, locale
     return historicalChoice ? buildHistoryDetail(historicalChoice, locale, runtime) : null;
   }
 
+  if (kind === "moltbook_reply") {
+    const item = runtime.moltbookItemsByToken.get(token);
+    // Fall back to the persisted timeline entry so that items which have
+    // been resolved (removed from the pending map) still render their
+    // detail view from history.
+    const entry = item
+      ? null
+      : runtime.recentTimelineEntries.find((e) => e.kind === "moltbook_reply" && e.token === token);
+    const source = item || entry;
+    if (!source) return null;
+    const contextText = item
+      ? item.contextText || item.summary || ""
+      : entry.messageText || entry.summary || "";
+    const contextHtml = escapeHtml(contextText)
+      .split("\n")
+      .map((line) => `<p>${line}</p>`)
+      .join("");
+    return {
+      kind: "moltbook_reply",
+      token,
+      threadId: source.threadId || "",
+      threadLabel: source.threadLabel || "Moltbook",
+      title: source.title || "Moltbook reply",
+      summary: source.summary || "",
+      messageHtml: contextHtml,
+      postUrl: source.postUrl || "",
+      commentAuthor: source.commentAuthor || "",
+      provider: "moltbook",
+      draftReply: item?.draftReply || "",
+      createdAtMs: source.createdAtMs || Date.now(),
+      readOnly: !item,
+      actions: [],
+      moltbookReplyEnabled: Boolean(item),
+    };
+  }
+
+  if (kind === "moltbook_draft") {
+    const draft = runtime.moltbookDraftsByToken.get(token);
+    const entry = draft
+      ? null
+      : runtime.recentTimelineEntries.find((e) => e.kind === "moltbook_draft" && e.token === token);
+    const source = draft || entry;
+    if (!source) return null;
+    const draftText = draft ? draft.draftText : entry.draftText || entry.messageText || "";
+    const contextSummary = draft ? draft.contextSummary || "" : entry.summary || "";
+    const messageHtml = escapeHtml(contextSummary)
+      .split("\n")
+      .map((line) => `<p>${line}</p>`)
+      .join("");
+    return {
+      kind: "moltbook_draft",
+      token,
+      threadId: "moltbook",
+      threadLabel: "Moltbook",
+      title: source.title || "Moltbook draft",
+      summary: source.summary || contextSummary || "",
+      messageHtml,
+      provider: "moltbook",
+      draftText,
+      postId: draft?.postId || entry?.postId || "",
+      postUrl: draft?.postUrl || entry?.postUrl || "",
+      postTitle: draft?.postTitle || entry?.postTitle || "",
+      postAuthor: draft?.postAuthor || entry?.postAuthor || "",
+      postBody: draft?.postBody || entry?.postBody || "",
+      draftType: draft?.draftType || entry?.draftType || "reply",
+      submoltName: draft?.submoltName || entry?.submoltName || "",
+      intent: draft?.intent || entry?.intent || "",
+      slot: draft?.slot || entry?.slot || "",
+      createdAtMs: source.createdAtMs || Date.now(),
+      readOnly: !draft || Boolean(draft?.decision),
+      actions: [],
+      moltbookDraftEnabled: Boolean(draft) && !draft.decision,
+    };
+  }
+
+  if (kind === "a2a_task") {
+    const task = runtime.a2aTasksByToken.get(token);
+    const entry = task
+      ? null
+      : runtime.recentTimelineEntries.find((e) => e.kind === "a2a_task" && e.token === token);
+    const source = task || entry;
+    if (!source) return null;
+    const instruction = task ? task.instruction : entry.messageText || entry.summary || "";
+    const messageHtml = escapeHtml(instruction)
+      .split("\n")
+      .map((line) => `<p>${line}</p>`)
+      .join("");
+    return {
+      kind: "a2a_task",
+      token,
+      threadId: "a2a",
+      threadLabel: "A2A",
+      title: source.title || `A2A Task`,
+      summary: source.summary || cleanText(instruction).slice(0, 160),
+      messageHtml,
+      provider: "a2a",
+      instruction,
+      taskId: task?.id || "",
+      taskStatus: task?.status || entry?.taskStatus || "unknown",
+      callerInfo: task?.callerInfo || {},
+      createdAtMs: source.createdAtMs || Date.now(),
+      readOnly: !task || task.status !== "submitted",
+      actions: [],
+      a2aTaskEnabled: Boolean(task) && task.status === "submitted",
+    };
+  }
+
   const historyItem = historyItemByToken(runtime, kind, token);
   return historyItem ? buildHistoryDetail(historyItem, locale, runtime) : null;
 }
@@ -10631,6 +10827,104 @@ function createNativeApprovalServer({ config, runtime, state }) {
         }
       }
 
+      // ---------------------------------------------------------------
+      // A2A (Agent2Agent) Protocol endpoints
+      // ---------------------------------------------------------------
+
+      if (url.pathname === "/.well-known/agent.json" && req.method === "GET") {
+        if (!config.a2aApiKey) {
+          return writeJson(res, 404, { error: "a2a-not-configured" });
+        }
+        return writeJson(res, 200, buildAgentCard(config));
+      }
+
+      if (url.pathname === "/a2a" && req.method === "POST") {
+        if (!config.a2aApiKey) {
+          return writeJson(res, 404, { error: "a2a-not-configured" });
+        }
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { jsonrpc: "2.0", id: null, error: { code: -32700, message: "Parse error" } });
+        }
+        return handleA2ARequest({
+          req, res, body, config, runtime, state,
+          writeJson, recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText,
+        });
+      }
+
+      // A2A task decision (user approves/denies from PWA)
+      const apiA2ATaskDecide = url.pathname.match(/^\/api\/items\/a2a-task\/([^/]+)\/decision$/u);
+      if (apiA2ATaskDecide && req.method === "POST") {
+        const session = requireMutatingApiSession(req, res, config, state);
+        if (!session) return;
+        const token = decodeURIComponent(apiA2ATaskDecide[1]);
+        const task = runtime.a2aTasksByToken.get(token);
+        if (!task) return writeJson(res, 404, { error: "task-not-found" });
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+        const action = String(body.action || "") === "approve" ? "approve" : "deny";
+        const instruction = cleanText(body.instruction || "");
+        resolveA2ATaskDecision(task, { action, instruction });
+
+        if (action === "approve") {
+          // Execute task asynchronously via Codex
+          (async () => {
+            try {
+              const { executeA2ATask } = await import("./a2a-executor.mjs");
+              await executeA2ATask(task, config, runtime, state, { recordTimelineEntry, saveState });
+            } catch (error) {
+              console.error(`[a2a-execute-error] ${error.message}`);
+              failA2ATask(task, error.message);
+            }
+            // Post result to relay if this is a relay-originated task
+            if (task.relayTaskId) {
+              postRelayResult({ config, task }).catch((err) =>
+                console.error(`[a2a-relay] Result post error: ${err.message}`)
+              );
+            }
+          })();
+        } else if (task.relayTaskId) {
+          // Denied — post rejection back to relay
+          postRelayResult({ config, task }).catch((err) =>
+            console.error(`[a2a-relay] Rejection post error: ${err.message}`)
+          );
+        }
+
+        // Keep entry briefly for polling
+        setTimeout(() => {
+          if (task.status === "rejected" || task.status === "canceled") {
+            runtime.a2aTasksByToken.delete(token);
+          }
+        }, 300_000).unref?.(); // 5 min cleanup for rejected/canceled
+
+        return writeJson(res, 200, { ok: true, action });
+      }
+
+      // A2A task status polling (for external callers, authenticated via A2A key)
+      const apiA2ATaskStatus = url.pathname.match(/^\/api\/providers\/a2a\/tasks\/([^/]+)\/status$/u);
+      if (apiA2ATaskStatus && req.method === "GET") {
+        const apiKey = req.headers["x-a2a-key"] || "";
+        if (!config.a2aApiKey || apiKey !== config.a2aApiKey) {
+          return writeJson(res, 401, { error: "unauthorized" });
+        }
+        const token = decodeURIComponent(apiA2ATaskStatus[1]);
+        const task = runtime.a2aTasksByToken.get(token);
+        if (!task) return writeJson(res, 404, { error: "task-not-found" });
+        return writeJson(res, 200, {
+          id: task.id,
+          status: task.status,
+          statusMessage: task.statusMessage || "",
+          artifacts: task.artifacts,
+          updatedAtMs: task.updatedAtMs,
+        });
+      }
+
       if (url.pathname === "/api/session" && req.method === "GET") {
         const session = readSession(req, config, state);
         const localeInfo = resolveDeviceLocaleInfo(config, state, session.deviceId);
@@ -10799,6 +11093,96 @@ function createNativeApprovalServer({ config, runtime, state }) {
         return writeJson(res, 200, { ok: true, enabled });
       }
 
+      if (url.pathname === "/api/moltbook/scout-status" && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+        if (!config.moltbookApiKey) {
+          return writeJson(res, 200, { enabled: false });
+        }
+        try {
+          const { readScoutState, rollScoutDayIfNeeded } = await import("./moltbook-api.mjs");
+          const scoutState = rollScoutDayIfNeeded(await readScoutState());
+          const batch = scoutState.batch;
+          const batchInfo = batch && batch.candidates?.length ? {
+            collecting: true,
+            candidateCount: batch.candidates.length,
+            topScore: Math.max(...batch.candidates.map((c) => c.score || 0)),
+            remainingSeconds: Math.max(0, Math.round(((batch.startedAt || 0) + (batch.windowMs || 1800000) - Date.now()) / 1000)),
+          } : null;
+          return writeJson(res, 200, {
+            enabled: true,
+            day: scoutState.day,
+            sentToday: scoutState.sentToday,
+            maxDaily: 5,
+            seenPostCount: Object.keys(scoutState.seenPostIds || {}).length,
+            batch: batchInfo,
+            composedToday: scoutState.composedToday || 0,
+            composeSlotsAttempted: Array.isArray(scoutState.composeSlotsAttempted) ? scoutState.composeSlotsAttempted : [],
+            recentComposeTitles: Array.isArray(scoutState.recentComposeTitles) ? scoutState.recentComposeTitles : [],
+          });
+        } catch {
+          return writeJson(res, 200, { enabled: true, day: "", sentToday: 0, maxDaily: 5, seenPostCount: 0 });
+        }
+      }
+
+      // 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.
+      if (url.pathname === "/api/providers/moltbook/activity-summary" && req.method === "GET") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+          return writeJson(res, 403, { error: "forbidden" });
+        }
+        const slot = String(url.searchParams.get("slot") || "").toLowerCase();
+        const dateParam = String(url.searchParams.get("date") || "");
+        const now = new Date();
+        const localHour = now.getHours();
+
+        // Determine time range based on slot.
+        let rangeStart, rangeEnd, rangeDate;
+        if (slot === "morning" && dateParam) {
+          // Morning slot: previous day's activities (dateParam = yesterday).
+          const d = new Date(dateParam + "T00:00:00");
+          rangeStart = d.getTime();
+          rangeEnd = rangeStart + 24 * 60 * 60 * 1000;
+          rangeDate = dateParam;
+        } else if (slot === "noon") {
+          // Noon slot: today 00:00 – 12:00 local.
+          const d = new Date(now); d.setHours(0, 0, 0, 0);
+          rangeStart = d.getTime();
+          const noon = new Date(now); noon.setHours(12, 0, 0, 0);
+          rangeEnd = noon.getTime();
+          rangeDate = d.toISOString().slice(0, 10);
+        } else if (slot === "evening") {
+          // Evening slot: today full day.
+          const d = new Date(now); d.setHours(0, 0, 0, 0);
+          rangeStart = d.getTime();
+          rangeEnd = Date.now();
+          rangeDate = d.toISOString().slice(0, 10);
+        } else {
+          // Default: today full day (UTC midnight to now).
+          const d = new Date(now);
+          d.setUTCHours(0, 0, 0, 0);
+          rangeStart = d.getTime();
+          rangeEnd = Date.now();
+          rangeDate = d.toISOString().slice(0, 10);
+        }
+
+        const relevantKinds = new Set(["file_event", "completion", "plan_ready", "assistant_final"]);
+        const entries = (runtime.recentTimelineEntries || [])
+          .filter((e) => e.createdAtMs >= rangeStart && e.createdAtMs < rangeEnd && relevantKinds.has(e.kind))
+          .map((e) => ({
+            kind: e.kind,
+            title: e.title || "",
+            summary: e.summary || "",
+            threadLabel: e.threadLabel || "",
+            createdAtMs: e.createdAtMs,
+          }));
+        return writeJson(res, 200, { date: rangeDate, slot: slot || "full", entries });
+      }
+
       if (url.pathname === "/api/push/status" && req.method === "GET") {
         const session = requireApiSession(req, res, config, state);
         if (!session) {
@@ -11135,6 +11519,324 @@ function createNativeApprovalServer({ config, runtime, state }) {
         });
       }
 
+      if (url.pathname === "/api/providers/moltbook/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 sourceId = cleanText(body.sourceId || "");
+        if (!sourceId) {
+          return writeJson(res, 400, { error: "missing-sourceId" });
+        }
+        const eventType = String(body.eventType || "reply_request");
+        if (eventType === "resolve") {
+          const token = historyToken(`moltbook:${sourceId}`);
+          runtime.moltbookItemsByToken.delete(token);
+          return writeJson(res, 200, { ok: true });
+        }
+        const token = historyToken(`moltbook:${sourceId}`);
+        const item = {
+          token,
+          sourceId,
+          threadId: cleanText(body.threadId || "moltbook"),
+          threadLabel: cleanText(body.threadLabel || "Moltbook"),
+          title: cleanText(body.title || "Moltbook reply"),
+          summary: cleanText(body.summary || ""),
+          contextText: cleanText(body.contextText || ""),
+          draftReply: cleanText(body.draftReply || ""),
+          callbackUrl: cleanText(body.callbackUrl || ""),
+          postUrl: cleanText(body.postUrl || ""),
+          commentAuthor: cleanText(body.commentAuthor || ""),
+          createdAtMs: Number(body.createdAtMs) || Date.now(),
+          resolved: false,
+        };
+        runtime.moltbookItemsByToken.set(token, item);
+        try {
+          recordTimelineEntry({
+            config,
+            runtime,
+            state,
+            entry: {
+              stableId: `moltbook_reply:${sourceId}`,
+              token,
+              kind: "moltbook_reply",
+              threadId: item.threadId,
+              threadLabel: item.threadLabel,
+              title: item.title,
+              summary: item.summary,
+              messageText: item.contextText,
+              createdAtMs: item.createdAtMs,
+              readOnly: false,
+              provider: "moltbook",
+            },
+          });
+          await saveState(config.stateFile, state);
+        } catch (error) {
+          console.error(`[moltbook-timeline-save] ${error.message}`);
+        }
+        try {
+          await deliverWebPushItem({
+            config,
+            state,
+            kind: "moltbook_reply",
+            token,
+            stableId: `moltbook_reply:${item.sourceId}`,
+            title: item.title,
+            body: item.summary,
+          });
+        } catch (error) {
+          console.error(`[moltbook-push-error] ${error.message}`);
+        }
+        return writeJson(res, 200, { ok: true, token });
+      }
+
+      const apiMoltbookReplyMatch = url.pathname.match(/^\/api\/items\/moltbook\/([^/]+)\/reply$/u);
+      if (apiMoltbookReplyMatch && req.method === "POST") {
+        const session = requireMutatingApiSession(req, res, config, state);
+        if (!session) {
+          return;
+        }
+        const token = decodeURIComponent(apiMoltbookReplyMatch[1]);
+        const item = runtime.moltbookItemsByToken.get(token);
+        if (!item) {
+          return writeJson(res, 404, { error: "item-not-found" });
+        }
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+        const action = String(body.action || "send");
+        const text = cleanText(body.text || "");
+        if (action === "send" && !text) {
+          return writeJson(res, 400, { error: "empty-reply" });
+        }
+        if (item.callbackUrl) {
+          try {
+            const callbackRes = await fetch(item.callbackUrl, {
+              method: "POST",
+              headers: {
+                "content-type": "application/json",
+                "x-viveworker-hook-secret": config.sessionSecret || "",
+              },
+              body: JSON.stringify({
+                sourceId: item.sourceId,
+                action,
+                text,
+              }),
+            });
+            if (!callbackRes.ok) {
+              return writeJson(res, 502, { error: `callback-failed-${callbackRes.status}` });
+            }
+          } catch (error) {
+            return writeJson(res, 502, { error: `callback-error: ${error.message}` });
+          }
+        }
+        item.resolved = true;
+        runtime.moltbookItemsByToken.delete(token);
+        return writeJson(res, 200, { ok: true, action });
+      }
+
+      // ---------------------------------------------------------------
+      // Moltbook scout draft channel
+      //
+      // The standalone scout CLI (`viveworker moltbook propose`) submits
+      // a draft reply via POST /api/providers/moltbook/draft, then long-
+      // polls /api/providers/moltbook/draft/:token/decision until the
+      // phone responds via POST /api/items/moltbook-draft/:token/decision.
+      // ---------------------------------------------------------------
+
+      if (url.pathname === "/api/providers/moltbook/draft" && 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 sourceId = cleanText(body.sourceId || "");
+        const postId = cleanText(body.postId || "");
+        const draftText = cleanText(body.draftText || "");
+        const draftType = cleanText(body.draftType || "reply");
+        const submoltName = cleanText(body.submoltName || "");
+        if (!sourceId || !draftText) {
+          return writeJson(res, 400, { error: "missing-sourceId-or-draftText" });
+        }
+        if (draftType === "reply" && !postId) {
+          return writeJson(res, 400, { error: "missing-postId-for-reply" });
+        }
+        const token = historyToken(`moltbook_draft:${sourceId}`);
+        const postTitle = cleanText(body.postTitle || "");
+        const postUrl = cleanText(body.postUrl || `https://www.moltbook.com/post/${postId}`);
+        const contextSummary = cleanText(body.contextSummary || "");
+        const postAuthor = cleanText(body.postAuthor || "");
+        const postBody = typeof body.postBody === "string" ? body.postBody : "";
+        const intent = typeof body.intent === "string" ? body.intent : "";
+        const slot = cleanText(body.slot || "");
+        const draft = {
+          token,
+          sourceId,
+          postId,
+          postTitle,
+          postAuthor,
+          postBody,
+          postUrl,
+          parentCommentId: cleanText(body.parentCommentId || ""),
+          draftText,
+          draftType,
+          submoltName,
+          intent,
+          slot,
+          contextSummary,
+          createdAtMs: Date.now(),
+          decisionWaiters: [],
+          decision: null,
+        };
+        runtime.moltbookDraftsByToken.set(token, draft);
+        try {
+          recordTimelineEntry({
+            config,
+            runtime,
+            state,
+            entry: {
+              stableId: `moltbook_draft:${sourceId}`,
+              token,
+              kind: "moltbook_draft",
+              threadId: "moltbook",
+              threadLabel: "Moltbook",
+              title: draftType === "original_post"
+                ? (postTitle || "Moltbook new post")
+                : (postTitle ? `draft → ${postTitle}` : "Moltbook draft"),
+              summary: contextSummary || String(draftText).slice(0, 160),
+              messageText: contextSummary || draftText,
+              draftText,
+              draftType,
+              submoltName,
+              intent,
+              slot,
+              postId,
+              postUrl,
+              postTitle,
+              postAuthor,
+              postBody,
+              createdAtMs: draft.createdAtMs,
+              readOnly: false,
+              provider: "moltbook",
+            },
+          });
+          await saveState(config.stateFile, state);
+        } catch (error) {
+          console.error(`[moltbook-draft-timeline-save] ${error.message}`);
+        }
+        try {
+          const pushTitle = (() => {
+            if (draftType !== "original_post") {
+              return postTitle ? `draft → ${postTitle}` : "Moltbook draft";
+            }
+            const greetings = {
+              morning: { en: "Good morning! Share yesterday's highlights?", ja: "おはようございます！昨日の成果をシェアしませんか？" },
+              noon: { en: "Nice progress! Ready to share your morning work?", ja: "午前中お疲れ様でした！進捗をシェアしませんか？" },
+              evening: { en: "Great work today! Let's share what you built.", ja: "今日もお疲れ様でした！成果をシェアしませんか？" },
+            };
+            const locale = config.locale || "en";
+            const lang = locale.startsWith("ja") ? "ja" : "en";
+            const g = greetings[slot];
+            return g ? g[lang] : (postTitle || "Moltbook new post");
+          })();
+          await deliverWebPushItem({
+            config,
+            state,
+            kind: "moltbook_draft",
+            token,
+            stableId: `moltbook_draft:${sourceId}`,
+            title: pushTitle,
+            body: draftType === "original_post" ? (postTitle || String(draftText).slice(0, 160)) : String(draftText).slice(0, 160),
+          });
+        } catch (error) {
+          console.error(`[moltbook-draft-push-error] ${error.message}`);
+        }
+        return writeJson(res, 200, { ok: true, token });
+      }
+
+      const apiMoltbookDraftDecisionGet = url.pathname.match(
+        /^\/api\/providers\/moltbook\/draft\/([^/]+)\/decision$/u
+      );
+      if (apiMoltbookDraftDecisionGet && req.method === "GET") {
+        const hookSecret = req.headers["x-viveworker-hook-secret"] || "";
+        if (!config.sessionSecret || hookSecret !== config.sessionSecret) {
+          return writeJson(res, 401, { error: "unauthorized" });
+        }
+        const token = decodeURIComponent(apiMoltbookDraftDecisionGet[1]);
+        const draft = runtime.moltbookDraftsByToken.get(token);
+        if (!draft) return writeJson(res, 404, { error: "draft-not-found" });
+        if (draft.decision) {
+          return writeJson(res, 200, { status: "decided", ...draft.decision });
+        }
+        const waitParam = Number(url.searchParams.get("wait")) || 25;
+        const waitMs = Math.min(Math.max(waitParam, 1), 60) * 1000;
+        const decided = await new Promise((resolve) => {
+          const timer = setTimeout(() => {
+            const idx = draft.decisionWaiters.indexOf(resolve);
+            if (idx !== -1) draft.decisionWaiters.splice(idx, 1);
+            resolve(null);
+          }, waitMs);
+          draft.decisionWaiters.push((d) => {
+            clearTimeout(timer);
+            resolve(d);
+          });
+        });
+        if (decided) return writeJson(res, 200, { status: "decided", ...decided });
+        return writeJson(res, 200, { status: "pending" });
+      }
+
+      const apiMoltbookDraftDecide = url.pathname.match(
+        /^\/api\/items\/moltbook-draft\/([^/]+)\/decision$/u
+      );
+      if (apiMoltbookDraftDecide && req.method === "POST") {
+        const session = requireMutatingApiSession(req, res, config, state);
+        if (!session) return;
+        const token = decodeURIComponent(apiMoltbookDraftDecide[1]);
+        const draft = runtime.moltbookDraftsByToken.get(token);
+        if (!draft) return writeJson(res, 404, { error: "draft-not-found" });
+        let body;
+        try {
+          body = await parseJsonBody(req);
+        } catch {
+          return writeJson(res, 400, { error: "invalid-json-body" });
+        }
+        const action = String(body.action || "") === "approve" ? "approve" : "deny";
+        const editedText = cleanText(body.editedText || "");
+        const editedTitle = cleanText(body.editedTitle || "");
+        const decision = {
+          action,
+          text: action === "approve" ? editedText || draft.draftText : "",
+          title: action === "approve" ? editedTitle || draft.postTitle : "",
+          decidedAtMs: Date.now(),
+        };
+        draft.decision = decision;
+        for (const waiter of draft.decisionWaiters.splice(0)) {
+          try {
+            waiter(decision);
+          } catch {
+            // ignore
+          }
+        }
+        // Keep the entry in moltbookDraftsByToken briefly so a slow long-
+        // poll can still pick it up; sweeper below removes it after 2min.
+        setTimeout(() => runtime.moltbookDraftsByToken.delete(token), 120 * 1000).unref?.();
+        return writeJson(res, 200, { ok: true, action });
+      }
+
       if (url.pathname === "/api/inbox" && req.method === "GET") {
         const session = requireApiSession(req, res, config, state);
         if (!session) {
@@ -13044,6 +13746,37 @@ function isLoopbackHostname(value) {
   return normalized === "127.0.0.1" || normalized === "::1" || normalized === "localhost";
 }
 
+function readA2AEnvKey() {
+  try {
+    const envPath = path.join(os.homedir(), ".viveworker", "a2a.env");
+    const raw = readFileSync(envPath, "utf8");
+    for (const line of raw.split(/\r?\n/u)) {
+      const m = line.match(/^\s*A2A_API_KEY\s*=\s*(.+?)\s*$/u);
+      if (m) return m[1].replace(/^['"]|['"]$/gu, "");
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
+function readMoltbookEnvKey() {
+  // Fall back to the standalone watcher's env file so the bridge can detect
+  // a configured Moltbook integration without requiring MOLTBOOK_API_KEY to
+  // be duplicated into its launchd plist.
+  try {
+    const envPath = path.join(os.homedir(), ".viveworker", "moltbook.env");
+    const raw = readFileSync(envPath, "utf8");
+    for (const line of raw.split(/\r?\n/u)) {
+      const m = line.match(/^\s*MOLTBOOK_API_KEY\s*=\s*(.+?)\s*$/u);
+      if (m) return m[1].replace(/^['"]|['"]$/gu, "");
+    }
+  } catch {
+    // ignore
+  }
+  return "";
+}
+
 function buildConfig(cli) {
   const codexHome = resolvePath(process.env.CODEX_HOME || path.join(os.homedir(), ".codex"));
   const stateFile = resolvePath(process.env.STATE_FILE || path.join(workspaceRoot, ".viveworker-state.json"));
@@ -13051,6 +13784,13 @@ function buildConfig(cli) {
     dryRun: cli.dryRun || truthy(process.env.DRY_RUN),
     once: cli.once,
     codexHome,
+    moltbookApiKey: cleanText(process.env.MOLTBOOK_API_KEY || readMoltbookEnvKey() || ""),
+    a2aApiKey: cleanText(process.env.A2A_API_KEY || readA2AEnvKey() || ""),
+    a2aPublicUrl: cleanText(process.env.A2A_PUBLIC_URL || ""),
+    a2aRelayUrl: cleanText(process.env.A2A_RELAY_URL || ""),
+    a2aRelayUserId: cleanText(process.env.A2A_RELAY_USER_ID || ""),
+    a2aRelaySecret: cleanText(process.env.A2A_RELAY_SECRET || ""),
+    a2aRelayRegisterSecret: cleanText(process.env.A2A_RELAY_REGISTER_SECRET || ""),
     webUiEnabled: boolEnv("WEB_UI_ENABLED", true),
     authRequired: boolEnv("AUTH_REQUIRED", true),
     webPushEnabled: boolEnv("WEB_PUSH_ENABLED", false),
@@ -13844,6 +14584,12 @@ function refreshResolvedThreadLabels({ config, runtime, state }) {
 
   const nextTimelineEntries = normalizeTimelineEntries(
     runtime.recentTimelineEntries.map((entry) => {
+      // Moltbook entries carry their own author-provided title/threadLabel
+      // (e.g. "@broanbot commented"). Skip the native-thread relabel pass so
+      // we don't overwrite them with the UUID-head fallback.
+      if (normalizeProvider(entry.provider) === "moltbook") {
+        return entry;
+      }
       const threadId = cleanText(entry.threadId || "");
       if (!threadId) {
         return entry;
@@ -14418,6 +15164,24 @@ async function main() {
       }
     }
 
+    // --- A2A Relay ---
+    if (config.a2aRelayUrl && config.a2aRelayUserId) {
+      const regResult = await registerWithRelay({ config, buildAgentCard });
+      if (regResult.ok) {
+        startRelayPolling({
+          config,
+          runtime,
+          state,
+          helpers: { recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText },
+        });
+      } else {
+        console.error(`[a2a-relay] Registration failed: ${regResult.error}`);
+      }
+    }
+
+    let lastA2aEnvCheckAt = 0;
+    const A2A_ENV_CHECK_INTERVAL_MS = 30_000; // check every 30 seconds
+
     while (!runtime.stopping) {
       try {
         const dirty = await scanOnce({ config, runtime, state });
@@ -14428,6 +15192,38 @@ async function main() {
         console.error(`[scan-error] ${error.message}`);
       }
 
+      // Hot-reload: detect a2a.env changes and auto-start relay
+      const now = Date.now();
+      if (!config.a2aRelayUrl && now - lastA2aEnvCheckAt > A2A_ENV_CHECK_INTERVAL_MS) {
+        lastA2aEnvCheckAt = now;
+        try {
+          loadEnvFile(path.join(os.homedir(), ".viveworker", "a2a.env"));
+          const newRelayUrl = cleanText(process.env.A2A_RELAY_URL || "");
+          const newRelayUserId = cleanText(process.env.A2A_RELAY_USER_ID || "");
+          const newRelayRegisterSecret = cleanText(process.env.A2A_RELAY_REGISTER_SECRET || "");
+          if (newRelayUrl && newRelayUserId) {
+            config.a2aRelayUrl = newRelayUrl;
+            config.a2aRelayUserId = newRelayUserId;
+            config.a2aRelayRegisterSecret = newRelayRegisterSecret;
+            config.a2aApiKey = cleanText(process.env.A2A_API_KEY || config.a2aApiKey || "");
+            console.log(`[a2a-relay] Detected new relay config, registering...`);
+            const regResult = await registerWithRelay({ config, buildAgentCard });
+            if (regResult.ok) {
+              startRelayPolling({
+                config,
+                runtime,
+                state,
+                helpers: { recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText },
+              });
+            } else {
+              console.error(`[a2a-relay] Registration failed: ${regResult.error}`);
+            }
+          }
+        } catch (error) {
+          // ignore — env file may not exist yet
+        }
+      }
+
       if (config.once) {
         break;
       }
@@ -14437,6 +15233,8 @@ async function main() {
   } finally {
     runtime.stopping = true;
 
+    stopRelayPolling();
+
     if (runtime.ipcClient) {
       runtime.ipcClient.stop();
     }