viveworker 0.8.10 → 0.9.0

package/scripts/lib/work-items.mjs

@@ -0,0 +1,179 @@
+const WORK_ITEM_SCHEMA_VERSION = 1;
+
+const TERMINAL_STATES = new Set(["completed", "failed", "canceled"]);
+const STATE_PRIORITY = new Map([
+  ["in_progress", 1],
+  ["needs_action", 2],
+  ["completed", 3],
+  ["failed", 3],
+  ["canceled", 3],
+]);
+
+function cleanText(value) {
+  return String(value ?? "").trim();
+}
+
+function normalizeProvider(value) {
+  const provider = cleanText(value).toLowerCase();
+  if (["claude", "moltbook", "a2a", "viveworker", "mcp"].includes(provider)) {
+    return provider;
+  }
+  return "codex";
+}
+
+function workItemCategory(item) {
+  switch (cleanText(item?.kind)) {
+    case "approval":
+      return cleanText(item?.approvalKind).includes("payment") ? "payment" : "approval";
+    case "plan":
+    case "plan_ready":
+      return "plan";
+    case "choice":
+      return "question";
+    case "moltbook_draft":
+      return "draft";
+    case "moltbook_reply":
+      return "reply";
+    case "thread_share":
+      return "handoff";
+    case "a2a_task":
+      return "delegation";
+    case "a2a_task_result":
+      return "delegation_result";
+    case "activity_status":
+      return "agent_run";
+    case "completion":
+    case "assistant_final":
+      return "result";
+    default:
+      return "work";
+  }
+}
+
+function terminalState(item) {
+  const taskStatus = cleanText(item?.taskStatus).toLowerCase();
+  if (["failed", "error"].includes(taskStatus)) {
+    return "failed";
+  }
+  if (["canceled", "cancelled", "rejected"].includes(taskStatus)) {
+    return "canceled";
+  }
+  return "completed";
+}
+
+function workItemPriority(item, state) {
+  if (workItemCategory(item) === "payment") {
+    return "urgent";
+  }
+  if (state === "needs_action") {
+    return cleanText(item?.kind) === "thread_share" ? "normal" : "high";
+  }
+  return state === "in_progress" ? "normal" : "low";
+}
+
+function workItemId(item) {
+  const provider = normalizeProvider(item?.provider);
+  const kind = cleanText(item?.kind) || "item";
+  const token = cleanText(item?.token);
+  const fallback = [item?.threadId, item?.createdAtMs, item?.title]
+    .map(cleanText)
+    .filter(Boolean)
+    .join(":");
+  return `${provider}:${kind}:${token || fallback || "unknown"}`;
+}
+
+function workItemThreadKey(item) {
+  const threadId = cleanText(item?.threadId);
+  return threadId ? `${normalizeProvider(item?.provider)}:${threadId}` : "";
+}
+
+function enrichWorkItem(item, state) {
+  const normalizedState = TERMINAL_STATES.has(state) ? state : cleanText(state) || "needs_action";
+  const requiresAction = normalizedState === "needs_action" && item?.supported !== false;
+  return {
+    ...item,
+    provider: normalizeProvider(item?.provider),
+    work: {
+      schemaVersion: WORK_ITEM_SCHEMA_VERSION,
+      id: workItemId(item),
+      state: normalizedState,
+      category: workItemCategory(item),
+      priority: workItemPriority(item, normalizedState),
+      requiresAction,
+      sourceRef: {
+        provider: normalizeProvider(item?.provider),
+        kind: cleanText(item?.kind),
+        token: cleanText(item?.token),
+        threadId: cleanText(item?.threadId),
+      },
+      occurredAtMs: Math.max(0, Number(item?.createdAtMs) || 0),
+    },
+  };
+}
+
+function compareWorkItems(left, right) {
+  const priorityRank = { urgent: 3, high: 2, normal: 1, low: 0 };
+  const priorityDelta = (priorityRank[right?.work?.priority] ?? 0) - (priorityRank[left?.work?.priority] ?? 0);
+  if (priorityDelta !== 0) {
+    return priorityDelta;
+  }
+  return Number(right?.createdAtMs ?? 0) - Number(left?.createdAtMs ?? 0);
+}
+
+function normalizeBucket(items, state) {
+  return (Array.isArray(items) ? items : [])
+    .filter((item) => item && typeof item === "object")
+    .map((item) => enrichWorkItem(item, state));
+}
+
+function dedupeAcrossStates(items) {
+  const byId = new Map();
+  for (const item of items) {
+    const id = cleanText(item?.work?.id);
+    if (!id) {
+      continue;
+    }
+    const previous = byId.get(id);
+    if (!previous) {
+      byId.set(id, item);
+      continue;
+    }
+    const previousRank = STATE_PRIORITY.get(previous.work.state) ?? 0;
+    const nextRank = STATE_PRIORITY.get(item.work.state) ?? 0;
+    if (nextRank > previousRank || (nextRank === previousRank && Number(item.createdAtMs) > Number(previous.createdAtMs))) {
+      byId.set(id, item);
+    }
+  }
+  return [...byId.values()];
+}
+
+export function buildWorkItemResponse({ pending = [], inProgress = [], completed = [], generatedAtMs = Date.now() } = {}) {
+  const pendingItems = normalizeBucket(pending, "needs_action");
+  const blockedThreadKeys = new Set(pendingItems.map(workItemThreadKey).filter(Boolean));
+  const activeItems = normalizeBucket(inProgress, "in_progress")
+    .filter((item) => !blockedThreadKeys.has(workItemThreadKey(item)));
+  const completedItems = (Array.isArray(completed) ? completed : [])
+    .filter((item) => item && typeof item === "object")
+    .map((item) => enrichWorkItem(item, terminalState(item)));
+
+  const deduped = dedupeAcrossStates([...activeItems, ...pendingItems, ...completedItems]);
+  const needsAction = deduped.filter((item) => item.work.state === "needs_action").sort(compareWorkItems);
+  const active = deduped.filter((item) => item.work.state === "in_progress").sort(compareWorkItems);
+  const terminal = deduped.filter((item) => TERMINAL_STATES.has(item.work.state)).sort(compareWorkItems);
+
+  return {
+    schemaVersion: WORK_ITEM_SCHEMA_VERSION,
+    generatedAtMs: Math.max(0, Number(generatedAtMs) || Date.now()),
+    counts: {
+      needsAction: needsAction.length,
+      inProgress: active.length,
+      completed: terminal.filter((item) => item.work.state === "completed").length,
+      failed: terminal.filter((item) => item.work.state === "failed").length,
+    },
+    pending: needsAction,
+    inProgress: active,
+    completed: terminal,
+  };
+}
+
+export { WORK_ITEM_SCHEMA_VERSION };

