viveworker 0.6.0 → 0.6.2

package/README.md

@@ -168,12 +168,21 @@ What it supports:
 - optional password protection
 - optional expiry
 
+HTML uploads are optimized by default when possible.
+This is especially useful for bundled standalone HTML exports that carry large embedded font payloads.
+`viveworker share upload` will try to shrink those files locally before upload, which often makes otherwise-too-large deck or prototype exports shareable without extra prep.
+
+If you want the original HTML bytes untouched, use `--no-optimize`.
+When optimization strips embedded fonts, layout and typography may change slightly, but the goal is to preserve a usable standalone share URL.
+
 It reuses the same A2A credentials as the rest of `viveworker`, so there is no separate auth or setup step.
 
 Typical commands:
 
 - `npx viveworker share upload report.html`
+- `npx viveworker share upload deck_standalone.html`
 - `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 update <slug> --password "hunter2"`
 - `npx viveworker share update <slug> --expires-days 7`

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "viveworker",
-  "version": "0.6.0",
+  "version": "0.6.2",
   "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/moltbook-api.mjs

@@ -312,43 +312,114 @@ export async function listPendingDrafts(dir = DEFAULT_DRAFTS_DIR) {
 //
 // Shared by the CLI (for manual `reply` flow) and the bridge (for fire-and-
 // forget draft posting on approval).
+//
+// Moltbook's verification puzzles are obfuscated word problems — e.g.
+// `lOoB-stErR ClAw FoRcE iS tHiRtY fIvE NoOtOnS aNd iT s OtHeR ClAw Is tWeNtY
+// tHrEe NooToNs, tOtAl/ FoRcE?` → 35 + 23 = 58.00. The solver strips
+// non-letter noise, identifies number words (including compounds like
+// "one hundred forty two" = 142), identifies operator words around each
+// number, and evaluates left-to-right. See `scripts/test-puzzle-solver.mjs`
+// for the regression corpus; add new cases there whenever we observe a
+// failure in the wild via the `~/.viveworker/moltbook-verify-history.jsonl`
+// log.
+
+// Operator encoding: 0=add, 1=sub, 2=mul, 3=div.
+const OP_ADD = 0;
+const OP_SUB = 1;
+const OP_MUL = 2;
+const OP_DIV = 3;
+
+const NUMBER_WORDS = Object.freeze({
+  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, thousand: 1000,
+  // Cultural shortcuts that occasionally appear in the generator.
+  dozen: 12, score: 20,
+});
+
+// Operator words. Keep contextual/framing words (force, velocity, total, etc.)
+// mapped to OP_ADD so their presence doesn't crash the parser — the binary-
+// sequence builder drops ops that have no number to operate against.
+const OP_WORDS = Object.freeze({
+  // Addition / neutral-context.
+  add: OP_ADD, added: OP_ADD, adds: OP_ADD, plus: OP_ADD, and: OP_ADD,
+  sum: OP_ADD, summed: OP_ADD, combined: OP_ADD, combine: OP_ADD, together: OP_ADD,
+  total: OP_ADD, totaled: OP_ADD, totals: OP_ADD, both: OP_ADD,
+  gain: OP_ADD, gains: OP_ADD, gained: OP_ADD,
+  increase: OP_ADD, increased: OP_ADD, increases: OP_ADD,
+  boost: OP_ADD, boosted: OP_ADD, boosts: OP_ADD,
+  faster: OP_ADD, accelerates: OP_ADD, accelerated: OP_ADD, more: OP_ADD,
+  force: OP_ADD, velocity: OP_ADD, speed: OP_ADD, exerts: OP_ADD, new: OP_ADD,
+  // Subtraction.
+  minus: OP_SUB, less: OP_SUB, difference: OP_SUB, subtract: OP_SUB,
+  subtracts: OP_SUB, subtracted: OP_SUB,
+  decrease: OP_SUB, decreased: OP_SUB, decreases: OP_SUB,
+  loses: OP_SUB, lost: OP_SUB, lose: OP_SUB,
+  reduce: OP_SUB, reduced: OP_SUB, reduces: OP_SUB, reducing: OP_SUB, reduction: OP_SUB,
+  drop: OP_SUB, drops: OP_SUB, dropped: OP_SUB,
+  slower: OP_SUB, slows: OP_SUB, slowed: OP_SUB,
+  remove: OP_SUB, removes: OP_SUB, removed: OP_SUB,
+  // Multiplication.
+  multiply: OP_MUL, multiplied: OP_MUL, multiplies: OP_MUL,
+  times: OP_MUL, product: OP_MUL,
+  twice: OP_MUL, double: OP_MUL, doubled: OP_MUL,
+  triple: OP_MUL, tripled: OP_MUL,
+  squared: OP_MUL, square: OP_MUL,
+  // Division.
+  divide: OP_DIV, divided: OP_DIV, divides: OP_DIV, division: OP_DIV,
+  ratio: OP_DIV,
+  // NOTE: "per" intentionally NOT mapped here — "per second" / "per hour"
+  // are units, not division operators. When a puzzle really means division
+  // it uses "divided by" or "ratio of" or "split".
+  half: OP_DIV, halved: OP_DIV, halves: OP_DIV,
+  split: OP_DIV,
+});
+
+// Collapse runs of the same letter: the generator often doubles consonants
+// (e.g. "NoOtOnS" → "nootons"; "lOoB-stErR" → "loobsterr"). Collapsing means
+// known-word detection still fires on the de-doubled form.
+const collapseRuns = (w) => w.replace(/([a-z])\1+/g, "$1");
+
+function lookupWord(word) {
+  if (NUMBER_WORDS[word] != null) return { type: "num", value: NUMBER_WORDS[word] };
+  if (OP_WORDS[word] != null) return { type: "op", value: OP_WORDS[word] };
+  const collapsed = collapseRuns(word);
+  if (collapsed !== word) {
+    if (NUMBER_WORDS[collapsed] != null) return { type: "num", value: NUMBER_WORDS[collapsed] };
+    if (OP_WORDS[collapsed] != null) return { type: "op", value: OP_WORDS[collapsed] };
+  }
+  return null;
+}
 
-// 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.
+// Naive verification-puzzle solver. Returns answer as "XX.XX" or null if we
+// can't confidently recover two numbers. Caller falls back to LLM.
 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
+
+  // Strip everything that isn't a letter or digit. Symbols (/, *, ^, ~, [, ])
+  // are deliberately NOT operators — the generator sprinkles them as pure
+  // noise. All real operators are spelled out in words.
+  const rawTokens = String(challengeText)
+    .toLowerCase()
     .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));
