viveworker 0.2.0 → 0.3.0

package/scripts/viveworker-bridge.mjs

@@ -26,7 +26,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;
@@ -79,6 +79,8 @@ const runtime = {
   userInputRequestsByToken: new Map(),
   userInputRequestsByRequestKey: new Map(),
   completionDetailsByToken: new Map(),
+  moltbookItemsByToken: new Map(),
+  moltbookDraftsByToken: new Map(),
   planDetailsByToken: new Map(),
   recentHistoryItems: [],
   recentTimelineEntries: [],
@@ -212,6 +214,7 @@ function buildSessionLocalePayload(config, state, deviceId) {
     deviceDetectedLocale: resolved.detectedLocale || null,
     deviceOverrideLocale: resolved.overrideLocale || null,
     claudeAwayMode: state?.claudeAwayMode === true,
+    moltbookEnabled: Boolean(config.moltbookApiKey),
   };
 }
 
@@ -1989,11 +1992,16 @@ 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";
+  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";
+  return t(locale, "common.codex");
 }
 
 function normalizeHistoryItems(rawItems, maxItems) {
@@ -2174,14 +2182,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 +2228,19 @@ 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) } : {}),
   };
 }
 
@@ -8982,6 +9007,26 @@ 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",
+    });
+  }
+
+  // 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 +9346,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 +10459,80 @@ 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 || "",
+      createdAtMs: source.createdAtMs || Date.now(),
+      readOnly: !draft || Boolean(draft?.decision),
+      actions: [],
+      moltbookDraftEnabled: Boolean(draft) && !draft.decision,
+    };
+  }
+
   const historyItem = historyItemByToken(runtime, kind, token);
   return historyItem ? buildHistoryDetail(historyItem, locale, runtime) : null;
 }
@@ -10799,6 +10918,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 +11344,309 @@ 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 draft = {
+          token,
+          sourceId,
+          postId,
+          postTitle,
+          postAuthor,
+          postBody,
+          postUrl,
+          parentCommentId: cleanText(body.parentCommentId || ""),
+          draftText,
+          draftType,
+          submoltName,
+          intent,
+          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,
+              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 {
+          await deliverWebPushItem({
+            config,
+            state,
+            kind: "moltbook_draft",
+            token,
+            stableId: `moltbook_draft:${sourceId}`,
+            title: draftType === "original_post"
+              ? (postTitle || "Moltbook new post")
+              : (postTitle ? `draft → ${postTitle}` : "Moltbook draft"),
+            body: 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 +13556,23 @@ function isLoopbackHostname(value) {
   return normalized === "127.0.0.1" || normalized === "::1" || normalized === "localhost";
 }
 
+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 +13580,7 @@ function buildConfig(cli) {
     dryRun: cli.dryRun || truthy(process.env.DRY_RUN),
     once: cli.once,
     codexHome,
+    moltbookApiKey: cleanText(process.env.MOLTBOOK_API_KEY || readMoltbookEnvKey() || ""),
     webUiEnabled: boolEnv("WEB_UI_ENABLED", true),
     authRequired: boolEnv("AUTH_REQUIRED", true),
     webPushEnabled: boolEnv("WEB_PUSH_ENABLED", false),
@@ -13844,6 +14374,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;

package/scripts/viveworker-claude-hook.mjs

@@ -181,7 +181,13 @@ async function handlePermissionRequest() {
   }
 
   const result = await postEvent("PermissionRequest", body, APPROVAL_TIMEOUT_MS);
-  const behavior = String(result?.permissionDecision || "deny") === "allow" ? "allow" : "deny";
+  // If the bridge is unreachable, postEvent resolves to {} with no
+  // permissionDecision field. Distinguish that from an explicit deny and
+  // fall back to Claude Code's default permission flow instead of blocking.
+  if (!result || typeof result.permissionDecision !== "string") {
+    return;
+  }
+  const behavior = result.permissionDecision === "allow" ? "allow" : "deny";
   const reason = typeof result?.permissionDecisionReason === "string" ? result.permissionDecisionReason : "";
 
   const decision = { behavior };