package/scripts/moltbook-api.mjs

@@ -62,6 +62,33 @@ export const DEFAULT_INBOX_DIR = path.join(os.homedir(), ".viveworker", "moltboo
 export const DEFAULT_SCOUT_STATE_FILE = path.join(os.homedir(), ".viveworker", "moltbook-scout-state.json");
 export const DEFAULT_DRAFTS_DIR = path.join(os.homedir(), ".viveworker", "moltbook-drafts");
 
+const PROVIDER_ERROR_TEXT_PATTERNS = [
+  /\bfailed to authenticate\b/iu,
+  /\binvalid authentication credentials\b/iu,
+  /\bauthentication_error\b/iu,
+  /\bapi error:\s*(?:401|403)\b/iu,
+  /\bincorrect api key\b/iu,
+  /\binvalid api key\b/iu,
+];
+
+export function looksLikeProviderErrorText(value) {
+  const text = String(value || "").trim();
+  if (!text) return false;
+  const compact = text.replace(/\s+/gu, " ");
+  if (PROVIDER_ERROR_TEXT_PATTERNS.some((pattern) => pattern.test(compact))) {
+    return true;
+  }
+  if (!compact.startsWith("{")) return false;
+  try {
+    const parsed = JSON.parse(compact);
+    const type = String(parsed?.error?.type || parsed?.type || "").toLowerCase();
+    const message = String(parsed?.error?.message || parsed?.message || "").toLowerCase();
+    return type === "authentication_error" || message.includes("invalid authentication credentials");
+  } catch {
+    return false;
+  }
+}
+
 export async function loadMoltbookEnv(envFile = DEFAULT_ENV_FILE) {
   const env = {};
   try {

package/scripts/moltbook-cli.mjs

@@ -36,6 +36,7 @@ import {
   pickInboxReplyCandidate,
   reconcileInboxDraftMarkers,
   getMoltbookReplyQuotaState,
+  looksLikeProviderErrorText,
   loopbackFetch,
 } from "./moltbook-api.mjs";
 
@@ -572,6 +573,9 @@ async function cmdPropose(postId, flags) {
   if (!postId) fail("usage: viveworker moltbook propose <postId> --text \"...\"");
   const text = typeof flags.text === "string" ? flags.text : "";
   if (!text.trim()) fail("--text is required and must be non-empty");
+  if (looksLikeProviderErrorText(text)) {
+    fail("--text looks like an LLM/provider authentication error; refusing to create a Moltbook draft");
+  }
   const ttlSec = Number(flags.ttl) || Number(flags.timeout) || 86400;
   const parentCommentId = typeof flags["parent-id"] === "string" ? flags["parent-id"] : "";
   const postTitle = typeof flags.title === "string" ? flags.title : "";
@@ -948,10 +952,6 @@ async function cmdCompose(flags) {
     return;
   }
 
-  // Mark slot as attempted (even before drafting, to avoid re-proposal on deny).
-  state.composeSlotsAttempted = [...attempted, slot];
-  await writeScoutState(state);
-
   // Load persona.
   let persona = "";
   try {
@@ -1020,6 +1020,14 @@ async function cmdComposePropose(flags) {
   }
   const token = submitRes?.token;
   if (!token) fail(`bridge did not return a token: ${JSON.stringify(submitRes)}`);
+  if (slot) {
+    const state = rollScoutDayIfNeeded(await readScoutState());
+    const attempted = Array.isArray(state.composeSlotsAttempted) ? state.composeSlotsAttempted : [];
+    if (!attempted.includes(slot)) {
+      state.composeSlotsAttempted = [...attempted, slot];
+      await writeScoutState(state);
+    }
+  }
 
   console.log(JSON.stringify({ ok: true, token, ttlSec, fireAndForget: true }));
 }

package/scripts/moltbook-scout-auto.sh

@@ -39,19 +39,88 @@ WINDOW_MS=$((WINDOW_SEC * 1000))
 MAX_SKIP=5
 
 # ── Detect harness ────────────────────────────────────────────
+resolve_harness_bin() {
+  local harness="$1"
+  local configured="${2:-}"
+  local resolved=""
+
+  if [ -n "$configured" ]; then
+    if [ -x "$configured" ]; then
+      printf '%s\n' "$configured"
+      return 0
+    fi
+    resolved=$(command -v "$configured" 2>/dev/null || true)
+    if [ -n "$resolved" ] && [ -x "$resolved" ]; then
+      printf '%s\n' "$resolved"
+      return 0
+    fi
+  fi
+
+  resolved=$(command -v "$harness" 2>/dev/null || true)
+  if [ -n "$resolved" ] && [ -x "$resolved" ]; then
+    printf '%s\n' "$resolved"
+    return 0
+  fi
+
+  # Desktop app updates can move the bundled Codex binary without rewriting
+  # an already-installed LaunchAgent. Resolve the current app bundle at every
+  # run so a stale absolute path does not disable scoring and drafting.
+  if [ "$harness" = "codex" ]; then
+    local candidate=""
+    for candidate in \
+      "/Applications/ChatGPT.app/Contents/Resources/codex" \
+      "/Applications/Codex.app/Contents/Resources/codex" \
+      "$HOME/Applications/ChatGPT.app/Contents/Resources/codex" \
+      "$HOME/Applications/Codex.app/Contents/Resources/codex"; do
+      if [ -x "$candidate" ]; then
+        printf '%s\n' "$candidate"
+        return 0
+      fi
+    done
+  fi
+
+  return 1
+}
+
 HARNESS="${SCOUT_HARNESS:-}"
+CONFIGURED_HARNESS_BIN="${SCOUT_HARNESS_BIN:-}"
 HARNESS_BIN=""
-if [ -z "$HARNESS" ]; then
-  if command -v claude >/dev/null 2>&1; then
-    HARNESS="claude"
-  elif command -v codex >/dev/null 2>&1; then
+if [ -n "$HARNESS" ]; then
+  HARNESS_BIN=$(resolve_harness_bin "$HARNESS" "$CONFIGURED_HARNESS_BIN" || true)
+else
+  HARNESS_BIN=$(resolve_harness_bin "codex" "" || true)
+  if [ -n "$HARNESS_BIN" ]; then
     HARNESS="codex"
+  else
+    HARNESS_BIN=$(resolve_harness_bin "claude" "" || true)
+    if [ -n "$HARNESS_BIN" ]; then
+      HARNESS="claude"
+    fi
   fi
 fi
-if [ -n "$HARNESS" ]; then
-  HARNESS_BIN=$(command -v "$HARNESS" 2>/dev/null || true)
+if [ -z "${SCOUT_DRAFT_TIMEOUT:-}" ] && [ "$HARNESS" = "codex" ]; then
+  DRAFT_TIMEOUT_SEC=300
 fi
 
+run_harness_prompt() {
+  local timeout_sec="$1"
+  local prompt="$2"
+
+  if [ "$HARNESS" = "claude" ]; then
+    portable_timeout "$timeout_sec" "$HARNESS_BIN" -p "$prompt" --output-format text
+  elif [ "$HARNESS" = "codex" ]; then
+    printf '%s' "$prompt" | portable_timeout "$timeout_sec" "$HARNESS_BIN" exec \
+      -C "$SCRIPT_DIR/.." \
+      --sandbox read-only \
+      --ephemeral \
+      --ignore-user-config \
+      --ignore-rules \
+      --color never
+  else
+    return 127
+  fi
+}
+
 # ── Load persona & avoid keywords ─────────────────────────────
 PERSONA=""
 AVOID_PATTERN=""
@@ -86,6 +155,19 @@ candidate_should_skip() {
   printf '%s\n%s' "$1" "$2" | grep -iqE "$AVOID_PATTERN"
 }
 
+looks_like_harness_error() {
+  printf '%s' "$1" | grep -Eiq 'failed to authenticate|invalid authentication credentials|authentication_error|api error:[[:space:]]*(401|403)|incorrect api key|invalid api key'
+}
+
+abort_if_harness_error() {
+  local stage="$1"
+  local text="$2"
+  if looks_like_harness_error "$text"; then
+    echo "[scout-auto] $stage: harness returned a provider authentication error; not proposing a Moltbook draft"
+    exit 1
+  fi
+}
+
 # Temp file for JSON interchange
 SCOUT_TMP=$(mktemp /tmp/viveworker-scout-XXXXXX.json)
 LOCK_DIR="${TMPDIR:-/tmp}/viveworker-moltbook-scout.lock"
@@ -160,16 +242,12 @@ INTENT: (1-2 sentences in Japanese: why this reply angle fits the incoming comme
 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
+    INBOX_DRAFT_TEXT=$(run_harness_prompt "$DRAFT_TIMEOUT_SEC" "$INBOX_PROMPT" 2>/dev/null) || true
 
     if [ -z "$INBOX_DRAFT_TEXT" ]; then
       echo "[scout-auto] inbox: harness returned empty draft or timed out after ${DRAFT_TIMEOUT_SEC}s"
     else
+      abort_if_harness_error "inbox" "$INBOX_DRAFT_TEXT"
       INBOX_INTENT=""
       INBOX_REPLY_BODY=""
       if echo "$INBOX_DRAFT_TEXT" | grep -q "^---$"; then
@@ -210,16 +288,17 @@ fi
 #   Max 3 approved posts/day. Each slot proposed at most once.
 # ═══════════════════════════════════════════════════════════════
 COMPOSE_MAX="${COMPOSE_MAX:-3}"
+COMPOSE_ACTIVITY_LIMIT="${SCOUT_COMPOSE_ACTIVITY_LIMIT:-30}"
 COMPOSE_JSON=$("$NODE" "$VIVEWORKER" moltbook compose --max-daily "$COMPOSE_MAX" 2>/dev/null) || true
 COMPOSE_STATUS=$(json_field "$COMPOSE_JSON" "status")
 
 if [ "$COMPOSE_STATUS" = "material" ] && [ -n "$HARNESS_BIN" ]; then
   COMPOSE_SLOT=$(json_field "$COMPOSE_JSON" "slot")
   ACTIVITY_COUNT=$(json_field "$COMPOSE_JSON" "activityCount")
-  ACTIVITY_SUMMARY=$(echo "$COMPOSE_JSON" | "$NODE" -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const o=JSON.parse(d);const e=o.activitySummary||[];console.log(e.map(x=>'- ['+x.kind+'] '+x.title+(x.summary?' — '+x.summary:'')).join('\n'))}catch{}})")
-  RECENT_TITLES=$(echo "$COMPOSE_JSON" | "$NODE" -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const o=JSON.parse(d);console.log((o.recentTitles||[]).join(', '))}catch{}})")
+  ACTIVITY_SUMMARY=$(echo "$COMPOSE_JSON" | "$NODE" -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const o=JSON.parse(d);const limit=Number('$COMPOSE_ACTIVITY_LIMIT')||30;const e=(o.activitySummary||[]).slice(0,limit);console.log(e.map(x=>'- ['+x.kind+'] '+x.title+(x.summary?' — '+x.summary:'')).join('\n'))}catch{}})")
+  RECENT_TITLES=$(echo "$COMPOSE_JSON" | "$NODE" -e "let d='';process.stdin.on('data',c=>d+=c);process.stdin.on('end',()=>{try{const o=JSON.parse(d);const titles=(o.recentTitles||[]).map(x=>typeof x==='string'?x:(x&&x.title)||'').filter(Boolean).slice(0,10);console.log(titles.join(', '))}catch{}})")
 
