viveworker 0.4.7 → 0.4.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.4.7",
+  "version": "0.4.9",
   "description": "Local mobile companion for Codex Desktop and Claude Desktop — approvals, code review, Moltbook drafts, and A2A (Agent-to-Agent) task relay on your LAN.",
   "author": "Yuta Hoshino <hoshino.lireneo@gmail.com>",
   "license": "MIT",

package/scripts/a2a-executor.mjs

@@ -1,20 +1,156 @@
 /**
- * a2a-executor.mjs — Execute approved A2A tasks via Codex CLI.
+ * a2a-executor.mjs — Execute approved A2A tasks via Codex or Claude CLI.
  *
  * After the user approves an A2A task in the PWA, this module spawns
- * `codex exec` to perform the work, captures the output, and updates
- * the task status to completed/failed.
+ * `codex exec` or `claude -p` to perform the work, captures the output,
+ * and updates the task status to completed/failed.
  */
 
-import { spawn } from "node:child_process";
+import { spawn, spawnSync } from "node:child_process";
+import { existsSync } from "node:fs";
 import path from "node:path";
 import os from "node:os";
 import { completeA2ATask, failA2ATask } from "./a2a-handler.mjs";
 
+const APP_BUNDLE_PATH = "/Applications/Codex.app/Contents/Resources/codex";
+
+// ---------------------------------------------------------------------------
+// PATH augmentation for launchd environments
+// ---------------------------------------------------------------------------
+
+/**
+ * Build an augmented PATH that includes nvm, homebrew, and other common
+ * directories so spawned processes (claude, codex) can find `node`, etc.
+ *
+ * Under launchd the inherited PATH is minimal (/usr/bin:/bin:/usr/sbin:/sbin).
+ * We prepend well-known bin directories so child processes work correctly.
+ *
+ * @param {string} [binPath] - Resolved path to the binary being spawned;
+ *                              its parent directory is prepended to PATH.
+ */
+function buildAugmentedPath(binPath) {
+  const extra = [];
+
+  // Include the directory of the resolved binary itself
+  if (binPath && binPath !== "codex" && binPath !== "claude") {
+    extra.push(path.dirname(binPath));
+  }
+
+  // nvm — find the active or latest node version's bin directory
+  const nvmBase = path.join(os.homedir(), ".nvm", "versions", "node");
+  if (existsSync(nvmBase)) {
+    // Prefer NVM_BIN if set (interactive shell), otherwise scan versions
+    if (process.env.NVM_BIN && existsSync(process.env.NVM_BIN)) {
+      extra.push(process.env.NVM_BIN);
+    } else {
+      const ls = spawnSync("ls", [nvmBase], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+      if (ls.status === 0 && ls.stdout) {
+        const versions = ls.stdout.trim().split("\n").filter(Boolean).reverse();
+        for (const v of versions) {
+          const binDir = path.join(nvmBase, v, "bin");
+          if (existsSync(path.join(binDir, "node"))) {
+            extra.push(binDir);
+            break; // use the latest version that has node
+          }
+        }
+      }
+    }
+  }
+
+  // Homebrew and common paths
+  for (const p of ["/opt/homebrew/bin", "/usr/local/bin"]) {
+    if (existsSync(p)) extra.push(p);
+  }
+
+  const basePath = process.env.PATH || "/usr/bin:/bin:/usr/sbin:/sbin";
+  // Deduplicate while preserving order
+  const seen = new Set();
+  const parts = [];
+  for (const dir of [...extra, ...basePath.split(":")]) {
+    if (dir && !seen.has(dir)) {
+      seen.add(dir);
+      parts.push(dir);
+    }
+  }
+  return parts.join(":");
+}
+
+/**
+ * Try to find the claude binary by walking well-known locations.
+ * Returns the absolute path if found, or null.
+ */
+function findClaudeBin() {
+  // 1. `which` works if PATH is set (interactive shell, etc.)
+  const which = spawnSync("which", ["claude"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  if (which.status === 0 && which.stdout) return which.stdout.trim();
+
+  // 2. ~/.claude/local/claude (official standalone install)
+  const standalone = path.join(os.homedir(), ".claude", "local", "claude");
+  if (existsSync(standalone)) return standalone;
+
+  // 3. nvm-managed global install — scan version dirs
+  const nvmBase = path.join(os.homedir(), ".nvm", "versions", "node");
+  if (existsSync(nvmBase)) {
+    const ls = spawnSync("ls", [nvmBase], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+    if (ls.status === 0 && ls.stdout) {
+      const versions = ls.stdout.trim().split("\n").filter(Boolean).reverse();
+      for (const v of versions) {
+        const candidate = path.join(nvmBase, v, "bin", "claude");
+        if (existsSync(candidate)) return candidate;
+      }
+    }
+  }
+
+  // 4. Homebrew / common paths
+  for (const p of ["/usr/local/bin/claude", "/opt/homebrew/bin/claude"]) {
+    if (existsSync(p)) return p;
+  }
+
+  return null;
+}
+
+/**
+ * Detect which executor CLIs are available on this machine.
+ * Returns { codex: boolean, claude: boolean, claudeBin?: string, codexBin?: string }.
+ */
+export function detectAvailableExecutors() {
+  const codexWhich = spawnSync("which", ["codex"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  const codexBin = codexWhich.status === 0 && codexWhich.stdout
+    ? codexWhich.stdout.trim()
+    : existsSync(APP_BUNDLE_PATH) ? APP_BUNDLE_PATH : null;
+
+  const claudeBin = findClaudeBin();
+
+  return {
+    codex: !!codexBin,
+    claude: !!claudeBin,
+    codexBin: codexBin || undefined,
+    claudeBin: claudeBin || undefined,
+  };
+}
+
+/**
+ * Resolve the codex binary path.
+ */
+function resolveCodexBin(config) {
+  if (config.codexBin) return config.codexBin;
+  const which = spawnSync("which", ["codex"], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] });
+  if (which.status === 0 && which.stdout) return which.stdout.trim();
+  if (existsSync(APP_BUNDLE_PATH)) return APP_BUNDLE_PATH;
+  return "codex";
+}
+
+/**
+ * Resolve the claude binary path.
+ */
+function resolveClaudeBin() {
+  return findClaudeBin() || "claude";
+}
+
 const EXEC_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
 
 /**
- * Execute an A2A task by spawning `codex exec`.
+ * Execute an A2A task by spawning the chosen executor.
  *
  * @param {object}   task                  - A2A task object
  * @param {object}   config                - Bridge config
@@ -23,54 +159,89 @@ const EXEC_TIMEOUT_MS = 10 * 60 * 1000; // 10 minutes
  * @param {object}   helpers
  * @param {Function} helpers.recordTimelineEntry
  * @param {Function} helpers.saveState
+ * @param {Function} [helpers.recordHistoryItem]    - Optional history-item recorder (adds to completed inbox)
+ * @param {Function} [helpers.deliverWebPushItem]   - Optional web push delivery helper
+ * @param {string}   [executor]            - "codex" or "claude" (auto-detect if omitted)
  */
-export async function executeA2ATask(task, config, runtime, state, { recordTimelineEntry, saveState }) {
+export async function executeA2ATask(task, config, runtime, state, { recordTimelineEntry, recordHistoryItem, saveState, deliverWebPushItem }, executor) {
   const instruction = task.instruction || "";
   if (!instruction) {
     failA2ATask(task, "No instruction provided");
     return;
   }
 
-  console.log(`[a2a-exec] Starting task ${task.id}: ${instruction.slice(0, 80)}`);
+  // Resolve executor if not specified.
+  if (!executor) {
+    const available = detectAvailableExecutors();
+    executor = available.codex ? "codex" : available.claude ? "claude" : "codex";
+  }
+
+  console.log(`[a2a-exec] Starting task ${task.id} via ${executor}: ${instruction.slice(0, 80)}`);
 
   try {
-    const result = await runCodexExec(instruction, config);
+    const result = executor === "claude"
+      ? await runClaudeExec(instruction)
+      : await runCodexExec(instruction, config);
     completeA2ATask(task, result);
-    console.log(`[a2a-exec] Task ${task.id} completed (${result.length} chars)`);
+    console.log(`[a2a-exec] Task ${task.id} completed via ${executor} (${result.length} chars)`);
   } catch (error) {
     failA2ATask(task, error.message);
-    console.error(`[a2a-exec] Task ${task.id} failed: ${error.message}`);
+    console.error(`[a2a-exec] Task ${task.id} failed via ${executor}: ${error.message}`);
   }
 
-  // Record completion in timeline
+  // Record completion in timeline AND history (history drives completed inbox list).
+  const resultEntry = {
+    stableId: `a2a_task_result:${task.id}`,
+    token: task.token,
+    kind: "a2a_task_result",
+    threadId: "a2a",
+    threadLabel: instruction.slice(0, 80),
+    title: task.status === "completed"
+      ? `A2A ✅: ${instruction.slice(0, 60)}`
+      : `A2A ❌: ${instruction.slice(0, 60)}`,
+    summary: task.status === "completed"
+      ? (task.artifacts?.[0]?.parts?.[0]?.text || "").slice(0, 160)
+      : task.statusMessage || "Failed",
+    instruction,
+    messageText: task.status === "completed"
+      ? (task.artifacts?.[0]?.parts?.[0]?.text || "").slice(0, 500)
+      : task.statusMessage || "Failed",
+    taskStatus: task.status,
+    createdAtMs: task.updatedAtMs || Date.now(),
+    readOnly: true,
+    provider: "a2a",
+  };
   try {
-    recordTimelineEntry({
-      config,
-      runtime,
-      state,
-      entry: {
-        stableId: `a2a_task_result:${task.id}`,
-        token: task.token,
-        kind: "a2a_task",
-        threadId: "a2a",
-        threadLabel: "A2A",
-        title: task.status === "completed"
-          ? `A2A ✅: ${instruction.slice(0, 60)}`
-          : `A2A ❌: ${instruction.slice(0, 60)}`,
-        summary: task.statusMessage || "",
-        messageText: task.status === "completed"
-          ? (task.artifacts?.[0]?.parts?.[0]?.text || "").slice(0, 500)
-          : task.statusMessage || "Failed",
-        taskStatus: task.status,
-        createdAtMs: task.updatedAtMs || Date.now(),
-        readOnly: true,
-        provider: "a2a",
-      },
-    });
+    recordTimelineEntry({ config, runtime, state, entry: resultEntry });
+    if (typeof recordHistoryItem === "function") {
+      recordHistoryItem({ config, runtime, state, item: resultEntry });
+    }
     await saveState(config.stateFile, state);
   } catch (error) {
     console.error(`[a2a-exec-timeline] ${error.message}`);
   }
+
+  // Send web push notification for completion/failure.
+  if (typeof deliverWebPushItem === "function") {
+    try {
+      const isCompleted = task.status === "completed";
+      const icon = isCompleted ? "✅" : "❌";
+      const resultBody = isCompleted
+        ? (task.artifacts?.[0]?.parts?.[0]?.text || "").slice(0, 160)
+        : (task.statusMessage || "Failed").slice(0, 160);
+      await deliverWebPushItem({
+        config,
+        state,
+        kind: "a2a_task_result",
+        token: task.token,
+        stableId: `a2a_task_result:${task.id}`,
+        title: `A2A ${icon}: ${instruction.slice(0, 60)}`,
+        body: resultBody || instruction.slice(0, 160),
+      });
+    } catch (error) {
+      console.error(`[a2a-exec-push] ${error.message}`);
+    }
+  }
 }
 
 /**
@@ -78,23 +249,28 @@ export async function executeA2ATask(task, config, runtime, state, { recordTimel
  */
 function runCodexExec(instruction, config) {
   return new Promise((resolve, reject) => {
-    const codexBin = config.codexBin || "codex";
-    const args = ["exec", "--prompt", instruction, "--approval-mode", "full-auto"];
-    const cwd = config.workspaceRoot || process.cwd();
+    const codexBin = resolveCodexBin(config);
+    const args = ["exec", "--full-auto", "--skip-git-repo-check", instruction];
+    const cwd = config.workspaceRoot || os.tmpdir();
 
     const child = spawn(codexBin, args, {
       cwd,
-      stdio: ["ignore", "pipe", "pipe"],
-      env: { ...process.env, CODEX_HOME: config.codexHome || path.join(os.homedir(), ".codex") },
+      stdio: ["pipe", "pipe", "pipe"],
+      env: {
+        ...process.env,
+        PATH: buildAugmentedPath(codexBin),
+        CODEX_HOME: config.codexHome || path.join(os.homedir(), ".codex"),
+      },
       timeout: EXEC_TIMEOUT_MS,
     });
 
+    child.stdin.end();
+
     let stdout = "";
     let stderr = "";
 
     child.stdout.on("data", (chunk) => {
       stdout += chunk.toString("utf8");
-      // Cap output at 100KB
       if (stdout.length > 100_000) {
         child.kill("SIGTERM");
       }
@@ -117,10 +293,60 @@ function runCodexExec(instruction, config) {
       }
     });
 
-    // Timeout fallback
     setTimeout(() => {
       try { child.kill("SIGTERM"); } catch { /* ignore */ }
       reject(new Error("codex exec timed out (10 minutes)"));
     }, EXEC_TIMEOUT_MS).unref?.();
   });
 }
+
+/**
+ * Spawn `claude -p` and capture stdout+stderr.
+ */
+function runClaudeExec(instruction) {
+  return new Promise((resolve, reject) => {
+    const claudeBin = resolveClaudeBin();
+    const args = ["-p", instruction, "--output-format", "text"];
+
+    const child = spawn(claudeBin, args, {
+      cwd: os.tmpdir(),
+      stdio: ["pipe", "pipe", "pipe"],
+      env: { ...process.env, PATH: buildAugmentedPath(claudeBin) },
+      timeout: EXEC_TIMEOUT_MS,
+    });
+
+    child.stdin.end();
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+      if (stdout.length > 100_000) {
+        child.kill("SIGTERM");
+      }
+    });
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+      if (stderr.length > 50_000) stderr = stderr.slice(-50_000);
+    });
+
+    child.on("error", (error) => {
+      reject(new Error(`Failed to spawn claude: ${error.message}`));
+    });
+
+    child.on("close", (code) => {
+      if (code === 0) {
+        resolve(stdout.trim() || "(completed with no output)");
+      } else {
+        const errorDetail = stderr.trim() || stdout.trim() || `exit code ${code}`;
+        reject(new Error(`claude exec failed: ${errorDetail.slice(0, 500)}`));
+      }
+    });
+
+    setTimeout(() => {
+      try { child.kill("SIGTERM"); } catch { /* ignore */ }
+      reject(new Error("claude exec timed out (10 minutes)"));
+    }, EXEC_TIMEOUT_MS).unref?.();
+  });
+}

package/scripts/a2a-handler.mjs

@@ -291,6 +291,10 @@ async function handleMessageSend({
 
   runtime.a2aTasksByToken.set(token, task);
 
+  // Update received task counter.
+  if (!state.a2aTaskStats) state.a2aTaskStats = { received: 0, completed: 0, denied: 0 };
+  state.a2aTaskStats.received += 1;
+
   // Record timeline entry
   try {
     recordTimelineEntry({
@@ -302,9 +306,10 @@ async function handleMessageSend({
         token,
         kind: "a2a_task",
         threadId: "a2a",
-        threadLabel: "A2A",
+        threadLabel: cleanText(instruction).slice(0, 80),
         title: `A2A: ${cleanText(instruction).slice(0, 80)}`,
         summary: cleanText(instruction).slice(0, 160),
+        instruction,
         messageText: instruction,
         createdAtMs: now,
         readOnly: false,

package/scripts/a2a-relay-client.mjs

@@ -68,6 +68,7 @@ export async function registerWithRelay({ config, buildAgentCard }) {
     userId,
     bridgeSecret,
     a2aApiKey: config.a2aApiKey || "",
+    acceptPublicTasks: config.a2aAcceptPublicTasks || false,
     agentCard,
     ...(config.a2aRelayRegisterSecret ? { registerSecret: config.a2aRelayRegisterSecret } : {}),
   };
@@ -166,6 +167,14 @@ export function stopRelayPolling() {
   console.log("[a2a-relay] Polling stopped");
 }
 
+/**
+ * Update the acceptPublicTasks flag on the relay via re-registration.
+ */
+export async function updatePublicTasksFlag({ config, buildAgentCard, acceptPublicTasks }) {
+  config.a2aAcceptPublicTasks = acceptPublicTasks;
+  return registerWithRelay({ config, buildAgentCard });
+}
+
 /**
  * Return current relay connection status for the settings UI.
  */
@@ -261,6 +270,10 @@ async function ingestRelayTask({ relayTask, config, runtime, state, helpers }) {
 
   runtime.a2aTasksByToken.set(token, task);
 
+  // Update received task counter.
+  if (!state.a2aTaskStats) state.a2aTaskStats = { received: 0, completed: 0, denied: 0 };
+  state.a2aTaskStats.received += 1;
+
   // Record timeline entry (same as local A2A handler)
   try {
     recordTimelineEntry({

package/scripts/moltbook-api.mjs

@@ -4,12 +4,14 @@
 import fs from "node:fs/promises";
 import os from "node:os";
 import path from "node:path";
+import { spawn } from "node:child_process";
 
 export const API_BASE = "https://www.moltbook.com/api/v1";
 
 export const DEFAULT_ENV_FILE = path.join(os.homedir(), ".viveworker", "moltbook.env");
 export const DEFAULT_INBOX_DIR = path.join(os.homedir(), ".viveworker", "moltbook-inbox");
 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");
 
 export async function loadMoltbookEnv(envFile = DEFAULT_ENV_FILE) {
   const env = {};
@@ -170,14 +172,14 @@ export function rollScoutDayIfNeeded(state) {
   return state;
 }
 
-export function recordComposeAttempt(state, title, postId) {
+export function recordComposeAttempt(state, title, postId, type = "post") {
   state.composedToday = (state.composedToday || 0) + 1;
   state.lastComposeDay = todayKey();
   if (!Array.isArray(state.recentComposeTitles)) state.recentComposeTitles = [];
-  state.recentComposeTitles.unshift(
-    postId ? { title: String(title || ""), postId: String(postId) } : String(title || "")
-  );
-  if (state.recentComposeTitles.length > 10) state.recentComposeTitles.length = 10;
+  const entry = { title: String(title || ""), type };
+  if (postId) entry.postId = String(postId);
+  state.recentComposeTitles.unshift(entry);
+  if (state.recentComposeTitles.length > 30) state.recentComposeTitles.length = 30;
   return state;
 }
 
@@ -204,3 +206,210 @@ export async function listInboxItems(dir = DEFAULT_INBOX_DIR) {
     return [];
   }
 }
+
+// ---------- Draft persistence ----------
+//
+// Pending Moltbook drafts (reply proposals and original-post proposals) are
+// written to disk so they survive bridge restarts.  One JSON file per draft,
+// keyed by its bridge-assigned token.
+
+export async function ensureDraftsDir(dir = DEFAULT_DRAFTS_DIR) {
+  await fs.mkdir(dir, { recursive: true });
+  return dir;
+}
+
+function draftPathFor(token, dir = DEFAULT_DRAFTS_DIR) {
+  // Token may contain colons — encode for safe filenames.
+  const safe = encodeURIComponent(token);
+  return path.join(dir, `${safe}.json`);
+}
+
+export async function writeDraft(draft, dir = DEFAULT_DRAFTS_DIR) {
+  await ensureDraftsDir(dir);
+  // Exclude runtime-only fields (decisionWaiters is an array of callbacks).
+  const { decisionWaiters, ...serializable } = draft;
+  await fs.writeFile(draftPathFor(draft.token, dir), JSON.stringify(serializable, null, 2) + "\n", "utf8");
+}
+
+export async function readDraft(token, dir = DEFAULT_DRAFTS_DIR) {
+  try {
+    const raw = await fs.readFile(draftPathFor(token, dir), "utf8");
+    return JSON.parse(raw);
+  } catch {
+    return null;
+  }
+}
+
+export async function deleteDraft(token, dir = DEFAULT_DRAFTS_DIR) {
+  try {
+    await fs.unlink(draftPathFor(token, dir));
+  } catch (error) {
+    if (error.code !== "ENOENT") throw error;
+  }
+}
+
+export async function listPendingDrafts(dir = DEFAULT_DRAFTS_DIR) {
+  try {
+    const files = await fs.readdir(dir);
+    const drafts = [];
+    for (const file of files) {
+      if (!file.endsWith(".json")) continue;
+      try {
+        const raw = await fs.readFile(path.join(dir, file), "utf8");
+        const draft = JSON.parse(raw);
+        if (draft && !draft.decision) drafts.push(draft);
+      } catch {
+        // skip bad file
+      }
+    }
+    return drafts;
+  } catch {
+    return [];
+  }
+}
+
+// ---------- Verification puzzle solvers ----------
+//
+// Shared by the CLI (for manual `reply` flow) and the bridge (for fire-and-
+// forget draft posting on approval).
+
+// Naive verification-puzzle solver. Handles the obfuscated two-number
+// arithmetic Moltbook currently uses (add / subtract / multiply). Returns
+// `null` if it can't confidently solve — caller falls back to LLM or manual.
+export function solveVerificationPuzzle(challengeText) {
+  if (!challengeText) return null;
+  const cleaned = String(challengeText)
+    .replace(/[^a-zA-Z0-9\s]/g, " ")
+    .toLowerCase();
+  const numberWords = {
+    zero: 0, one: 1, two: 2, three: 3, four: 4, five: 5, six: 6, seven: 7, eight: 8, nine: 9,
+    ten: 10, eleven: 11, twelve: 12, thirteen: 13, fourteen: 14, fifteen: 15, sixteen: 16,
+    seventeen: 17, eighteen: 18, nineteen: 19, twenty: 20, thirty: 30, forty: 40, fifty: 50,
+    sixty: 60, seventy: 70, eighty: 80, ninety: 90, hundred: 100,
+  };
+  const collapseRuns = (w) => w.replace(/([a-z])\1+/g, "$1");
+  const rawTokens = cleaned
+    .replace(/[^a-z0-9\s]/g, " ")
+    .split(/\s+/)
+    .filter(Boolean);
+  const operationWords = new Set([
+    "total", "combined", "force", "velocity", "speed", "gains", "plus", "and",
+    "subtract", "minus", "less", "difference", "decreased", "loses", "lost", "slower", "slows", "slowed",
+    "multiply", "times", "product", "multiplied",
+    "divide", "divided", "ratio",
+    "how", "much", "what", "exerts", "new",
+  ]);
+  const isKnown = (w) => numberWords[w] != null || numberWords[collapseRuns(w)] != null || operationWords.has(w) || operationWords.has(collapseRuns(w));
+  const merged = [];
+  let ti = 0;
+  while (ti < rawTokens.length) {
+    let best = rawTokens[ti];
+    let bestLen = 1;
+    let candidate = rawTokens[ti];
+    for (let span = 2; span <= Math.min(4, rawTokens.length - ti); span++) {
+      candidate += rawTokens[ti + span - 1];
+      if (isKnown(candidate) || isKnown(collapseRuns(candidate))) {
+        best = candidate;
+        bestLen = span;
+      }
+    }
+    merged.push(best);
+    ti += bestLen;
+  }
+  const words = merged.map((w) => {
+    if (/^\d+$/.test(w)) return w;
+    if (numberWords[w] != null) return w;
+    const collapsed = collapseRuns(w);
+    if (numberWords[collapsed] != null) return collapsed;
+    return collapsed;
+  });
+  const numbers = [];
+  let i = 0;
+  while (i < words.length) {
+    const w = words[i];
+    if (/^\d+$/.test(w)) {
+      numbers.push(Number(w));
+      i += 1;
+      continue;
+    }
+    if (numberWords[w] != null) {
+      let total = numberWords[w];
+      i += 1;
+      while (i < words.length && numberWords[words[i]] != null) {
+        const next = numberWords[words[i]];
+        if (next === 100) total *= 100;
+        else if (next < 100 && total < 100) total += next;
+        else break;
+        i += 1;
+      }
+      numbers.push(total);
+      continue;
+    }
+    i += 1;
+  }
+  if (numbers.length < 2) return null;
+  const a = numbers[0];
+  const b = numbers[1];
+  const hasWord = (w) => words.includes(w);
+  const hasAny = (...ws) => ws.some(hasWord);
+  let result;
+  if (hasAny("subtract", "minus", "less", "difference", "decreased", "loses", "lost", "slower", "slows", "slowed")) {
+    result = a - b;
+  } else if (hasAny("multiply", "times", "product", "multiplied")) {
+    result = a * b;
+  } else if (hasAny("divide", "divided", "ratio")) {
+    result = b !== 0 ? a / b : a;
+  } else {
+    result = a + b;
+  }
+  return result.toFixed(2);
+}
+
+// LLM-based verification puzzle solver. Shells out to claude or codex CLI.
+// Returns the answer as "XX.XX" string, or null if unavailable.
+export async function solvePuzzleWithLLM(challengeText) {
+  if (!challengeText) return null;
+  const prompt =
+    `The following text is an obfuscated arithmetic word problem from Moltbook (an AI social network). ` +
+    `The text has random capitalization, doubled letters, and stray punctuation — ignore all of that. ` +
+    `CRITICAL: ALL symbols (/, *, ^, ~, [, ], etc.) are NOISE, NOT arithmetic operators. ` +
+    `The operation is ALWAYS expressed in natural language words only. ` +
+    `Extract the numbers (written as words like "thirty five" = 35), determine the operation from WORDS ONLY ` +
+    `(addition: "total", "combined", "and", "plus", "gains", "new velocity"; ` +
+    `subtraction: "difference", "minus", "less", "loses"; ` +
+    `multiplication: "times", "product", "multiplied"; ` +
+    `division: "divided by", "ratio", "per"). ` +
+    `If no operation word is found, default to addition. ` +
+    `Compute the result and output ONLY the number with exactly 2 decimal places (e.g. "58.00"). No other text.\n\n` +
+    `Puzzle: ${challengeText}`;
+  for (const cmd of ["claude", "codex"]) {
+    let bin;
+    try {
+      bin = await new Promise((resolve) => {
+        const p = spawn("command", ["-v", cmd], { shell: "/bin/bash", stdio: ["ignore", "pipe", "ignore"] });
+        let out = "";
+        p.stdout.on("data", (d) => (out += d.toString()));
+        p.on("exit", (code) => resolve(code === 0 ? out.trim() : ""));
+        p.on("error", () => resolve(""));
+      });
+    } catch { bin = ""; }
+    if (!bin) continue;
+    const args = cmd === "claude" ? ["-p", prompt, "--output-format", "text"] : ["exec", prompt];
+    try {
+      const result = await new Promise((resolve, reject) => {
+        const p = spawn(bin, args, { stdio: ["ignore", "pipe", "pipe"], timeout: 30000 });
+        let out = "";
+        p.stdout.on("data", (d) => (out += d.toString()));
+        p.on("exit", (code) => (code === 0 ? resolve(out.trim()) : reject(new Error(`exit ${code}`))));
+        p.on("error", reject);
+      });
+      const match = result.match(/(\d+\.\d{2})/);
+      if (match) return match[1];
+      const intMatch = result.match(/^(\d+)$/m);
+      if (intMatch) return `${intMatch[1]}.00`;
+    } catch {
+      // try next
+    }
+  }
+  return null;
+}