viveworker 0.5.2 → 0.5.5

package/scripts/viveworker-bridge.mjs

@@ -18,7 +18,7 @@ import { generatePairingCredentials, shouldRotatePairing, upsertEnvText } from "
 import { renderMarkdownHtml } from "./lib/markdown-render.mjs";
 import { buildAgentCard, handleA2ARequest, resolveA2ATaskDecision, completeA2ATask, failA2ATask } from "./a2a-handler.mjs";
 import { registerWithRelay, startRelayPolling, stopRelayPolling, postRelayResult, getRelayStatus, updatePublicTasksFlag } from "./a2a-relay-client.mjs";
-import { createMoltbookClient, readScoutState, writeScoutState, rollScoutDayIfNeeded, markPostSeen, recordComposeAttempt, writeDraft, readDraft, deleteDraft, listPendingDrafts, solveVerificationPuzzle, solvePuzzleWithLLM } from "./moltbook-api.mjs";
+import { createMoltbookClient, readScoutState, writeScoutState, rollScoutDayIfNeeded, markPostSeen, recordComposeAttempt, writeDraft, readDraft, deleteDraft, listPendingDrafts, solveVerificationPuzzle, solvePuzzleWithLLM, listInboxItems } from "./moltbook-api.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -29,7 +29,7 @@ const sessionCookieName = "viveworker_session";
 const deviceCookieName = "viveworker_device";
 const historyKinds = new Set(["completion", "assistant_final", "plan_ready", "approval", "plan", "choice", "info", "moltbook_reply", "moltbook_draft", "thread_share", "a2a_task", "a2a_task_result"]);
 const timelineMessageKinds = new Set(["user_message", "assistant_commentary", "assistant_final"]);
-const timelineKinds = new Set([...timelineMessageKinds, "approval", "plan", "choice", "plan_ready", "file_event", "moltbook_reply", "moltbook_draft", "thread_share", "a2a_task", "a2a_task_result"]);
+const timelineKinds = new Set([...timelineMessageKinds, "ambient_suggestions", "approval", "plan", "choice", "plan_ready", "file_event", "moltbook_reply", "moltbook_draft", "thread_share", "a2a_task", "a2a_task_result"]);
 const SQLITE_COMPLETION_BATCH_SIZE = 200;
 const DEFAULT_DEVICE_TRUST_TTL_MS = 30 * 24 * 60 * 60 * 1000;
 const MAX_PAIRED_DEVICES = 200;
@@ -95,6 +95,11 @@ const runtime = {
   pairingAttemptsByRemoteAddress: new Map(),
   ipcClient: null,
   stopping: false,
+  // In-memory cache for the `/api/share/status` endpoint. A 30s TTL avoids
+  // hammering the share worker on every settings-page render. Purely runtime —
+  // deliberately NOT persisted via `state` since the cache is worthless after
+  // a restart and would just bloat the state file.
+  a2aShareStatusCache: null,
 };
 const state = await loadState(config.stateFile);
 runtime.threadRegistry = await loadThreadRegistry(config.threadRegistryFile);
@@ -156,8 +161,10 @@ runtime.recentHistoryItems = initialHistoryItems;
 runtime.recentTimelineEntries = initialTimelineEntries;
 state.recentHistoryItems = initialHistoryItems;
 state.recentTimelineEntries = initialTimelineEntries;
+const backfilledAmbientSuggestionsStateChanged = backfillAmbientSuggestionsState({ config, runtime, state });
 const migratedRecentCodeEventsStateChanged = migrateRecentCodeEventsState({ config, runtime, state });
 const restoredTimelineImagePathsStateChanged = await backfillPersistedTimelineImagePaths({ config, runtime, state });
+const backfilledMoltbookInboxChanged = await backfillMoltbookInboxHistory({ config, runtime, state });
 runtime.historyFileState.offset = Number(state.historyFileOffset) || 0;
 runtime.historyFileState.sourceFile = cleanText(state.historyFileSourceFile ?? "");
 
@@ -269,6 +276,9 @@ function buildSessionLocalePayload(config, state, deviceId) {
     moltbookEnabled: Boolean(config.moltbookApiKey),
     a2aEnabled: Boolean(config.a2aApiKey),
     a2aRelayEnabled: Boolean(config.a2aRelayUrl && config.a2aRelayUserId),
+    // Share piggy-backs on A2A credentials — it's "enabled" as soon as both
+    // halves (user id + API key) are provisioned.
+    a2aShareEnabled: Boolean(config.a2aRelayUserId && config.a2aApiKey),
     a2aExecutors: runtime.a2aAvailableExecutors || { codex: false, claude: false },
     a2aExecutorPreference: state.a2aExecutorPreference || "ask",
   };