-  echo "[scout-auto] compose ($COMPOSE_SLOT): ${ACTIVITY_COUNT} activities found"
+  echo "[scout-auto] compose ($COMPOSE_SLOT): ${ACTIVITY_COUNT} activities found (using ${COMPOSE_ACTIVITY_LIMIT})"
 
   # Slot-specific tone instructions.
   case "$COMPOSE_SLOT" in
@@ -275,14 +354,10 @@ INTENT: (1-2 sentences in Japanese: why this is worth posting from this persona
 COMPOSE_EOF
   )"
 
-  COMPOSE_DRAFT=""
-  if [ "$HARNESS" = "claude" ]; then
-    COMPOSE_DRAFT=$(portable_timeout 60 "$HARNESS_BIN" -p "$COMPOSE_PROMPT" --output-format text 2>/dev/null) || true
-  elif [ "$HARNESS" = "codex" ]; then
-    COMPOSE_DRAFT=$(portable_timeout 60 "$HARNESS_BIN" exec "$COMPOSE_PROMPT" 2>/dev/null) || true
-  fi
+  COMPOSE_DRAFT=$(run_harness_prompt "$DRAFT_TIMEOUT_SEC" "$COMPOSE_PROMPT" 2>/dev/null) || true
 
   if [ -n "$COMPOSE_DRAFT" ]; then
