viveworker 0.8.2 → 0.8.4

package/README.md

@@ -284,6 +284,8 @@ Typical commands:
 - `npx viveworker share upload report.pdf --password "hunter2" --expires-days 7`
 - `npx viveworker share upload deck_standalone.html --no-optimize`
 - `npx viveworker share list`
+- `npx viveworker share replace <slug> updated-report.html`
+- `npx viveworker share update <slug> --file updated-report.html`
 - `npx viveworker share update <slug> --password "hunter2"`
 - `npx viveworker share update <slug> --expires-days 7`
 - `npx viveworker share link <slug>`
@@ -386,18 +388,18 @@ Because the Claude hook opens browser windows and returns focus to Claude Deskto
 
 ### What it does
 
-- **Incoming replies**: detects when other agents comment on your posts and notifies your phone so you can draft a reply
+- **Incoming reply drafts**: detects when other agents comment on your posts, drafts a contextual reply first, and sends it to your phone for approval
 - **Draft approval on phone**: reply drafts and original post drafts appear in `Tasks` and `Timeline`, where you can approve, deny, or edit them from your phone
-- **Auto-scout replies**: every 2 minutes, scans the Moltbook feed, scores posts against your agent's persona (0–100), batches candidates over a 30-minute window, picks the best match, drafts a reply via LLM, and proposes it for your approval
+- **Auto-scout replies**: every 2 minutes, handles pending incoming comments first, then scans the Moltbook feed, scores posts against your agent's persona (0–100), batches candidates over a 30-minute window, picks the best match, drafts a reply via LLM, and proposes it for your approval
 - **Original post drafts**: based on your daily coding activity, composes new posts in your agent's voice and proposes them at natural intervals — morning (yesterday recap), noon (morning progress), and evening (full-day summary). Up to 3 per day; deny any slot you don't want
 
 ### How it works
 
 1. Define your agent's persona in `~/.viveworker/moltbook-persona.md` — voice, expertise, interests, topics to avoid
 2. The system filters all content through this persona: only activities and posts that match your agent's expertise are surfaced
-3. The Moltbook watcher pushes incoming replies and draft proposals into `Tasks` and `Timeline`
+3. The Moltbook watcher saves incoming replies; auto-scout turns pending comments and discovery candidates into draft proposals
 4. On your phone, you can approve, deny, or edit the draft body before sending
-5. The Moltbook CLI long-polls for that decision, then posts to Moltbook and solves the verification puzzle automatically
+5. After approval, the bridge posts to Moltbook and solves the verification puzzle automatically
 
 ### Setup
 
@@ -428,6 +430,7 @@ Open `Settings > Moltbook` in the phone app to see the current auto-scout postin
 - `npx viveworker moltbook list` — show pending comment notifications
 - `npx viveworker moltbook poll` — manually refresh Moltbook notifications once
 - `npx viveworker moltbook reconcile` — resolve inbox items that were already replied to elsewhere
+- `npx viveworker moltbook inbox-pick` — manually pick one pending incoming comment for a reply draft
 - `npx viveworker moltbook scout` — manually pick a feed candidate
 - `npx viveworker moltbook propose <postId> --text "..."` — submit a reply draft for phone approval
 - `npx viveworker moltbook compose` — inspect today's activity for original-post material

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.8.2",
+  "version": "0.8.4",
   "description": "Open mobile control surface for Codex, Claude, Thread Sharing, File Share, Moltbook, and A2A tasks on your trusted LAN.",
   "author": "Yuta Hoshino <hoshino.lireneo@gmail.com>",
   "license": "MIT",

package/scripts/com.viveworker.moltbook-scout.plist.sample

@@ -32,13 +32,13 @@
         candidate (status: 'candidate'), draft a 2-3 paragraph reply in
         viveworker voice (informal lowercase, technically substantive,
         no signature) and run: node scripts/viveworker.mjs moltbook
-        propose <postId> --text \"<your draft>\" --timeout 900. If
+        propose <postId> --text \"<your draft>\" --timeout 86400. If
         scout prints anything else, exit quietly."
 
       Replace `codex exec` with `claude -p` for Claude Code users, or
       with your own SDK runner.
     -->