+
+  // The generator sometimes splits a known word into pieces separated by
+  // stripped punctuation (e.g. "tHiR-tY" → "thir" "ty"). Try to re-merge
+  // adjacent tokens if their concatenation is a known number or operator.
   const merged = [];
   let ti = 0;
   while (ti < rawTokens.length) {
-    let best = rawTokens[ti];
     let bestLen = 1;
+    let best = rawTokens[ti];
     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))) {
+      if (lookupWord(candidate)) {
         best = candidate;
         bestLen = span;
       }
@@ -356,57 +427,199 @@ export function solveVerificationPuzzle(challengeText) {
     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];
+
+  // Convert the token stream into a sequence of {type:"num"|"op", value}.
+  // Compound numbers ("one hundred forty two" = 142) are collected greedily.
+  const tokens = [];
+  let j = 0;
+  while (j < merged.length) {
+    const w = merged[j];
+
+    // Bare digit.
     if (/^\d+$/.test(w)) {
-      numbers.push(Number(w));
-      i += 1;
+      tokens.push({ type: "num", value: Number(w) });
+      j += 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;
+
+    const lookup = lookupWord(w);
+    if (!lookup) { j += 1; continue; }
+
+    if (lookup.type === "num") {
+      // Greedy compound-number consumption. Examples:
+      //   "thirty five"                =  35  (chunk += 30 then chunk += 5)
+      //   "one hundred forty two"      = 142  (chunk=1 → *100 → +40 → +2)
+      //   "three thousand four hundred fifty" = 3450
+      let sum = 0;
+      let chunk = 0;
+      let consumed = false;
+      while (j < merged.length) {
+        const cur = merged[j];
+        if (/^\d+$/.test(cur)) {
+          if (consumed) break; // mixing word-number + digit-number, stop
+          sum = Number(cur);
+          consumed = true;
+          j += 1;
+          break;
+        }
+        const inner = lookupWord(cur);
+        if (!inner || inner.type !== "num") break;
+        const n = inner.value;
+        if (n === 1000) {
+          sum += (chunk || 1) * 1000;
+          chunk = 0;
+        } else if (n === 100) {
+          chunk = (chunk || 1) * 100;
+        } else {
+          // n < 100: tens + ones accumulate into the current chunk.
+          chunk += n;
+        }
+        consumed = true;
+        j += 1;
       }
-      numbers.push(total);
+      if (consumed) tokens.push({ type: "num", value: sum + chunk });
       continue;
     }
-    i += 1;
+
+    // Operator.
+    tokens.push({ type: "op", value: lookup.value });
+    j += 1;
+  }
+
+  // Capture the first non-default op that appears BEFORE the first number.
+  // Phrases like "product of X and Y", "difference between X and Y", and
+  // "ratio of X to Y" put the real operation at the front and leave only a
+  // weak connector ("and", "to", "of") between the numbers. Without this,
+  // the solver would drop the leading op and default to addition.
+  let leadingStrongOp = null;
+  for (const t of tokens) {
+    if (t.type === "num") break;
+    if (t.type === "op" && t.value !== OP_ADD) { leadingStrongOp = t.value; break; }
+  }
+
+  // Normalise into a strict alternation [num, op, num, op, num, ...].
+  //   - Drop leading ops (framing words like "total force is ...").
+  //   - If two ops appear back-to-back, prefer the STRONGER (non-ADD) one
+  //     over the default ADD. This is because contextual framing verbs
+  //     (force / velocity / speed / exerts) are mapped to OP_ADD so their
+  //     presence doesn't crash the parser, but they should NOT clobber a
+  //     real operator (OP_SUB / OP_MUL / OP_DIV) that appears right next
+  //     to them. Example: "reducing speed by four" → tokens end up as
+  //     [OP_SUB(reducing), OP_ADD(speed)] — SUB must survive.
+  //     When both ops are the same strength, the latter wins (closest to
+  //     the following number).
+  //   - If two nums appear with no op between them, insert a default add.
+  //   - Drop trailing ops.
+  const seq = [];
+  for (const t of tokens) {
+    if (seq.length === 0) {
+      if (t.type === "num") seq.push(t);
+      continue;
+    }
+    const last = seq[seq.length - 1];
+    if (t.type === "num") {
+      if (last.type === "num") {
+        seq.push({ type: "op", value: OP_ADD });
+      }
+      seq.push(t);
+    } else {
+      if (last.type === "op") {
+        // Prefer strong over default (ADD). Otherwise latter wins.
+        if (last.value === OP_ADD && t.value !== OP_ADD) {
+          seq[seq.length - 1] = t;
+        } else if (last.value !== OP_ADD && t.value === OP_ADD) {
+          // Keep last — strong op survives over a trailing framing verb.
+        } else {
+          seq[seq.length - 1] = t;
+        }
+      } else {
+        seq.push(t);
+      }
+    }
   }
-  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;
+  while (seq.length > 0 && seq[seq.length - 1].type === "op") seq.pop();
+
+  if (seq.length < 3) return null;
+  if (seq[0].type !== "num") return null;
+
+  // Promote the leading op if no strong op appeared between the numbers. We
+  // only do this when every internal op is the default OP_ADD — otherwise
+  // the internal ops were the real signal (e.g. "a+b-c" should stay mixed,
+  // even if the sentence started with "total").
+  if (leadingStrongOp != null) {
+    const hasStrongInternal = seq.some((t) => t.type === "op" && t.value !== OP_ADD);
+    if (!hasStrongInternal) {
+      for (const t of seq) {
+        if (t.type === "op") t.value = leadingStrongOp;
+      }
+    }
+  }
+
+  // Evaluate strictly left-to-right (no precedence — Moltbook puzzles are
+  // binary in practice, so this only matters for the rare 3-number case).
+  let result = seq[0].value;
+  for (let k = 1; k < seq.length; k += 2) {
+    const op = seq[k];
+    const rhs = seq[k + 1];
+    if (!op || !rhs || op.type !== "op" || rhs.type !== "num") break;
+    switch (op.value) {
+      case OP_ADD: result += rhs.value; break;
+      case OP_SUB: result -= rhs.value; break;
+      case OP_MUL: result *= rhs.value; break;
+      case OP_DIV: result = rhs.value !== 0 ? result / rhs.value : result; break;
+      default: break;
+    }
   }
+
+  if (!Number.isFinite(result)) return null;
+  // Refuse answers the puzzle generator shouldn't produce. A negative answer
+  // usually means we mis-identified the operator direction; returning null
+  // lets the LLM take a clean shot rather than submitting a definitely-wrong
+  // value.
+  if (result < 0) return null;
+
   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.
+//
+// The naive solver misses ~13% of Moltbook's puzzles (mostly 3-number or
+// unusual-vocabulary cases). The LLM fallback has been the same ~13% blind
+// spot because parsing was too strict — it only accepted "XX.XX" on its own
+// or a pure-integer line, and many CLI wrappers prepend banners or reason
+// step-by-step before emitting the final number. `extractPuzzleAnswerFromText`
+// is now shared with `solvePuzzleWithLLM` and is much more forgiving:
+// prefer explicit decimals, fall back to the last standalone integer, then
+// the last integer anywhere in the response. Exported for tests.
+export function extractPuzzleAnswerFromText(text) {
+  if (!text) return null;
+  const trimmed = String(text).trim();
+  if (!trimmed) return null;
+
+  // 1. Prefer an exact "NN.NN" (two decimals) token. This is what the prompt
+  //    explicitly asks for and what every happy-path response contains.
+  const twoDecimal = trimmed.match(/(?:^|[^\d])(\d+\.\d{2})(?:[^\d]|$)/);
+  if (twoDecimal) return twoDecimal[1];
+
+  // 2. Accept a one-decimal form and pad — e.g. "58.5" → "58.50".
+  const oneDecimal = trimmed.match(/(?:^|[^\d])(\d+\.\d)(?:[^\d]|$)/);
+  if (oneDecimal) return `${oneDecimal[1]}0`;
+
+  // 3. If the response contains any integer at all, use the LAST one. The LLM
+  //    often reasons step-by-step ("thirty-five = 35, twenty-three = 23,
+  //    sum is 58"), and the final integer is the answer. This is less
+  //    precise than step (1) but beats returning null on otherwise-correct
+  //    reasoning.
+  const ints = [...trimmed.matchAll(/\b(\d+)\b/g)].map((m) => m[1]);
+  if (ints.length > 0) {
+    const pick = Number(ints[ints.length - 1]);
+    if (Number.isFinite(pick) && pick >= 0) return `${pick}.00`;
+  }
+
+  return null;
+}
+
 export async function solvePuzzleWithLLM(challengeText) {
   if (!challengeText) return null;
   const prompt =
@@ -414,13 +627,16 @@ export async function solvePuzzleWithLLM(challengeText) {
     `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"). ` +
+    `Extract the numbers (written as words like "thirty five" = 35, or "one hundred forty" = 140), ` +
+    `determine the operation from WORDS ONLY ` +
+    `(addition: "total", "combined", "and", "plus", "gains", "sum", "together", "increased", "new velocity"; ` +
+    `subtraction: "difference", "minus", "less", "loses", "decreased", "reduced"; ` +
+    `multiplication: "times", "product", "multiplied", "doubled", "tripled", "squared"; ` +
+    `division: "divided by", "ratio", "per", "halved"). ` +
+    `If two or more operation words appear, apply them left-to-right in order. ` +
     `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` +
+    `Compute the result and output ONLY the number with exactly 2 decimal places (e.g. "58.00"). ` +
+    `No reasoning, no other text — JUST the number.\n\n` +
     `Puzzle: ${challengeText}`;
   for (const cmd of ["claude", "codex"]) {
     let bin;
@@ -443,13 +659,44 @@ export async function solvePuzzleWithLLM(challengeText) {
         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`;
+      const extracted = extractPuzzleAnswerFromText(result);
+      if (extracted) return extracted;
     } catch {
       // try next
     }
   }
   return null;
 }
+
+// ---------- Verification history (for offline analysis / retraining) ----------
+//
+// Every verify attempt — whether it succeeded, was rejected by the server,
+// or couldn't be solved at all — gets a single JSONL line appended to
+// `~/.viveworker/moltbook-verify-history.jsonl`. The file is the only way to
+// reconstruct a failing `challenge_text` after the fact, because the puzzle
+// is ephemeral on the Moltbook side (returned once in the POST /posts
+// response and never exposed again).
+//
+// Having the corpus lets us:
+//   1. Diagnose concrete failures with `scripts/test-puzzle-solver.mjs`.
+//   2. Add new regression cases to the test harness when a new template
+//      starts appearing.
+//   3. Measure solver vs LLM hit rate over time.
+export const DEFAULT_VERIFY_HISTORY_FILE = path.join(
+  os.homedir(), ".viveworker", "moltbook-verify-history.jsonl"
+);
+
+export async function recordPuzzleAttempt(entry, file = DEFAULT_VERIFY_HISTORY_FILE) {
+  try {
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    const record = {
+      ts: new Date().toISOString(),
+      ...entry,
+    };
+    await fs.appendFile(file, JSON.stringify(record) + "\n", "utf8");
+  } catch (err) {
+    // Best-effort logging — never fail a post just because the history file
+    // is unwritable.
+    try { console.error(`[moltbook-verify-history] Failed to record: ${err.message}`); } catch { /* ignore */ }
+  }
+}

package/scripts/share-cli.mjs

@@ -7,7 +7,7 @@
  *   .html .htm .pdf .png .jpg .jpeg .gif .webp .csv
  *
  * Commands:
- *   viveworker share upload <file> [--password <pw>] [--expires-days <n>] [--json]
+ *   viveworker share upload <file> [--password <pw>] [--expires-days <n>] [--no-optimize] [--json]
  *   viveworker share list [--json]
  *   viveworker share update <slug> [--password <pw>] [--no-password] [--expires-days <n>] [--json]
  *   viveworker share link <slug> --password <pw> [--ttl-hours <n>] [--json]
@@ -71,7 +71,7 @@ export async function runShareCli(args) {
 
 function printHelp() {
   console.log("Commands:");
-  console.log("  viveworker share upload <file> [--password <pw>] [--expires-days <n>] [--json]");
+  console.log("  viveworker share upload <file> [--password <pw>] [--expires-days <n>] [--no-optimize] [--json]");
   console.log("  viveworker share list [--json]");
   console.log("  viveworker share update <slug> [--password <pw>] [--no-password] [--expires-days <n>] [--json]");
   console.log("  viveworker share link <slug> --password <pw> [--ttl-hours <n>] [--json]");
@@ -79,6 +79,7 @@ function printHelp() {
   console.log("");
   console.log(`Accepted file types: ${ALLOWED_EXTENSIONS.join(" / ")}`);
   console.log("CSV files are rendered as an HTML table on view; append ?raw=1 for bytes.");
+  console.log("HTML uploads are optimized by default when possible (use --no-optimize to disable).");
   console.log("");
   console.log("Credentials are read from ~/.viveworker/a2a.env (same as `viveworker a2a`).");
 }
@@ -107,9 +108,6 @@ async function handleUpload(args) {
   if (stat.size === 0) {
     throw new Error(`File is empty: ${filePath}`);
   }
-  if (stat.size > MAX_FILE_SIZE) {
-    throw new Error(`File too large (${stat.size} bytes, max ${MAX_FILE_SIZE})`);
-  }
   const ext = path.extname(absolute).toLowerCase();
   if (!ALLOWED_EXTENSIONS.includes(ext)) {
     throw new Error(
@@ -134,7 +132,18 @@ async function handleUpload(args) {
 
   const { apiKey, userId, shareUrl } = await resolveCredentials();
 
-  const bytes = await fs.readFile(absolute);
+  const originalBytes = await fs.readFile(absolute);
+  const optimization =
+    flags["no-optimize"] || flags["noOptimize"]
+      ? { bytes: originalBytes, info: null }
+      : maybeOptimizeUpload({ absolute, ext, bytes: originalBytes });
+  const bytes = optimization.bytes;
+  if (bytes.length > MAX_FILE_SIZE) {
+    const detail = optimization.info
+      ? ` after optimization to ${formatSize(bytes.length)}`
+      : "";
+    throw new Error(`File too large (${originalBytes.length} bytes, max ${MAX_FILE_SIZE})${detail}`);
+  }
   const form = new FormData();
   const blob = new Blob([bytes], { type: mime });
   const file = new File([blob], path.basename(absolute), { type: mime });
@@ -164,6 +173,15 @@ async function handleUpload(args) {
   console.log("");
   console.log(`✅ Uploaded ${body.originalName || path.basename(absolute)} (${formatSize(body.size)})`);
   console.log("");
+  if (optimization.info) {
+    console.log(
+      `   Optimized HTML: ${formatSize(optimization.info.originalBytes)} → ${formatSize(optimization.info.optimizedBytes)}`
+    );
+    console.log(
+      `   Removed embedded fonts: ${optimization.info.removedFonts}`
+    );
+    console.log("");
+  }
   console.log(`   ${body.url}`);
   console.log("");
   if (body.hasPassword) console.log(`   🔒 Password-protected`);
@@ -179,6 +197,97 @@ async function handleUpload(args) {
   console.log("");
 }
 
+function maybeOptimizeUpload({ absolute, ext, bytes }) {
+  if (ext !== ".html" && ext !== ".htm") {
+    return { bytes, info: null };
+  }
+
+  const source = bytes.toString("utf8");
+  const optimized = optimizeBundledStandaloneHtml(source);
+  if (!optimized) {
+    return { bytes, info: null };
+  }
+
+  const optimizedBytes = Buffer.from(optimized.html, "utf8");
+  if (optimizedBytes.length >= bytes.length) {
+    return { bytes, info: null };
+  }
+
+  return {
+    bytes: optimizedBytes,
+    info: {
+      kind: "bundled-standalone-html",
+      removedFonts: optimized.removedFonts,
+      originalBytes: bytes.length,
+      optimizedBytes: optimizedBytes.length,
+      file: absolute,
+    },
+  };
+}
+
+function optimizeBundledStandaloneHtml(source) {
+  const manifestTagPattern = /(<script\b[^>]*type="__bundler\/manifest"[^>]*>)([\s\S]*?)(<\/script>)/i;
+  const templateTagPattern = /(<script\b[^>]*type="__bundler\/template"[^>]*>)([\s\S]*?)(<\/script>)/i;
+  const manifestMatch = source.match(manifestTagPattern);
+  const templateMatch = source.match(templateTagPattern);
+  if (!manifestMatch || !templateMatch) {
+    return null;
+  }
+
+  let manifest;
+  let template;
+  try {
+    manifest = JSON.parse(manifestMatch[2]);
+    template = JSON.parse(templateMatch[2]);
+  } catch {
+    return null;
+  }
+
+  const fontUuids = Object.entries(manifest)
+    .filter(([, entry]) => entry?.mime === "font/woff2")
+    .map(([uuid]) => uuid);
+  if (fontUuids.length === 0) {
+    return null;
+  }
+
+  for (const uuid of fontUuids) {
+    delete manifest[uuid];
+    const escapedUuid = escapeRegExp(uuid);
+    template = template.replace(
+      new RegExp(`@font-face\\s*\\{[^{}]*${escapedUuid}[^{}]*\\}`, "g"),
+      "",
+    );
+    template = template.split(uuid).join("");
+  }
+
+  let html = source.replace(
+    manifestTagPattern,
+    (_, openTag, _json, closeTag) => `${openTag}${stringifyForHtmlScriptTag(manifest)}${closeTag}`,
+  );
+  html = html.replace(
+    templateTagPattern,
+    (_, openTag, _json, closeTag) => `${openTag}${stringifyForHtmlScriptTag(template)}${closeTag}`,
+  );
+
+  return {
+    html,
+    removedFonts: fontUuids.length,
+  };
+}
+
+function escapeRegExp(value) {
+  return String(value).replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+function stringifyForHtmlScriptTag(value) {
+  return JSON.stringify(value)
+    .replace(/</g, "\\u003C")
+    .replace(/>/g, "\\u003E")
+    .replace(/&/g, "\\u0026")
+    .replace(/\u2028/g, "\\u2028")
+    .replace(/\u2029/g, "\\u2029");
+}
+
 // ---------------------------------------------------------------------------
 // list
 // ---------------------------------------------------------------------------

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, listInboxItems } from "./moltbook-api.mjs";
+import { createMoltbookClient, readScoutState, writeScoutState, rollScoutDayIfNeeded, markPostSeen, recordComposeAttempt, writeDraft, readDraft, deleteDraft, listPendingDrafts, solveVerificationPuzzle, solvePuzzleWithLLM, recordPuzzleAttempt, listInboxItems } from "./moltbook-api.mjs";
 
 const __filename = fileURLToPath(import.meta.url);
 const __dirname = path.dirname(__filename);
@@ -15038,6 +15038,12 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
   const finalTitle = draft.decision.title || draft.postTitle;
 
   let verification;
+  // Captured so the post-verify history record knows which post/comment the
+  // challenge_text was attached to. `draft.postId` only exists for replies;
+  // for `original_post` drafts the id only shows up in the POST /posts
+  // response.
+  let createdPostId = null;
+  let createdCommentId = null;
 
   if (draft.draftType === "original_post") {
     const result = await mb("/posts", {
@@ -15051,6 +15057,7 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
     });
     const post = result?.post || null;
     verification = post?.verification || null;
+    createdPostId = post?.id || null;
     console.log(`[moltbook-draft-post] Posted original post (id=${post?.id})`);
 
     const scoutState = rollScoutDayIfNeeded(await readScoutState());
@@ -15066,6 +15073,8 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
     });
     const comment = result?.comment || null;
     verification = comment?.verification || null;
+    createdPostId = draft.postId || null;
+    createdCommentId = comment?.id || null;
     console.log(`[moltbook-draft-post] Posted reply (commentId=${comment?.id}) to post ${draft.postId}`);
 
     const scoutState = rollScoutDayIfNeeded(await readScoutState());
@@ -15080,41 +15089,79 @@ async function executeMoltbookDraftPost(draft, config, runtime, state) {
   }
 
   // Solve verification puzzle if present.
+  //
+  // Every attempt — success, server rejection, or complete failure — gets
+  // recorded via `recordPuzzleAttempt` so we can build a corpus of
+  // challenge_text at `~/.viveworker/moltbook-verify-history.jsonl`. This is
+  // the only way to reconstruct failing puzzles; Moltbook only returns
+  // `challenge_text` in the initial POST response.
   if (verification) {
-    let answer = solveVerificationPuzzle(verification.challenge_text);
-    const source = answer != null ? "solver" : null;
-    if (answer == null) {
-      answer = await solvePuzzleWithLLM(verification.challenge_text);
+    const solverAnswer = solveVerificationPuzzle(verification.challenge_text);
+    let submittedAnswer = solverAnswer;
+    let llmAnswer = null;
+    let outcome = "unknown";
+    let verifyError = null;
+
+    if (submittedAnswer == null) {
+      llmAnswer = await solvePuzzleWithLLM(verification.challenge_text);
+      submittedAnswer = llmAnswer;
     }
-    if (answer != null) {
+
+    if (submittedAnswer != null) {
       try {
         await mb("/verify", {
           method: "POST",
-          body: JSON.stringify({ verification_code: verification.verification_code, answer }),
+          body: JSON.stringify({ verification_code: verification.verification_code, answer: submittedAnswer }),
         });
-        console.log(`[moltbook-draft-verify] Verified with answer ${answer}`);
-      } catch (verifyError) {
+        console.log(`[moltbook-draft-verify] Verified with answer ${submittedAnswer}`);
+        outcome = solverAnswer != null && llmAnswer == null ? "solver-verified" : "llm-verified";
+      } catch (err) {
+        verifyError = err.message;
         // Wrong answer from solver — retry with LLM.
-        if (/incorrect/i.test(verifyError.message) && source === "solver") {
-          const llmAnswer = await solvePuzzleWithLLM(verification.challenge_text);
-          if (llmAnswer && llmAnswer !== answer) {
+        if (/incorrect/i.test(err.message) && solverAnswer != null && llmAnswer == null) {
+          llmAnswer = await solvePuzzleWithLLM(verification.challenge_text);
+          if (llmAnswer && llmAnswer !== solverAnswer) {
             try {
               await mb("/verify", {
                 method: "POST",
                 body: JSON.stringify({ verification_code: verification.verification_code, answer: llmAnswer }),
               });
               console.log(`[moltbook-draft-verify] Verified with LLM retry answer ${llmAnswer}`);
+              submittedAnswer = llmAnswer;
+              verifyError = null;
+              outcome = "solver-incorrect-llm-verified";
             } catch (retryError) {
               console.error(`[moltbook-draft-verify] LLM retry failed: ${retryError.message}`);
+              verifyError = retryError.message;
+              outcome = "both-incorrect";
             }
+          } else {
+            outcome = "solver-incorrect-llm-agreed-or-null";
           }
         } else {
-          console.error(`[moltbook-draft-verify] Failed: ${verifyError.message}`);
+          console.error(`[moltbook-draft-verify] Failed: ${err.message}`);
+          outcome = solverAnswer != null ? "solver-rejected" : "llm-rejected";
         }
       }
     } else {
       console.error(`[moltbook-draft-verify] Could not solve puzzle for draft ${draft.token}`);
-    }
+      outcome = "both-failed-to-solve";
+    }
+
+    // Best-effort corpus write. Never throws.
+    await recordPuzzleAttempt({
+      draftToken: draft.token,
+      draftType: draft.draftType,
+      postId: createdPostId,
+      commentId: createdCommentId,
+      challenge_text: verification.challenge_text,
+      verification_code: verification.verification_code,
+      solverAnswer,
+      llmAnswer,
+      submittedAnswer,
+      outcome,
+      verifyError,
+    });
   }
 
   // Push notification for successful post.

package/scripts/viveworker.mjs

@@ -64,6 +64,17 @@ if (rawArgs[0] === "share") {
   }
 }
 
+if (rawArgs[0] === "stats") {
+  const { runStatsCli } = await import("./stats-cli.mjs");
+  try {
+    await runStatsCli(rawArgs.slice(1));
+    process.exit(0);
+  } catch (error) {
+    console.error(error.message || String(error));
+    process.exit(1);
+  }
+}
+
 const cli = parseArgs(rawArgs);
 
 try {