+    abort_if_harness_error "compose ($COMPOSE_SLOT)" "$COMPOSE_DRAFT"
     # Check for NO_MATCH signal (persona doesn't align with today's work).
     if echo "$COMPOSE_DRAFT" | grep -q "NO_MATCH"; then
       echo "[scout-auto] compose ($COMPOSE_SLOT): persona has no match with current activities — skipping"
@@ -393,17 +468,13 @@ PROMPT_EOF
   )"
 
   echo "[scout-auto] drafting via $HARNESS for '$BEST_TITLE'"
-  DRAFT_TEXT=""
-  if [ "$HARNESS" = "claude" ]; then
-    DRAFT_TEXT=$(portable_timeout "$DRAFT_TIMEOUT_SEC" "$HARNESS_BIN" -p "$DRAFT_PROMPT" --output-format text 2>/dev/null) || true
-  elif [ "$HARNESS" = "codex" ]; then
-    DRAFT_TEXT=$(portable_timeout "$DRAFT_TIMEOUT_SEC" "$HARNESS_BIN" exec "$DRAFT_PROMPT" 2>/dev/null) || true
-  fi
+  DRAFT_TEXT=$(run_harness_prompt "$DRAFT_TIMEOUT_SEC" "$DRAFT_PROMPT" 2>/dev/null) || true
 
   if [ -z "$DRAFT_TEXT" ]; then
     echo "[scout-auto] error: harness returned empty draft or timed out after ${DRAFT_TIMEOUT_SEC}s"
     exit 1
   fi