-    <string>set -a; . "$HOME/.viveworker/moltbook.env"; set +a; cd "$HOME/path/to/viveworker" &amp;&amp; codex exec "Run scripts/moltbook-scout-run.sh and, if it prints a candidate, draft a reply in viveworker voice and call viveworker moltbook propose &lt;postId&gt; --text \"...\" --timeout 900."</string>
+    <string>set -a; . "$HOME/.viveworker/moltbook.env"; set +a; cd "$HOME/path/to/viveworker" &amp;&amp; codex exec "Run scripts/moltbook-scout-run.sh and, if it prints a candidate, draft a reply in viveworker voice and call viveworker moltbook propose &lt;postId&gt; --text \"...\" --timeout 86400."</string>
   </array>
 
   <key>StartInterval</key>

package/scripts/moltbook-api.mjs

@@ -177,11 +177,15 @@ export function defaultScoutState() {
   return { day: todayKey(), sentToday: 0, seenPostIds: {}, batch: null, lastComposeDay: "", composedToday: 0, composeSlotsAttempted: [], recentComposeTitles: [] };
 }
 
-export function todayKey() {
+export function todayKey(nowMs = Date.now()) {
+  return dayKeyForTimestamp(nowMs);
+}
+
+export function dayKeyForTimestamp(timestampMs = Date.now()) {
   // Use local timezone with AM 5:00 as the day boundary — hours before 5am
   // count as the previous day so late-night work doesn't consume the next
   // day's quota.
-  const d = new Date(Date.now() - 5 * 60 * 60 * 1000);
+  const d = new Date(Number(timestampMs || Date.now()) - 5 * 60 * 60 * 1000);
   const y = d.getFullYear();
   const m = String(d.getMonth() + 1).padStart(2, "0");
   const day = String(d.getDate()).padStart(2, "0");
@@ -247,6 +251,178 @@ export async function listInboxItems(dir = DEFAULT_INBOX_DIR) {
   }
 }
 
+function normalizedAuthorKey(value) {
+  return String(value || "")
+    .trim()
+    .replace(/^@/u, "")
+    .toLowerCase();
+}
+
+export function isOwnMoltbookInboxItem(item, env = {}) {
+  const authorId = String(item?.authorId || item?.author_id || "");
+  const myAgentId = String(env.MOLTBOOK_AGENT_ID || "");
+  if (authorId && myAgentId && authorId === myAgentId) return true;
+
+  const authorName = normalizedAuthorKey(item?.authorName || item?.author || item?.username);
+  const myAgentName = normalizedAuthorKey(env.MOLTBOOK_AGENT_NAME || "");
+  return Boolean(authorName && (authorName === "viveworker" || (myAgentName && authorName === myAgentName)));
+}
+
+export function hasPendingMoltbookDraftForInboxItem(item) {
+  const draftStatus = String(item?.draftStatus || "").toLowerCase();
+  if (["failed", "expired", "missing", "stale"].includes(draftStatus)) return false;
+  if (draftStatus && draftStatus !== "none") return true;
+  return Boolean(item?.draftToken || item?.draftedAt || item?.draftSourceId);
+}
+
+export function isActiveMoltbookDraft(draft, nowMs = Date.now()) {
+  if (!draft || typeof draft !== "object" || draft.decision) return false;
+  const token = String(draft.token || "");
+  if (!token) return false;
+  const createdAtMs = Number(draft.createdAtMs) || 0;
+  if (!createdAtMs) return true;
+  const ttlMs = Math.max(60_000, Math.min(Number(draft.ttlMs) || 86_400_000, 86_400_000));
+  return nowMs - createdAtMs <= ttlMs;
+}
+
+export function countReservedMoltbookReplyDrafts(drafts, {
+  day = todayKey(),
+  nowMs = Date.now(),
+  excludeToken = "",
+} = {}) {
+  let count = 0;
+  for (const draft of Array.isArray(drafts) ? drafts : []) {
+    if (!isActiveMoltbookDraft(draft, nowMs)) continue;
+    if (String(draft.token || "") === String(excludeToken || "")) continue;
+    if (String(draft.draftType || "reply") !== "reply") continue;
+    const createdAtMs = Number(draft.createdAtMs) || nowMs;
+    if (dayKeyForTimestamp(createdAtMs) !== day) continue;
+    count += 1;
+  }
+  return count;
+}
+
+export async function getMoltbookReplyQuotaState({
+  state = null,
+  maxDaily = 5,
+  draftsDir = DEFAULT_DRAFTS_DIR,
+  nowMs = Date.now(),
+  excludeToken = "",
+} = {}) {
+  const scoutState = rollScoutDayIfNeeded(state || await readScoutState());
+  const pendingDrafts = await listPendingDrafts(draftsDir);
+  const pendingToday = countReservedMoltbookReplyDrafts(pendingDrafts, {
+    day: scoutState.day,
+    nowMs,
+    excludeToken,
+  });
+  const sentToday = Number(scoutState.sentToday) || 0;
+  const max = Math.max(0, Number(maxDaily) || 5);
+  const usedToday = sentToday + pendingToday;
+  return {
+    day: scoutState.day,
+    sentToday,
+    pendingToday,
+    usedToday,
+    maxDaily: max,
+    remaining: Math.max(0, max - usedToday),
+    quotaReached: usedToday >= max,
+  };
+}
+
+export async function reconcileInboxDraftMarkers(items, {
+  inboxDir = DEFAULT_INBOX_DIR,
+  draftsDir = DEFAULT_DRAFTS_DIR,
+  nowMs = Date.now(),
+} = {}) {
+  const pendingDrafts = await listPendingDrafts(draftsDir);
+  const activeTokens = new Set(
+    pendingDrafts
+      .filter((draft) => isActiveMoltbookDraft(draft, nowMs))
+      .map((draft) => String(draft.token || ""))
+      .filter(Boolean),
+  );
+  const reconciled = [];
+  let resetCount = 0;
+  for (const item of Array.isArray(items) ? items : []) {
+    if (!item || typeof item !== "object") {
+      reconciled.push(item);
+      continue;
+    }
+    const status = String(item.status || "").toLowerCase();
+    const draftStatus = String(item.draftStatus || "").toLowerCase();
+    const draftToken = String(item.draftToken || "");
+    const shouldReset =
+      status === "pending"
+      && hasPendingMoltbookDraftForInboxItem(item)
+      && (draftStatus === "proposed" || Boolean(draftToken))
+      && (!draftToken || !activeTokens.has(draftToken));
+    if (!shouldReset) {
+      reconciled.push(item);
+      continue;
+    }
+    const updated = await updateInboxStatus(item.commentId, "pending", {
+      draftStatus: "expired",
+      draftToken: "",
+      draftSource: "",
+      draftSourceId: "",
+      draftError: "previous draft expired or is no longer available; eligible for reproposal",
+      draftExpiredAt: new Date(nowMs).toISOString(),
+    }, inboxDir);
+    reconciled.push(updated || {
+      ...item,
+      draftStatus: "expired",
+      draftToken: "",
+      draftSource: "",
+      draftSourceId: "",
+      draftError: "previous draft expired or is no longer available; eligible for reproposal",
+      draftExpiredAt: new Date(nowMs).toISOString(),
+    });
+    resetCount += 1;
+  }
+  return { items: reconciled, resetCount };
+}
+
+export function pickInboxReplyCandidate(items, env = {}) {
+  const skipReasons = {
+    malformed: 0,
+    notPending: 0,
+    selfAuthor: 0,
+    alreadyDrafted: 0,
+  };
+  const candidates = [];
+  for (const item of Array.isArray(items) ? items : []) {
+    if (!item || typeof item !== "object" || !item.commentId || !item.postId) {
+      skipReasons.malformed += 1;
+      continue;
+    }
+    if (String(item.status || "").toLowerCase() !== "pending") {
+      skipReasons.notPending += 1;
+      continue;
+    }
+    if (isOwnMoltbookInboxItem(item, env)) {
+      skipReasons.selfAuthor += 1;
+      continue;
+    }
+    if (hasPendingMoltbookDraftForInboxItem(item)) {
+      skipReasons.alreadyDrafted += 1;
+      continue;
+    }
+    candidates.push(item);
+  }
+  candidates.sort((a, b) => {
+    const bt = Number(Date.parse(b.createdAt || b.updatedAt || "")) || 0;
+    const at = Number(Date.parse(a.createdAt || a.updatedAt || "")) || 0;
+    return bt - at;
+  });
+  return {
+    status: candidates.length ? "candidate" : "empty",
+    item: candidates[0] || null,
+    skipReasons,
+    consideredCount: candidates.length,
+  };
+}
+
 // ---------- Draft persistence ----------
 //
 // Pending Moltbook drafts (reply proposals and original-post proposals) are

package/scripts/moltbook-cli.mjs

@@ -33,6 +33,9 @@ import {
   recordComposeAttempt,
   solveVerificationPuzzle,
   solvePuzzleWithLLM,
+  pickInboxReplyCandidate,
+  reconcileInboxDraftMarkers,
+  getMoltbookReplyQuotaState,
 } from "./moltbook-api.mjs";
 
 function fail(message, code = 1) {
@@ -138,7 +141,7 @@ async function cmdThread(commentId) {
 }
 
 async function cmdReply(commentId, flags) {
-  if (!commentId) fail("usage: viveworker moltbook reply <commentId> --text \"...\"");
+  if (!commentId) fail("usage: viveworker moltbook reply <commentId> --text \"...\" [--top-level]");
   const text = typeof flags.text === "string" ? flags.text : "";
   if (!text.trim()) fail("--text is required and must be non-empty");
   let item = await readInboxItem(commentId);
@@ -159,10 +162,20 @@ async function cmdReply(commentId, flags) {
     };
     await writeInboxItem(item);
   }
+  // For "mention" notifications, the commentId is a synthetic notification
+  // ID — there's no real parent comment to thread under, and posting with
+  // parent_id=that value gets rejected as "Parent comment not found". Drop
+  // parent_id so the comment lands as a top-level reply on the post.
+  // Caller can also force this with --top-level for ad-hoc cases (e.g.,
+  // older inbox entries written before the watcher started recording kind).
+  const isTopLevel = flags["top-level"] === true || item.kind === "mention";
+  const body = isTopLevel
+    ? { content: text }
+    : { content: text, parent_id: commentId };
   const { mb, env } = await getClient();
   const result = await mb(`/posts/${item.postId}/comments`, {
     method: "POST",
-    body: JSON.stringify({ content: text, parent_id: commentId }),
+    body: JSON.stringify(body),
   });
   const verification = result?.comment?.verification || null;
   await resolveOnBridge(env, commentId);
@@ -272,6 +285,7 @@ async function cmdPoll() {
       commentId,
       postId,
       parentCommentId: String(n.comment?.parent_id || n.parent_id || ""),
+      authorId: String(author.id || author.agent_id || author.agentId || ""),
       authorName: author.username || author.name || "user",
       postTitle: n.post?.title || n.post_title || "",
       postUrl: `https://www.moltbook.com/post/${postId}`,
@@ -285,6 +299,71 @@ async function cmdPoll() {
   console.log(`added ${written} new item(s)`);
 }
 
+async function cmdInboxPick(flags) {
+  await ensureInboxDir();
+  const { mb, env } = await getClient();
+  const maxDaily = Number(flags["max-daily"]) || 5;
+  const state = rollScoutDayIfNeeded(await readScoutState());
+  const reconciled = await reconcileInboxDraftMarkers(await listInboxItems());
+  const quota = await getMoltbookReplyQuotaState({ state, maxDaily });
+  if (quota.quotaReached) {
+    await writeScoutState(state);
+    console.log(JSON.stringify({
+      status: "quota-reached",
+      sentToday: quota.sentToday,
+      pendingToday: quota.pendingToday,
+      usedToday: quota.usedToday,
+      maxDaily: quota.maxDaily,
+      day: quota.day,
+      recoveredDrafts: reconciled.resetCount,
+    }, null, 2));
+    return;
+  }
+  const picked = pickInboxReplyCandidate(reconciled.items, env);
+  if (!picked.item) {
+    console.log(JSON.stringify({
+      status: "empty",
+      skipReasons: picked.skipReasons,
+      recoveredDrafts: reconciled.resetCount,
+    }, null, 2));
+    return;
+  }
+
+  const item = picked.item;
+  let post = null;
+  if (!flags["no-fetch"]) {
+    try {
+      const data = await mb(`/posts/${item.postId}`);
+      post = data?.post || data || null;
+    } catch (error) {
+      console.error(`inbox-pick: could not fetch post ${item.postId}: ${error.message}`);
+    }
+  }
+
+  const postAuthor = post?.author || post?.user || {};
+  const output = {
+    status: "candidate",
+    commentId: String(item.commentId),
+    postId: String(item.postId),
+    parentCommentId: String(item.parentCommentId || ""),
+    author: item.authorName || "user",
+    authorId: item.authorId || "",
+    postTitle: item.postTitle || post?.title || "",
+    postUrl: item.postUrl || `https://www.moltbook.com/post/${item.postId}`,
+    postAuthor: postAuthor.username || postAuthor.name || "",
+    postBody: post?.content || post?.body || "",
+    commentText: item.contextText || "",
+    createdAt: item.createdAt || "",
+    consideredCount: picked.consideredCount,
+    skipReasons: picked.skipReasons,
+    recoveredDrafts: reconciled.resetCount,
+  };
+  const json = JSON.stringify(output, (_, v) =>
+    typeof v === "string" ? v.replace(/[\x00-\x1f]/g, (ch) => ch === "\n" || ch === "\t" ? ch : "") : v
+  , 2);
+  console.log(json);
+}
+
 // ---------------------------------------------------------------------------
 // scout: pick one candidate post from the feed and print the context needed
 // for an agent (Codex / Claude Desktop / whatever) to draft a reply.
@@ -311,10 +390,18 @@ async function cmdScout(flags) {
   const dryRun = Boolean(flags["dry-run"]);
 
   const state = rollScoutDayIfNeeded(await readScoutState());
-  if (state.sentToday >= maxDaily) {
+  const quota = await getMoltbookReplyQuotaState({ state, maxDaily });
+  if (quota.quotaReached) {
     console.log(
       JSON.stringify(
-        { status: "quota-reached", sentToday: state.sentToday, maxDaily, day: state.day },
+        {
+          status: "quota-reached",
+          sentToday: quota.sentToday,
+          pendingToday: quota.pendingToday,
+          usedToday: quota.usedToday,
+          maxDaily: quota.maxDaily,
+          day: quota.day,
+        },
         null,
         2
       )
@@ -495,6 +582,14 @@ async function cmdPropose(postId, flags) {
   const postAuthor = typeof flags["post-author"] === "string" ? flags["post-author"] : "";
   const intent = typeof flags.intent === "string" ? flags.intent : "";
   const postUrl = `https://www.moltbook.com/post/${postId}`;
+  const sourceId = typeof flags["source-id"] === "string" && flags["source-id"].trim()
+    ? flags["source-id"].trim()
+    : parentCommentId
+      ? `inbox-comment:${parentCommentId}`
+      : `draft:${postId}:${Date.now()}`;
+  const draftSource = typeof flags["draft-source"] === "string" && flags["draft-source"].trim()
+    ? flags["draft-source"].trim()
+    : (parentCommentId ? "inbox-auto-scout" : "auto-scout");
 
   const env = await loadMoltbookEnv();
   const base = (env.VIVEWORKER_BASE_URL || "https://127.0.0.1:8810").replace(/\/+$/u, "");
@@ -504,8 +599,6 @@ async function cmdPropose(postId, flags) {
   const prevTls = process.env.NODE_TLS_REJECT_UNAUTHORIZED;
   if (!prevTls) process.env.NODE_TLS_REJECT_UNAUTHORIZED = "0";
 
-  const sourceId = `draft:${postId}:${Date.now()}`;
-
   // Submit draft to bridge. The bridge persists it to disk and handles posting
   // on approval — the CLI exits immediately (fire-and-forget).
   let submitRes;
@@ -537,6 +630,17 @@ async function cmdPropose(postId, flags) {
   }
   const token = submitRes?.token;
   if (!token) fail(`bridge did not return a token: ${JSON.stringify(submitRes)}`);
+  if (parentCommentId) {
+    await updateInboxStatus(parentCommentId, "pending", {
+      draftStatus: "proposed",
+      draftSource,
+      draftSourceId: sourceId,
+      draftToken: token,
+      draftedAt: new Date().toISOString(),
+      draftError: "",
+    }).catch(() => null);
+    await resolveOnBridge(env, parentCommentId);
+  }
 
   console.log(JSON.stringify({ ok: true, token, ttlSec, fireAndForget: true }));
   if (!prevTls) process.env.NODE_TLS_REJECT_UNAUTHORIZED = prevTls ?? "";
@@ -603,7 +707,26 @@ async function cmdBatchAdd(flags) {
 
 async function cmdBatchPick(flags) {
   const windowMs = Number(flags["window-ms"]) || DEFAULT_BATCH_WINDOW_MS;
+  const maxDaily = Number(flags["max-daily"]) || 5;
   const state = rollScoutDayIfNeeded(await readScoutState());
+  const quota = await getMoltbookReplyQuotaState({ state, maxDaily });
+
+  if (quota.quotaReached) {
+    if (quota.sentToday >= quota.maxDaily) {
+      state.batch = null;
+    }
+    await writeScoutState(state);
+    console.log(JSON.stringify({
+      status: "quota-reached",
+      sentToday: quota.sentToday,
+      pendingToday: quota.pendingToday,
+      usedToday: quota.usedToday,
+      maxDaily: quota.maxDaily,
+      day: quota.day,
+      droppedBatch: quota.sentToday >= quota.maxDaily,
+    }, null, 2));
+    return;
+  }
 
   if (!state.batch || !state.batch.candidates?.length) {
     console.log(JSON.stringify({ status: "empty" }));
@@ -933,6 +1056,8 @@ export async function runMoltbookCli(argv) {
       return cmdPoll();
     case "reconcile":
       return cmdReconcile();
+    case "inbox-pick":
+      return cmdInboxPick(flags);
     case "scout":
       return cmdScout(flags);
     case "propose":
@@ -972,12 +1097,13 @@ Commands:
   mark-skip <commentId>                 Mark an item as skipped
   poll                                  Manual one-shot notification refresh
   reconcile                             Mark inbox items already replied to as resolved
+  inbox-pick [--no-fetch]               Pick one pending incoming comment for a reply draft
   scout [--max-daily N] [--submolts a,b] [--dry-run]
                                         Pick one feed candidate and print context
-  propose <postId> --text "..." [--timeout 900] [--parent-id <commentId>]
+  propose <postId> --text "..." [--timeout 86400] [--parent-id <commentId>] [--source-id <id>]
                                         Submit draft for phone approval, then post on approve
   compose [--max-daily N]               Check activity & return compose material (JSON)
-  compose-propose --title "..." --content "..." [--submolt general] [--timeout 900]
+  compose-propose --title "..." --content "..." [--submolt general] [--timeout 86400]
                                         Submit original post draft for phone approval, then publish
   persona init|edit|show                Manage ~/.viveworker/moltbook-persona.md (inlined into scout prompt)`);
       return;

package/scripts/moltbook-scout-auto.sh

@@ -10,7 +10,7 @@
 # Environment:
 #   SCOUT_HARNESS   — "claude" or "codex" (default: auto-detect)
 #   SCOUT_FLAGS     — extra flags for scout (e.g. "--submolts builds,general --max-daily 5")
-#   SCOUT_TIMEOUT   — propose timeout in seconds (default: 900)
+#   SCOUT_TIMEOUT   — propose timeout in seconds (default: 86400 = 24h)
 #   SCOUT_DRAFT_TIMEOUT — LLM draft timeout in seconds (default: 120)
 #   SCOUT_WINDOW    — batch window in seconds (default: 1800 = 30 min)
 #   COMPOSE_MAX     — max original posts per day (default: 1)
@@ -27,7 +27,7 @@ NODE="$(command -v node)"
 VIVEWORKER="$SCRIPT_DIR/viveworker.mjs"
 PERSONA_FILE="$HOME/.viveworker/moltbook-persona.md"
 WINDOW_SEC="${SCOUT_WINDOW:-1800}"
-PROPOSE_TIMEOUT_SEC="${SCOUT_TIMEOUT:-900}"
+PROPOSE_TIMEOUT_SEC="${SCOUT_TIMEOUT:-86400}"
 DRAFT_TIMEOUT_SEC="${SCOUT_DRAFT_TIMEOUT:-120}"
 
 # Seconds until a given hour (local time). Used for compose slot timeouts.
@@ -106,6 +106,102 @@ json_field() {
   echo "$1" | "$NODE" -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{console.log(JSON.parse(d).$2||'')}catch{}})"
 }
 
+# ═══════════════════════════════════════════════════════════════
+# Step -1: Draft a reply to an incoming comment first.
+#   Inbox replies continue an active conversation, so they take priority over
+#   original posts and discovery replies.  The CLI marks a successful proposal
+#   on the inbox item, which prevents duplicate drafts for the same comment.
+# ═══════════════════════════════════════════════════════════════
+INBOX_JSON=$("$NODE" "$VIVEWORKER" moltbook inbox-pick ${SCOUT_FLAGS:-} 2>/dev/null) || true
+INBOX_STATUS=$(json_field "$INBOX_JSON" "status")
+
+if [ "$INBOX_STATUS" = "candidate" ]; then
+  if [ -z "$HARNESS_BIN" ]; then
+    echo "[scout-auto] inbox: pending comment found, but no draft harness is available"
+  else
+    printf '%s' "$INBOX_JSON" > "$SCOUT_TMP"
+    INBOX_COMMENT_ID=$(read_field commentId)
+    INBOX_POST_ID=$(read_field postId)
+    INBOX_AUTHOR=$(read_field author)
+    INBOX_POST_TITLE=$(read_field postTitle)
+    INBOX_POST_AUTHOR=$(read_field postAuthor)
+    INBOX_POST_URL=$(read_field postUrl)
+    INBOX_POST_BODY=$(read_field postBody)
+    INBOX_COMMENT_TEXT=$(read_field commentText)
+
+    echo "[scout-auto] inbox: drafting reply to @$INBOX_AUTHOR on '$INBOX_POST_TITLE'"
+
+    INBOX_PROMPT="$(cat <<INBOX_PROMPT_EOF
+${PERSONA:+You are drafting a reply on behalf of the agent described below. Follow this persona precisely.
+-----8<----- persona -----8<-----
+$PERSONA
+-----8<----- end persona -----8<-----
+
+}Someone replied to your Moltbook post. You are continuing that conversation, not cold-starting a new outreach reply.
+
+Original post:
+Title: $INBOX_POST_TITLE
+Author: ${INBOX_POST_AUTHOR:-you}
+URL: $INBOX_POST_URL
+
+Post body:
+$INBOX_POST_BODY
+
+Incoming comment from @$INBOX_AUTHOR:
+$INBOX_COMMENT_TEXT
+
+Draft a natural reply in the persona voice. Keep it concise, specific to the comment, and conversational. Prefer ending with one concrete question only if it genuinely helps continue the thread.
+
+Output in this exact format — no markdown fences, no extra text:
+
+INTENT: (1-2 sentences in Japanese: why this reply angle fits the incoming comment and original post)
+---
+(your reply text here)
+INBOX_PROMPT_EOF
+    )"
+
+    INBOX_DRAFT_TEXT=""
+    if [ "$HARNESS" = "claude" ]; then
+      INBOX_DRAFT_TEXT=$(portable_timeout "$DRAFT_TIMEOUT_SEC" "$HARNESS_BIN" -p "$INBOX_PROMPT" --output-format text 2>/dev/null) || true
+    elif [ "$HARNESS" = "codex" ]; then
+      INBOX_DRAFT_TEXT=$(portable_timeout "$DRAFT_TIMEOUT_SEC" "$HARNESS_BIN" exec "$INBOX_PROMPT" 2>/dev/null) || true
+    fi
+
+    if [ -z "$INBOX_DRAFT_TEXT" ]; then
+      echo "[scout-auto] inbox: harness returned empty draft or timed out after ${DRAFT_TIMEOUT_SEC}s"
+    else
+      INBOX_INTENT=""
+      INBOX_REPLY_BODY=""
+      if echo "$INBOX_DRAFT_TEXT" | grep -q "^---$"; then
+        INBOX_INTENT=$(echo "$INBOX_DRAFT_TEXT" | sed -n '1,/^---$/p' | sed '/^---$/d' | sed 's/^INTENT: *//')
+        INBOX_REPLY_BODY=$(echo "$INBOX_DRAFT_TEXT" | sed '1,/^---$/d')
+      else
+        INBOX_REPLY_BODY="$INBOX_DRAFT_TEXT"
+        INBOX_INTENT="inbox: responding to @${INBOX_AUTHOR}'s comment"
+      fi
+      INBOX_INTENT=$(echo "$INBOX_INTENT" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+      INBOX_REPLY_BODY=$(echo "$INBOX_REPLY_BODY" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
+
+      if [ -n "$INBOX_REPLY_BODY" ]; then
+        echo "[scout-auto] inbox: draft ready (${#INBOX_REPLY_BODY} chars), submitting propose"
+        "$NODE" "$VIVEWORKER" moltbook propose "$INBOX_POST_ID" \
+          --title "$INBOX_POST_TITLE" \
+          --post-author "$INBOX_POST_AUTHOR" \
+          --post-body "$INBOX_POST_BODY" \
+          --intent "$INBOX_INTENT" \
+          --text "$INBOX_REPLY_BODY" \
+          --parent-id "$INBOX_COMMENT_ID" \
+          --source-id "inbox-comment:$INBOX_COMMENT_ID" \
+          --draft-source "inbox-auto-scout" \
+          --timeout "$PROPOSE_TIMEOUT_SEC"
+
+        exit 0
+      fi
+      echo "[scout-auto] inbox: parsed draft body is empty"
+    fi
+  fi
+fi
+
 # ═══════════════════════════════════════════════════════════════
 # Step 0: Compose an original post (slot-based: morning/noon/evening)
 #   - morning (9-12): yesterday's work if not posted yesterday
@@ -208,13 +304,7 @@ COMPOSE_EOF
       C_BODY=$(echo "$C_BODY" | sed 's/^[[:space:]]*//;s/[[:space:]]*$//')
 
       if [ -n "$C_TITLE" ] && [ -n "$C_BODY" ]; then
-        # Timeout = seconds until current slot ends.
-        case "$COMPOSE_SLOT" in
-          morning) COMPOSE_TIMEOUT=$(seconds_until_hour 12) ;;
-          noon)    COMPOSE_TIMEOUT=$(seconds_until_hour 17) ;;
-          evening) COMPOSE_TIMEOUT=$(seconds_until_hour 24) ;;
-          *)       COMPOSE_TIMEOUT=1800 ;;
-        esac
+        COMPOSE_TIMEOUT="$PROPOSE_TIMEOUT_SEC"
         echo "[scout-auto] compose ($COMPOSE_SLOT): title='$C_TITLE' submolt=$C_SUBMOLT (${#C_BODY} chars, timeout=${COMPOSE_TIMEOUT}s)"
 
         "$NODE" "$VIVEWORKER" moltbook compose-propose \
@@ -238,7 +328,7 @@ fi
 # ═══════════════════════════════════════════════════════════════
 # Step 1: Check if the batch window has expired → pick & draft
 # ═══════════════════════════════════════════════════════════════
-PICK_JSON=$("$NODE" "$VIVEWORKER" moltbook batch-pick --window-ms "$WINDOW_MS" 2>/dev/null) || true
+PICK_JSON=$("$NODE" "$VIVEWORKER" moltbook batch-pick --window-ms "$WINDOW_MS" ${SCOUT_FLAGS:-} 2>/dev/null) || true
 PICK_STATUS=$(json_field "$PICK_JSON" "status")
 
 if [ "$PICK_STATUS" = "picked" ]; then

package/scripts/moltbook-watcher.mjs

@@ -185,6 +185,7 @@ async function pollOnce() {
       seen.add(commentId);
       const sourceId = `comment:${commentId}`;
       const author = n.actor || n.author || n.comment?.author || {};
+      const authorId = String(author.id || author.agent_id || author.agentId || "");
       let authorName = author.username || author.name || "";
       if (!authorName) {
         authorName = (await resolveAuthorName(postId, commentId, n.type || n.notificationType || "", postCommentCache, postCache)) || "user";
@@ -194,12 +195,21 @@ async function pollOnce() {
       const createdAtIso = n.created_at || n.createdAt || new Date().toISOString();
       const parentCommentId = String(n.comment?.parent_id || n.parent_id || "");
 
+      // "mention" notifications carry a synthetic commentId that doesn't
+      // exist in the moltbook comment table — replying with parent_id=that
+      // value 404s ("Parent comment not found"). Mark these so the CLI can
+      // skip parent_id and post a top-level comment on the post instead.
+      const notifType = String(n.type || n.kind || n.notificationType || "").toLowerCase();
+      const kind = notifType.includes("mention") ? "mention" : "reply";
+
       pending.set(sourceId, { commentId, postId });
 
       const inboxItem = {
         commentId,
         postId,
         parentCommentId,
+        kind,
+        authorId,
         authorName,
         postTitle,
         postUrl: `https://www.moltbook.com/post/${postId}`,