@@ -282,6 +292,8 @@ function kindTitle(locale, kind) {
       return t(locale, "server.title.assistantCommentary");
     case "assistant_final":
       return t(locale, "server.title.assistantFinal");
+    case "ambient_suggestions":
+      return t(locale, "server.title.ambientSuggestions");
     case "approval":
       return t(locale, "server.title.approval");
     case "plan":
@@ -310,6 +322,117 @@ function kindTitle(locale, kind) {
   }
 }
 
+function normalizeAmbientSuggestion(raw) {
+  if (!isPlainObject(raw)) {
+    return null;
+  }
+
+  const title = cleanText(raw.title ?? "");
+  const prompt = normalizeLongText(raw.prompt ?? "");
+  if (!title || !prompt) {
+    return null;
+  }
+
+  const threadAction = isPlainObject(raw.threadAction)
+    ? {
+        ...(cleanText(raw.threadAction.type ?? "") ? { type: cleanText(raw.threadAction.type) } : {}),
+      }
+    : null;
+  const appIds = Array.isArray(raw.appIds)
+    ? raw.appIds.map((value) => cleanText(value ?? "")).filter(Boolean)
+    : [];
+
+  return {
+    ...(cleanText(raw.id ?? "") ? { id: cleanText(raw.id) } : {}),
+    title,
+    prompt,
+    ...(cleanText(raw.description ?? "") ? { description: cleanText(raw.description) } : {}),
+    ...(threadAction && threadAction.type ? { threadAction } : {}),
+    ...(appIds.length > 0 ? { appIds } : {}),
+  };
+}
+
+function normalizeAmbientSuggestions(raw) {
+  if (!Array.isArray(raw)) {
+    return [];
+  }
+  return raw.map((entry) => normalizeAmbientSuggestion(entry)).filter(Boolean);
+}
+
+function parseAmbientSuggestionsEnvelope(value) {
+  const normalized = cleanText(value ?? "");
+  if (!normalized) {
+    return null;
+  }
+
+  let payload;
+  try {
+    payload = JSON.parse(normalized);
+  } catch {
+    return null;
+  }
+
+  if (!isPlainObject(payload)) {
+    return null;
+  }
+
+  const hasSuggestionsField = Array.isArray(payload.suggestions);
+  const hasExcludeField = Array.isArray(payload.exclude);
+  if (!hasSuggestionsField && !hasExcludeField) {
+    return null;
+  }
+
+  const suggestions = hasSuggestionsField ? normalizeAmbientSuggestions(payload.suggestions) : [];
+  if (suggestions.length > 0) {
+    return { type: "suggestions", suggestions };
+  }
+
+  return {
+    type: "metadata",
+    hasSuggestionsField,
+    hasExcludeField,
+  };
+}
+
+function parseAmbientSuggestionsPayload(value) {
+  const envelope = parseAmbientSuggestionsEnvelope(value);
+  return envelope?.type === "suggestions" ? envelope.suggestions : null;
+}
+
+function isAmbientSuggestionsMetadataPayload(value) {
+  return parseAmbientSuggestionsEnvelope(value) !== null;
+}
+
+function ambientSuggestionsSummary(locale, suggestions) {
+  const count = Math.max(0, Array.isArray(suggestions) ? suggestions.length : 0);
+  if (count <= 0) {
+    return "";
+  }
+  const firstTitle = cleanText(suggestions[0]?.title || "");
+  return t(locale, "summary.ambientSuggestions", {
+    count,
+    firstTitle,
+    more: Math.max(0, count - 1),
+  });
+}
+
+function ambientSuggestionsMessageText(locale, suggestions) {
+  if (!Array.isArray(suggestions) || suggestions.length === 0) {
+    return "";
+  }
+  return [
+    kindTitle(locale, "ambient_suggestions"),
+    "",
+    ...suggestions.flatMap((suggestion, index) => {
+      const description = cleanText(suggestion.description || "");
+      return [
+        `${index + 1}. ${cleanText(suggestion.title || "")}`,
+        ...(description ? [description] : []),
+      ];
+    }),
+  ].join("\n");
+}
+
 function looksLikeGeneratedThreadTitle(value) {
   const normalized = cleanText(value || "");
   if (!normalized.includes("|")) {
@@ -2241,6 +2364,8 @@ function timelineKindSortPriority(kind) {
     case "plan_ready":
     case "choice":
       return 60;
+    case "ambient_suggestions":
+      return 52;
     case "file_event":
       return 45;
     case "assistant_final":
@@ -2272,6 +2397,10 @@ function normalizeTimelineEntry(raw) {
   const diffText = normalizeTimelineDiffText(raw.diffText ?? "");
   const diffSource = normalizeTimelineDiffSource(raw.diffSource ?? "");
   const diffCounts = diffLineCounts(diffText);
+  const suggestions = normalizeAmbientSuggestions(raw.suggestions ?? []);
+  if (kind === "ambient_suggestions" && suggestions.length === 0) {
+    return null;
+  }
   const summary =
     normalizeNotificationText(raw.summary ?? "") ||
     formatNotificationBody(messageText, 180) ||
@@ -2342,6 +2471,7 @@ function normalizeTimelineEntry(raw) {
     // A2A task-specific fields
     ...(raw.instruction != null ? { instruction: cleanText(raw.instruction) } : {}),
     ...(raw.taskStatus != null ? { taskStatus: cleanText(raw.taskStatus) } : {}),
+    ...(suggestions.length > 0 ? { suggestions } : {}),
   };
 }
 
@@ -2516,6 +2646,9 @@ function historyItemFromEvent(event) {
 
   const kind = event.kind === "task_complete" ? "completion" : "plan_ready";
   const messageText = normalizeLongText(event.detailText || event.message || "");
+  if (kind === "completion" && isAmbientSuggestionsMetadataPayload(messageText)) {
+    return null;
+  }
   return normalizeHistoryItem({
     stableId: event.id,
     kind,
@@ -2549,6 +2682,94 @@ function recordHistoryItem({ config, runtime, state, item }) {
   return changed;
 }
 
+function backfillAmbientSuggestionsState({ config, runtime, state }) {
+  const nextTimelineEntries = normalizeTimelineEntries(
+    (runtime.recentTimelineEntries ?? []).map((entry) => {
+      const entryKind = cleanText(entry?.kind || "");
+      if (entryKind === "ambient_suggestions") {
+        const suggestions = normalizeAmbientSuggestions(entry?.suggestions ?? []);
+        if (suggestions.length === 0) {
+          return null;
+        }
+        return {
+          ...entry,
+          title: kindTitle(DEFAULT_LOCALE, "ambient_suggestions"),
+          summary: ambientSuggestionsSummary(DEFAULT_LOCALE, suggestions),
+          messageText: ambientSuggestionsMessageText(DEFAULT_LOCALE, suggestions),
+          suggestions,
+        };
+      }
+      if (entryKind !== "assistant_final") {
+        return entry;
+      }
+      const envelope = parseAmbientSuggestionsEnvelope(entry?.messageText ?? "");
+      if (!envelope) {
+        return entry;
+      }
+      if (envelope.type !== "suggestions") {
+        return null;
+      }
+      const suggestions = envelope.suggestions;
+      return {
+        ...entry,
+        kind: "ambient_suggestions",
+        title: kindTitle(DEFAULT_LOCALE, "ambient_suggestions"),
+        summary: ambientSuggestionsSummary(DEFAULT_LOCALE, suggestions),
+        messageText: ambientSuggestionsMessageText(DEFAULT_LOCALE, suggestions),
+        suggestions,
+      };
+    }),
+    config.maxTimelineEntries
+  );
+
+  const nextHistoryItems = normalizeHistoryItems(
+    (runtime.recentHistoryItems ?? []).filter((item) => {
+      const kind = cleanText(item?.kind || "");
+      if (kind !== "assistant_final" && kind !== "completion") {
+        return true;
+      }
+      return !isAmbientSuggestionsMetadataPayload(item?.messageText ?? "");
+    }),
+    config.maxHistoryItems
+  );
+
+  const timelineChanged =
+    JSON.stringify(nextTimelineEntries) !== JSON.stringify(runtime.recentTimelineEntries ?? []);
+  const historyChanged =
+    JSON.stringify(nextHistoryItems) !== JSON.stringify(runtime.recentHistoryItems ?? []);
+
+  if (timelineChanged) {
+    runtime.recentTimelineEntries = nextTimelineEntries;
+    state.recentTimelineEntries = nextTimelineEntries;
+  }
+  if (historyChanged) {
+    runtime.recentHistoryItems = nextHistoryItems;
+    state.recentHistoryItems = nextHistoryItems;
+  }
+
+  return timelineChanged || historyChanged;
+}
+
+// Flip a previously-recorded history item's readOnly flag without disturbing
+// its ordering or other fields.  Used by moltbook_reply / moltbook_draft flows
+// to transition pending → resolved so the entry starts matching the completed
+// tab's readOnly filter.  Returns true if a mutation happened (caller should
+// saveState in that case).
+function flipHistoryItemReadOnly({ runtime, state, stableId, readOnly = true }) {
+  const normalizedStableId = cleanText(stableId || "");
+  if (!normalizedStableId) return false;
+  const idx = runtime.recentHistoryItems.findIndex((entry) => entry.stableId === normalizedStableId);
+  if (idx === -1) return false;
+  const current = runtime.recentHistoryItems[idx];
+  if (current.readOnly === readOnly) return false;
+  const next = { ...current, readOnly };
+  const nextItems = runtime.recentHistoryItems.slice();
+  nextItems[idx] = next;
+  runtime.recentHistoryItems = nextItems;
+  state.recentHistoryItems = nextItems;
+  return true;
+}
+
 function recordActionHistoryItem({
   config,
   runtime,
@@ -3760,6 +3981,66 @@ async function backfillPersistedTimelineImagePaths({ config, runtime, state }) {
   return true;
 }
 
+// Walk ~/.viveworker/moltbook-inbox/ on startup and synthesize readOnly
+// history entries for items the CLI / reconcile marked as replied or skipped.
+// Without this, an inbox item that was handled before the history hooks
+// existed — or that was resolved purely via the CLI path, which doesn't touch
+// the bridge's in-memory maps — never makes it into `recentHistoryItems` and
+// so never appears in the completed tab.  We match the same stableId / token
+// scheme as the live push (sourceId = `comment:<commentId>`) so a future
+// watcher push for the same commentId replaces this entry cleanly rather than
+// creating a duplicate.
+async function backfillMoltbookInboxHistory({ config, runtime, state }) {
+  let changed = false;
+  try {
+    const inboxItems = await listInboxItems();
+    for (const inbox of inboxItems) {
+      const status = String(inbox?.status || "").toLowerCase();
+      if (status !== "replied" && status !== "skipped") continue;
+      const commentId = String(inbox?.commentId || "");
+      if (!commentId) continue;
+      const sourceId = `comment:${commentId}`;
+      const stableId = `moltbook_reply:${sourceId}`;
+      if (runtime.recentHistoryItems.some((entry) => entry.stableId === stableId)) continue;
+      const token = historyToken(`moltbook:${sourceId}`);
+      const createdAtMs = Number(Date.parse(inbox.updatedAt || inbox.createdAt || "")) || Date.now();
+      const postTitle = cleanText(inbox.postTitle || "");
+      const contextText = cleanText(inbox.contextText || "");
+      const replyText = cleanText(inbox.replyText || "");
+      const messageText = status === "replied" ? (replyText || contextText) : contextText;
+      const summary = (status === "replied" ? (replyText || contextText) : contextText).slice(0, 160);
+      const titlePrefix = status === "replied" ? "replied" : "skipped";
+      const title = postTitle ? `${titlePrefix} → ${postTitle}` : (status === "replied" ? "Moltbook reply" : "Moltbook skipped");
+      const recorded = recordHistoryItem({
+        config,
+        runtime,
+        state,
+        item: {
+          stableId,
+          token,
+          kind: "moltbook_reply",
+          threadId: "moltbook",
+          threadLabel: postTitle || "Moltbook",
+          title,
+          summary,
+          messageText,
+          createdAtMs,
+          readOnly: true,
+          provider: "moltbook",
+        },
+      });
+      if (recorded) changed = true;
+    }
+  } catch (error) {
+    console.error(`[moltbook-inbox-backfill] ${error.message}`);
+    return false;
+  }
+  if (changed) {
+    console.log(`[moltbook-inbox-backfill] Synthesized history entries for resolved inbox items`);
+  }
+  return changed;
+}
+
 async function backfillRecentTimelineEntryDiffs({ config, runtime, state }) {
   const nextEntries = runtime.recentTimelineEntries.map((entry) => ({ ...entry }));
   let changed = false;
@@ -4051,6 +4332,20 @@ function buildSqliteTimelineEntry({ row, config, runtime }) {
   if (!messageText) {
     return null;
   }
+  const ambientSuggestionsEnvelope = kind === "assistant_final" ? parseAmbientSuggestionsEnvelope(messageText) : null;
+  if (ambientSuggestionsEnvelope?.type === "metadata") {
+    return null;
+  }
+  const ambientSuggestions = ambientSuggestionsEnvelope?.type === "suggestions"
+    ? ambientSuggestionsEnvelope.suggestions
+    : null;
+  const entryKind = ambientSuggestions ? "ambient_suggestions" : kind;
+  const entryMessageText = ambientSuggestions
+    ? ambientSuggestionsMessageText(config.defaultLocale, ambientSuggestions)
+    : messageText;
+  const entrySummary = ambientSuggestions
+    ? ambientSuggestionsSummary(config.defaultLocale, ambientSuggestions)
+    : formatNotificationBody(messageText, 180) || messageText;
 
   const createdAtMs = Math.max(0, Number(row.ts) || 0) * 1000 || Date.now();
   const threadLabel = getNativeThreadLabel({
@@ -4058,17 +4353,18 @@ function buildSqliteTimelineEntry({ row, config, runtime }) {
     conversationId: threadId,
     cwd: "",
   });
-  const stableId = messageTimelineStableId(kind, threadId, item.id || row.id, messageText, createdAtMs);
+  const stableId = messageTimelineStableId(entryKind, threadId, item.id || row.id, entryMessageText, createdAtMs);
 
   return normalizeTimelineEntry({
     stableId,
     token: historyToken(stableId),
-    kind,
+    kind: entryKind,
     threadId,
     threadLabel,
-    title: threadLabel || kindTitle(config.defaultLocale, kind),
-    summary: formatNotificationBody(messageText, 180) || messageText,
-    messageText,
+    title: ambientSuggestions ? kindTitle(config.defaultLocale, entryKind) : threadLabel || kindTitle(config.defaultLocale, entryKind),
+    summary: entrySummary,
+    messageText: entryMessageText,
+    ...(ambientSuggestions ? { suggestions: ambientSuggestions } : {}),
     createdAtMs,
     readOnly: true,
   });
@@ -4520,7 +4816,11 @@ async function processScannedEvent({ config, runtime, state, event }) {
       item: historyItemFromEvent(event),
     }) || dirty;
 
-  if (event.kind === "task_complete") {
+  const isAmbientSuggestionsCompletion =
+    event.kind === "task_complete" &&
+    isAmbientSuggestionsMetadataPayload(normalizeLongText(event.detailText || event.message || ""));
+
+  if (event.kind === "task_complete" && !isAmbientSuggestionsCompletion) {
     dirty =
       (await deliverWebPushItem({
         config,
@@ -4537,7 +4837,7 @@ async function processScannedEvent({ config, runtime, state, event }) {
       })) || dirty;
   }
 
-  if (config.enableNtfy) {
+  if (config.enableNtfy && !isAmbientSuggestionsCompletion) {
     try {
       await publishNtfy(config, event);
     } catch (error) {
@@ -9262,12 +9562,26 @@ function buildCompletedInboxItems(runtime, state, config, locale) {
   const items = normalizeHistoryItems(state.recentHistoryItems ?? runtime.recentHistoryItems, config.maxHistoryItems);
   runtime.recentHistoryItems = items;
   const completedKinds = new Set(["assistant_final", "approval", "moltbook_reply", "moltbook_draft", "thread_share", "a2a_task_result"]);
-  return items
+
+  // Infrequent kinds (A2A, thread_share) get evicted from the fixed-size
+  // history FIFO by the high volume of approval/assistant_final entries.
+  // Fall back to recentTimelineEntries so completed A2A tasks are never lost
+  // while they're still within the timeline window.
+  const infrequentKinds = new Set(["a2a_task_result", "thread_share"]);
+  const historyStableIds = new Set(items.map((i) => i.stableId).filter(Boolean));
+  const timelineEntries = (runtime.recentTimelineEntries ?? [])
+    .filter((e) => infrequentKinds.has(cleanText(e?.kind || "")) && !historyStableIds.has(e.stableId));
+  const merged = [...items, ...timelineEntries];
+
+  return merged
     .filter((item) => {
       const k = cleanText(item?.kind || "");
       if (!completedKinds.has(k)) return false;
-      // Only resolved approvals (readOnly = true)
-      if (k === "approval" && !item.readOnly) return false;
+      // Only resolved approvals (readOnly = true).  Moltbook reply/draft items
+      // are gated the same way so pending entries don't double-show as
+      // completed while they're also surfaced via moltbookItemsByToken /
+      // moltbookDraftsByToken on the pending list.
+      if ((k === "approval" || k === "moltbook_reply" || k === "moltbook_draft") && !item.readOnly) return false;
       return true;
     })
     .slice()
@@ -9539,22 +9853,44 @@ function buildOperationalTimelineEntries(runtime, state, config, locale) {
   }
 
   for (const historyItem of normalizeHistoryItems(state.recentHistoryItems ?? runtime.recentHistoryItems, config.maxHistoryItems)) {
-    if (!timelineKinds.has(historyItem.kind)) {
+    let historyKind = historyItem.kind;
+    let historySummary = historyItem.summary;
+    let historyMessageText = historyItem.messageText;
+    let historyTitle = historyItem.threadLabel ? formatTitle(kindTitle(locale, historyItem.kind), historyItem.threadLabel) : historyItem.title;
+    let historySuggestions = [];
+
+    if (historyItem.kind === "assistant_final" || historyItem.kind === "completion") {
+      const ambientSuggestionsEnvelope = parseAmbientSuggestionsEnvelope(historyItem.messageText ?? "");
+      if (ambientSuggestionsEnvelope?.type === "metadata") {
+        continue;
+      }
+      if (ambientSuggestionsEnvelope?.type === "suggestions") {
+        const ambientSuggestions = ambientSuggestionsEnvelope.suggestions;
+        historyKind = "ambient_suggestions";
+        historyTitle = kindTitle(locale, historyKind);
+        historySummary = ambientSuggestionsSummary(locale, ambientSuggestions);
+        historyMessageText = ambientSuggestionsMessageText(locale, ambientSuggestions);
+        historySuggestions = ambientSuggestions;
+      }
+    }
+
+    if (!timelineKinds.has(historyKind)) {
       continue;
     }
     items.push(
       normalizeTimelineEntry({
         stableId: historyItem.stableId,
         token: historyItem.token,
-        kind: historyItem.kind,
+        kind: historyKind,
         threadId: cleanText(extractConversationIdFromStableId(historyItem.stableId) || ""),
         threadLabel: historyItem.threadLabel,
-        title: historyItem.threadLabel ? formatTitle(kindTitle(locale, historyItem.kind), historyItem.threadLabel) : historyItem.title,
-        summary: historyItem.summary,
-        messageText: historyItem.messageText,
+        title: historyTitle,
+        summary: historySummary,
+        messageText: historyMessageText,
         outcome: historyItem.outcome,
         createdAtMs: historyItem.createdAtMs,
         provider: normalizeProvider(historyItem.provider),
+        ...(historySuggestions.length > 0 && historyKind === "ambient_suggestions" ? { suggestions: historySuggestions } : {}),
       })
     );
   }
@@ -9978,6 +10314,25 @@ function buildTimelineMessageDetail(entry, locale, runtime = null) {
   };
 }
 
+function buildAmbientSuggestionsDetail(entry, locale) {
+  const suggestions = normalizeAmbientSuggestions(entry?.suggestions ?? []);
+  return {
+    kind: "ambient_suggestions",
+    token: cleanText(entry?.token || ""),
+    threadId: cleanText(entry?.threadId || ""),
+    title: cleanText(entry?.title || "") || kindTitle(locale, "ambient_suggestions"),
+    threadLabel: cleanText(entry?.threadLabel || ""),
+    createdAtMs: Number(entry?.createdAtMs) || 0,
+    messageHtml: renderMessageHtml(
+      t(locale, "detail.ambientSuggestions.copy"),
+      `<p>${escapeHtml(t(locale, "detail.detailUnavailable"))}</p>`
+    ),
+    suggestions,
+    readOnly: true,
+    actions: [],
+  };
+}
+
 function buildTimelineFileEventDetail(entry, locale) {
   const fileEventType = normalizeTimelineFileEventType(entry?.fileEventType ?? "");
   return {
@@ -10699,6 +11054,33 @@ async function buildApiItemDetail({ config, runtime, state, kind, token, locale
     const entry = timelineEntryByToken(runtime, token, kind);
     return entry ? buildTimelineFileEventDetail(entry, locale) : null;
   }
+  if (kind === "ambient_suggestions") {
+    const entry = timelineEntryByToken(runtime, token, kind);
+    if (entry) {
+      return buildAmbientSuggestionsDetail(entry, locale);
+    }
+    const historicalSource = (runtime.recentHistoryItems ?? []).find((item) => {
+      if (cleanText(item?.token || "") !== cleanText(token || "")) {
+        return false;
+      }
+      const itemKind = cleanText(item?.kind || "");
+      if (itemKind !== "assistant_final" && itemKind !== "completion") {
+        return false;
+      }
+      return parseAmbientSuggestionsPayload(item?.messageText ?? "") !== null;
+    });
+    if (!historicalSource) {
+      return null;
+    }
+    return buildAmbientSuggestionsDetail({
+      token: historicalSource.token,
+      threadId: historyItemThreadId(historicalSource),
+      threadLabel: historicalSource.threadLabel,
+      title: kindTitle(locale, "ambient_suggestions"),
+      createdAtMs: historicalSource.createdAtMs,
+      suggestions: parseAmbientSuggestionsPayload(historicalSource.messageText ?? "") ?? [],
+    }, locale);
+  }
   if (timelineMessageKinds.has(kind)) {
     const entry = timelineEntryByToken(runtime, token, kind);
     if (!entry) return null;
@@ -11429,7 +11811,7 @@ function createNativeApprovalServer({ config, runtime, state }) {
           return writeJson(res, 200, { enabled: false });
         }
         try {
-          const { readScoutState, rollScoutDayIfNeeded } = await import("./moltbook-api.mjs");
+          const { readScoutState, rollScoutDayIfNeeded, createMoltbookClient } = await import("./moltbook-api.mjs");
           const scoutState = rollScoutDayIfNeeded(await readScoutState());
           const batch = scoutState.batch;
           const batchInfo = batch && batch.candidates?.length ? {
@@ -11438,8 +11820,39 @@ function createNativeApprovalServer({ config, runtime, state }) {
             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;
+
+          // Agent profile — lazy-fetched, cached 1h. Stale cache survives
+          // fetch failures so the UI never goes blank mid-outage.
+          let account = null;
+          try {
+            const PROFILE_TTL_MS = 60 * 60 * 1000;
+            const cached = runtime.moltbookAgentProfile;
+            const nowMs = Date.now();
+            if (!cached || nowMs - (cached.fetchedAtMs || 0) > PROFILE_TTL_MS) {
+              const mb = createMoltbookClient(config.moltbookApiKey);
+              const meRes = await mb("/agents/me");
+              const name = cleanText(meRes?.agent?.name || meRes?.agent?.display_name || "");
+              if (name) {
+                runtime.moltbookAgentProfile = {
+                  name,
+                  profileUrl: `https://www.moltbook.com/u/${encodeURIComponent(name)}`,
+                  fetchedAtMs: nowMs,
+                };
+              }
+            }
+          } catch {
+            // Fall through — if fetch fails, use whatever's cached (possibly null).
+          }
+          if (runtime.moltbookAgentProfile) {
+            account = {
+              name: runtime.moltbookAgentProfile.name,
+              profileUrl: runtime.moltbookAgentProfile.profileUrl,
+            };
+          }
+
           return writeJson(res, 200, {
             enabled: true,
+            account,
             day: scoutState.day,
             sentToday: scoutState.sentToday,
             maxDaily: 5,
@@ -11478,6 +11891,82 @@ function createNativeApprovalServer({ config, runtime, state }) {
         });
       }
 
+      // A2A Share status (HTML hosting) for the settings UI. Reuses A2A
+      // credentials; enabled iff both user id + API key are provisioned.
+      // Results from the upstream `/api/list` call are cached for 30s so a
+      // settings-page render doesn't hammer the worker on every refresh tick.
+      if (url.pathname === "/api/share/status" && req.method === "GET") {
+        const session = requireApiSession(req, res, config, state);
+        if (!session) return;
+        const enabled = Boolean(config.a2aRelayUserId && config.a2aApiKey);
+        if (!enabled) {
+          return writeJson(res, 200, { enabled: false });
+        }
+        const shareHost = (() => {
+          try { return new URL(config.a2aShareUrl).host; } catch { return config.a2aShareUrl || ""; }
+        })();
+        // Mirror the constants baked into share-worker/worker.js. If those
+        // change, bump here too — there's no shared module between the two.
+        const limits = {
+          maxFileBytes: 5 * 1024 * 1024,
+          maxTotalBytes: 5 * 1024 * 1024,
+          maxFiles: 10,
+          defaultExpiresDays: 30,
+          maxExpiresDays: 30,
+          uploadRatePerHour: 10,
+        };
+        const cacheKey = `${config.a2aRelayUserId}|${config.a2aShareUrl}`;
+        const nowMs = Date.now();
+        const cached = runtime.a2aShareStatusCache;
+        if (cached && cached.key === cacheKey && nowMs - cached.fetchedAtMs < 30_000) {
+          return writeJson(res, 200, {
+            enabled: true,
+            userId: config.a2aRelayUserId,
+            shareUrl: config.a2aShareUrl,
+            shareHost,
+            limits,
+            ...cached.payload,
+            fetchedAtMs: cached.fetchedAtMs,
+          });
+        }
+        let upstream = { items: [], quota: null, error: null };
+        const controller = new AbortController();
+        const timer = setTimeout(() => controller.abort(), 10_000);
+        try {
+          const resUpstream = await fetch(`${config.a2aShareUrl}/api/list`, {
+            method: "GET",
+            headers: {
+              "x-a2a-user": config.a2aRelayUserId,
+              "x-a2a-key": config.a2aApiKey,
+            },
+            signal: controller.signal,
+          });
+          if (resUpstream.ok) {
+            const body = await resUpstream.json().catch(() => ({}));
+            upstream.items = Array.isArray(body.items) ? body.items : [];
+            upstream.quota = body.quota || null;
+          } else {
+            upstream.error = `HTTP ${resUpstream.status}`;
+          }
+        } catch (error) {
+          upstream.error = error?.name === "AbortError"
+            ? "upstream timeout"
+            : (error?.message || String(error));
+        } finally {
+          clearTimeout(timer);
+        }
+        runtime.a2aShareStatusCache = { key: cacheKey, fetchedAtMs: nowMs, payload: upstream };
+        return writeJson(res, 200, {
+          enabled: true,
+          userId: config.a2aRelayUserId,
+          shareUrl: config.a2aShareUrl,
+          shareHost,
+          limits,
+          ...upstream,
+          fetchedAtMs: nowMs,
+        });
+      }
+
       // Toggle acceptPublicTasks on the A2A relay.
       if (url.pathname === "/api/a2a/public-tasks" && req.method === "POST") {
         const session = requireApiSession(req, res, config, state);
@@ -12247,6 +12736,14 @@ function createNativeApprovalServer({ config, runtime, state }) {
         if (eventType === "resolve") {
           const token = historyToken(`moltbook:${sourceId}`);
           runtime.moltbookItemsByToken.delete(token);
+          // Flip the history item to readOnly so it moves from pending → completed.
+          try {
+            if (flipHistoryItemReadOnly({ runtime, state, stableId: `moltbook_reply:${sourceId}` })) {
+              await saveState(config.stateFile, state);
+            }
+          } catch (error) {
+            console.error(`[moltbook-reply-resolve] ${error.message}`);
+          }
           return writeJson(res, 200, { ok: true });
         }
         const token = historyToken(`moltbook:${sourceId}`);
@@ -12268,24 +12765,21 @@ function createNativeApprovalServer({ config, runtime, state }) {
         };
         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",
-            },
-          });
+          const historyEntry = {
+            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",
+          };
+          recordTimelineEntry({ config, runtime, state, entry: historyEntry });
+          recordHistoryItem({ config, runtime, state, item: historyEntry });
           await saveState(config.stateFile, state);
         } catch (error) {
           console.error(`[moltbook-timeline-save] ${error.message}`);
@@ -12351,6 +12845,13 @@ function createNativeApprovalServer({ config, runtime, state }) {
         }
         item.resolved = true;
         runtime.moltbookItemsByToken.delete(token);
+        try {
+          if (flipHistoryItemReadOnly({ runtime, state, stableId: `moltbook_reply:${item.sourceId}` })) {
+            await saveState(config.stateFile, state);
+          }
+        } catch (error) {
+          console.error(`[moltbook-reply-phone] ${error.message}`);
+        }
         return writeJson(res, 200, { ok: true, action });
       }
 
@@ -12419,36 +12920,33 @@ function createNativeApprovalServer({ config, runtime, state }) {
         runtime.moltbookDraftsByToken.set(token, draft);
         await writeDraft(draft).catch((e) => console.error(`[moltbook-draft-persist] ${e.message}`));
         try {
-          recordTimelineEntry({
-            config,
-            runtime,
-            state,
-            entry: {
-              stableId: `moltbook_draft:${sourceId}`,
-              token,
-              kind: "moltbook_draft",
-              threadId: "moltbook",
-              threadLabel: postTitle || "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",
-            },
-          });
+          const draftEntry = {
+            stableId: `moltbook_draft:${sourceId}`,
+            token,
+            kind: "moltbook_draft",
+            threadId: "moltbook",
+            threadLabel: postTitle || "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",
+          };
+          recordTimelineEntry({ config, runtime, state, entry: draftEntry });
+          recordHistoryItem({ config, runtime, state, item: draftEntry });
           await saveState(config.stateFile, state);
         } catch (error) {
           console.error(`[moltbook-draft-timeline-save] ${error.message}`);
@@ -12549,6 +13047,15 @@ function createNativeApprovalServer({ config, runtime, state }) {
         // Persist decision to disk.
         await writeDraft(draft).catch((e) => console.error(`[moltbook-draft-persist-decision] ${e.message}`));
 
+        // Flip the history entry to readOnly so it moves from pending → completed.
+        try {
+          if (flipHistoryItemReadOnly({ runtime, state, stableId: `moltbook_draft:${draft.sourceId}` })) {
+            await saveState(config.stateFile, state);
+          }
+        } catch (error) {
+          console.error(`[moltbook-draft-decision-flip] ${error.message}`);
+        }
+
         if (action === "approve") {
           // Execute posting asynchronously — fire-and-forget from the HTTP handler.
           (async () => {
@@ -14564,12 +15071,11 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
     const scoutState = rollScoutDayIfNeeded(await readScoutState());
     scoutState.sentToday += 1;
     markPostSeen(scoutState, draft.postId, "published");
-    // Note: replies are tracked via sentToday + markPostSeen("published").
-    // They intentionally do NOT flow through recordComposeAttempt because
-    // `composedToday` / `recentComposeTitles` back the "本日の新規投稿数"
-    // settings row, which is labelled for ORIGINAL posts only. Counting
-    // replies there produced a misleading "6 / 3" over-quota display even
-    // when the user only published one actual new post for the day.
+    // Append the reply to `recentComposeTitles` so it shows up in the
+    // "最近の投稿" list with its reply badge. `recordComposeAttempt` knows
+    // not to bump `composedToday` when type === "reply", so the
+    // "本日の新規投稿数" counter only reflects original posts.
+    recordComposeAttempt(scoutState, draft.postTitle || draft.postId, draft.postId, "reply");
     await writeScoutState(scoutState);
   }
 
@@ -14643,6 +15149,11 @@ function buildConfig(cli) {
     a2aRelayUserId: cleanText(process.env.A2A_RELAY_USER_ID || ""),
     a2aRelaySecret: cleanText(process.env.A2A_RELAY_SECRET || ""),
     a2aRelayRegisterSecret: cleanText(process.env.A2A_RELAY_REGISTER_SECRET || ""),
+    // share.viveworker.com — HTML hosting backed by the same A2A credentials.
+    // Override for staging / self-hosted deployments via VIVEWORKER_SHARE_URL.
+    a2aShareUrl: stripTrailingSlash(
+      process.env.VIVEWORKER_SHARE_URL || "https://share.viveworker.com"
+    ),
     webUiEnabled: boolEnv("WEB_UI_ENABLED", true),
     authRequired: boolEnv("AUTH_REQUIRED", true),
     webPushEnabled: boolEnv("WEB_PUSH_ENABLED", false),
@@ -15992,8 +16503,10 @@ async function main() {
       migratedPairedDevicesStateChanged ||
       restoredPendingPlanStateChanged ||
       restoredTimelineImagePathsStateChanged ||
+      backfilledAmbientSuggestionsStateChanged ||
       migratedRecentCodeEventsStateChanged ||
       restoredPendingUserInputStateChanged ||
+      backfilledMoltbookInboxChanged ||
       refreshResolvedThreadLabels({ config, runtime, state })
     ) {
       await saveState(config.stateFile, state);