+  abort_if_harness_error "draft" "$DRAFT_TEXT"
 
   # Parse INTENT and reply body
   INTENT=""
@@ -498,11 +569,13 @@ Post body (first 500 chars): ${POST_CONTENT:0:500}
 
 Reply with ONLY a number from 0 to 100. Nothing else."
 
-    SCORE_RAW=""
-    if [ "$HARNESS" = "claude" ]; then
-      SCORE_RAW=$(portable_timeout 30 "$HARNESS_BIN" -p "$SCORE_PROMPT" --output-format text 2>/dev/null) || true
-    elif [ "$HARNESS" = "codex" ]; then
-      SCORE_RAW=$(portable_timeout 30 "$HARNESS_BIN" exec "$SCORE_PROMPT" 2>/dev/null) || true
+    SCORE_RAW=$(run_harness_prompt 30 "$SCORE_PROMPT" 2>/dev/null) || true
+    abort_if_harness_error "score" "$SCORE_RAW"
+
+    if [ -z "$SCORE_RAW" ]; then
+      SKIP_COUNT=$((SKIP_COUNT + 1))
+      echo "[scout-auto] skipping (score failed): $POST_TITLE (by @$POST_AUTHOR) [$SKIP_COUNT/$MAX_SKIP]"
+      continue
     fi
 
     SCORE=$(echo "$SCORE_RAW" | tr -dc '0-9\n' | head -1)
@@ -515,11 +588,6 @@ Reply with ONLY a number from 0 to 100. Nothing else."
       continue
     fi
 
-    if [ -z "$SCORE_RAW" ]; then
-      SKIP_COUNT=$((SKIP_COUNT + 1))
-      echo "[scout-auto] skipping (score failed): $POST_TITLE (by @$POST_AUTHOR) [$SKIP_COUNT/$MAX_SKIP]"
-      continue
-    fi
   else
     SCORE=50
   fi