viveworker 0.3.0 → 0.4.0

package/scripts/a2a-relay-client.mjs

@@ -0,0 +1,394 @@
+/**
+ * a2a-relay-client.mjs — Bridge-side polling client for the viveworker A2A relay.
+ *
+ * Connects the local viveworker bridge to the Cloudflare Worker relay:
+ *   - Registers the bridge with the relay on first startup
+ *   - Polls the relay every 20 seconds for pending A2A tasks
+ *   - Posts task results (completion/failure/rejection) back to the relay
+ *
+ * Designed to be imported and used from viveworker-bridge.mjs.
+ */
+
+import crypto from "node:crypto";
+import os from "node:os";
+import path from "node:path";
+import { promises as fs, readFileSync } from "node:fs";
+import { upsertEnvText } from "./lib/pairing.mjs";
+
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+
+const POLL_INTERVAL_MS = 20_000;     // 20 seconds
+const REQUEST_TIMEOUT_MS = 15_000;   // 15 seconds per HTTP request
+const A2A_ENV_FILE = path.join(os.homedir(), ".viveworker", "a2a.env");
+
+// ---------------------------------------------------------------------------
+// Module state
+// ---------------------------------------------------------------------------
+
+let pollTimer = null;
+let isPolling = false;
+
+// ---------------------------------------------------------------------------
+// Registration
+// ---------------------------------------------------------------------------
+
+/**
+ * Register this bridge with the A2A relay. On first registration, generates
+ * a bridgeSecret and writes it back to ~/.viveworker/a2a.env.
+ *
+ * @param {object} params
+ * @param {object} params.config - Bridge config (must have a2aRelayUrl, a2aRelayUserId, a2aApiKey)
+ * @param {Function} params.buildAgentCard - Function to build the local agent card
+ * @returns {Promise<{ ok: boolean, relayUrl?: string, error?: string }>}
+ */
+export async function registerWithRelay({ config, buildAgentCard }) {
+  const relayUrl = config.a2aRelayUrl;
+  const userId = config.a2aRelayUserId;
+
+  if (!relayUrl || !userId) {
+    return { ok: false, error: "A2A_RELAY_URL or A2A_RELAY_USER_ID not configured" };
+  }
+
+  // Generate or reuse bridgeSecret
+  let bridgeSecret = config.a2aRelaySecret || "";
+  const isNewSecret = !bridgeSecret;
+  if (isNewSecret) {
+    bridgeSecret = crypto.randomBytes(32).toString("hex");
+  }
+
+  const agentCard = typeof buildAgentCard === "function"
+    ? buildAgentCard(config)
+    : {};
+
+  const body = {
+    userId,
+    bridgeSecret,
+    a2aApiKey: config.a2aApiKey || "",
+    agentCard,
+    ...(config.a2aRelayRegisterSecret ? { registerSecret: config.a2aRelayRegisterSecret } : {}),
+  };
+
+  const headers = {
+    "content-type": "application/json",
+  };
+  // Re-registration requires the current bridgeSecret
+  if (!isNewSecret) {
+    headers["authorization"] = `Bearer ${bridgeSecret}`;
+  }
+
+  try {
+    const res = await fetchWithTimeout(`${relayUrl}/internal/register`, {
+      method: "POST",
+      headers,
+      body: JSON.stringify(body),
+    });
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      return { ok: false, error: data.error || `HTTP ${res.status}` };
+    }
+
+    // On success, write bridgeSecret back to a2a.env if new
+    if (isNewSecret) {
+      await persistRelaySecret(bridgeSecret);
+      // Update config in-place so subsequent calls use the secret
+      config.a2aRelaySecret = bridgeSecret;
+    }
+
+    console.log(`[a2a-relay] Registered as ${userId} → ${data.relayUrl || relayUrl}`);
+    return { ok: true, relayUrl: data.relayUrl };
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Polling
+// ---------------------------------------------------------------------------
+
+/**
+ * Start polling the relay for pending A2A tasks. Tasks are ingested into
+ * the local runtime just like locally-received A2A tasks.
+ *
+ * @param {object} params
+ * @param {object} params.config       - Bridge config
+ * @param {object} params.runtime      - Bridge runtime state
+ * @param {object} params.state        - Persistent state
+ * @param {object} params.helpers      - { recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText }
+ */
+export function startRelayPolling({ config, runtime, state, helpers }) {
+  if (pollTimer) {
+    console.warn("[a2a-relay] Polling already started, skipping duplicate start");
+    return;
+  }
+
+  const relayUrl = config.a2aRelayUrl;
+  const userId = config.a2aRelayUserId;
+  const secret = config.a2aRelaySecret;
+
+  if (!relayUrl || !userId || !secret) {
+    console.warn("[a2a-relay] Cannot start polling — missing relay config");
+    return;
+  }
+
+  console.log(`[a2a-relay] Starting poll loop (every ${POLL_INTERVAL_MS / 1000}s) for user ${userId}`);
+
+  // Do an initial poll immediately, then schedule interval
+  pollOnce({ config, runtime, state, helpers }).catch((err) => {
+    console.error(`[a2a-relay] Initial poll error: ${err.message}`);
+  });
+
+  pollTimer = setInterval(() => {
+    if (isPolling || runtime.stopping) return;
+    pollOnce({ config, runtime, state, helpers }).catch((err) => {
+      console.error(`[a2a-relay] Poll error: ${err.message}`);
+    });
+  }, POLL_INTERVAL_MS);
+
+  // Allow Node to exit even if timer is running
+  if (pollTimer.unref) pollTimer.unref();
+}
+
+/**
+ * Stop relay polling. Call on bridge shutdown.
+ */
+export function stopRelayPolling() {
+  if (pollTimer) {
+    clearInterval(pollTimer);
+    pollTimer = null;
+  }
+  isPolling = false;
+  console.log("[a2a-relay] Polling stopped");
+}
+
+/**
+ * Single poll cycle: fetch pending tasks from the relay and ingest them.
+ */
+async function pollOnce({ config, runtime, state, helpers }) {
+  if (runtime.stopping) return;
+  isPolling = true;
+
+  try {
+    const relayUrl = config.a2aRelayUrl;
+    const userId = config.a2aRelayUserId;
+    const secret = config.a2aRelaySecret;
+
+    const res = await fetchWithTimeout(`${relayUrl}/internal/poll/${userId}`, {
+      method: "GET",
+      headers: {
+        authorization: `Bearer ${secret}`,
+      },
+    });
+
+    if (!res.ok) {
+      const text = await res.text().catch(() => "");
+      console.error(`[a2a-relay] Poll failed: HTTP ${res.status} ${text.slice(0, 200)}`);
+      return;
+    }
+
+    const data = await res.json();
+    const tasks = data.tasks || [];
+
+    if (tasks.length === 0) return;
+
+    console.log(`[a2a-relay] Received ${tasks.length} task(s) from relay`);
+
+    for (const relayTask of tasks) {
+      await ingestRelayTask({ relayTask, config, runtime, state, helpers });
+    }
+  } finally {
+    isPolling = false;
+  }
+}
+
+/**
+ * Ingest a single relay task into local runtime. Creates the same structure
+ * as a locally-received A2A task, tagged with relayTaskId for result posting.
+ */
+async function ingestRelayTask({ relayTask, config, runtime, state, helpers }) {
+  const { recordTimelineEntry, deliverWebPushItem, saveState, historyToken, cleanText } = helpers;
+
+  // Skip if we already have this task (deduplicate)
+  for (const existing of runtime.a2aTasksByToken.values()) {
+    if (existing.relayTaskId === relayTask.id) {
+      return; // already ingested
+    }
+  }
+
+  const token = historyToken(`a2a_task:${relayTask.id}`);
+  const instruction = cleanText(relayTask.instruction || "");
+  const now = Date.now();
+
+  const task = {
+    id: relayTask.id,
+    token,
+    contextId: relayTask.contextId || crypto.randomUUID(),
+    status: "submitted",
+    statusMessage: "",
+    messages: relayTask.messages || [],
+    artifacts: [],
+    instruction,
+    callerInfo: relayTask.callerInfo || {},
+    createdAtMs: relayTask.createdAtMs || now,
+    updatedAtMs: now,
+    decisionWaiters: [],
+    decision: null,
+    // Mark as relay-originated so we know to post results back
+    relayTaskId: relayTask.id,
+    relayUserId: config.a2aRelayUserId,
+  };
+
+  runtime.a2aTasksByToken.set(token, task);
+
+  // Record timeline entry (same as local A2A handler)
+  try {
+    recordTimelineEntry({
+      config,
+      runtime,
+      state,
+      entry: {
+        stableId: `a2a_task:${relayTask.id}`,
+        token,
+        kind: "a2a_task",
+        threadId: "a2a",
+        threadLabel: "A2A",
+        title: `A2A: ${instruction.slice(0, 80)}`,
+        summary: instruction.slice(0, 160),
+        messageText: instruction,
+        createdAtMs: relayTask.createdAtMs || now,
+        readOnly: false,
+        provider: "a2a",
+      },
+    });
+    await saveState(config.stateFile, state);
+  } catch (err) {
+    console.error(`[a2a-relay] Timeline save error: ${err.message}`);
+  }
+
+  // Send Web Push notification
+  try {
+    await deliverWebPushItem({
+      config,
+      state,
+      kind: "a2a_task",
+      token,
+      stableId: `a2a_task:${relayTask.id}`,
+      title: "A2A Task Request",
+      body: instruction.slice(0, 160),
+      buildLocalizedContent: ({ locale }) => {
+        const lang = locale?.startsWith("ja") ? "ja" : "en";
+        return {
+          title: lang === "ja" ? "\u{1F91D} A2Aリレー経由のタスク依頼" : "\u{1F91D} A2A task via relay",
+          body: instruction.slice(0, 160),
+        };
+      },
+    });
+  } catch (err) {
+    console.error(`[a2a-relay] Push notification error: ${err.message}`);
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Result posting
+// ---------------------------------------------------------------------------
+
+/**
+ * Post a task result back to the relay. Called after task completion,
+ * failure, or rejection.
+ *
+ * @param {object} params
+ * @param {object} params.config - Bridge config (a2aRelayUrl, a2aRelayUserId, a2aRelaySecret)
+ * @param {object} params.task   - A2A task object with relayTaskId
+ * @returns {Promise<{ ok: boolean, error?: string }>}
+ */
+export async function postRelayResult({ config, task }) {
+  if (!task.relayTaskId) {
+    return { ok: false, error: "Not a relay task" };
+  }
+
+  const relayUrl = config.a2aRelayUrl;
+  const userId = task.relayUserId || config.a2aRelayUserId;
+  const secret = config.a2aRelaySecret;
+
+  if (!relayUrl || !userId || !secret) {
+    return { ok: false, error: "Relay not configured" };
+  }
+
+  const body = {
+    status: task.status,
+    statusMessage: task.statusMessage || "",
+    updatedAtMs: task.updatedAtMs || Date.now(),
+    artifacts: task.artifacts || [],
+  };
+
+  try {
+    const res = await fetchWithTimeout(
+      `${relayUrl}/internal/result/${userId}/${task.relayTaskId}`,
+      {
+        method: "POST",
+        headers: {
+          "content-type": "application/json",
+          authorization: `Bearer ${secret}`,
+        },
+        body: JSON.stringify(body),
+      }
+    );
+
+    const data = await res.json();
+
+    if (!res.ok) {
+      console.error(`[a2a-relay] Result post failed: HTTP ${res.status} ${data.error || ""}`);
+      return { ok: false, error: data.error || `HTTP ${res.status}` };
+    }
+
+    console.log(`[a2a-relay] Result posted for task ${task.relayTaskId} → ${data.status}`);
+    return { ok: true };
+  } catch (err) {
+    console.error(`[a2a-relay] Result post error: ${err.message}`);
+    return { ok: false, error: err.message };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+/**
+ * Write A2A_RELAY_SECRET back to ~/.viveworker/a2a.env.
+ */
+async function persistRelaySecret(secret) {
+  try {
+    let current = "";
+    try {
+      current = await fs.readFile(A2A_ENV_FILE, "utf8");
+    } catch {
+      // File may not exist yet
+    }
+
+    const updated = upsertEnvText(current, {
+      A2A_RELAY_SECRET: secret,
+    });
+
+    await fs.mkdir(path.dirname(A2A_ENV_FILE), { recursive: true, mode: 0o700 });
+    await fs.writeFile(A2A_ENV_FILE, updated, { mode: 0o600 });
+    console.log(`[a2a-relay] Wrote A2A_RELAY_SECRET to ${A2A_ENV_FILE}`);
+  } catch (err) {
+    console.error(`[a2a-relay] Failed to write relay secret: ${err.message}`);
+  }
+}
+
+/**
+ * fetch() with a timeout via AbortSignal.
+ */
+async function fetchWithTimeout(url, options = {}, timeoutMs = REQUEST_TIMEOUT_MS) {
+  const controller = new AbortController();
+  const timer = setTimeout(() => controller.abort(), timeoutMs);
+  try {
+    return await fetch(url, { ...options, signal: controller.signal });
+  } finally {
+    clearTimeout(timer);
+  }
+}

package/scripts/moltbook-api.mjs

@@ -142,10 +142,13 @@ export function defaultScoutState() {
 }
 
 export function todayKey() {
-  const d = new Date();
-  const y = d.getUTCFullYear();
-  const m = String(d.getUTCMonth() + 1).padStart(2, "0");
-  const day = String(d.getUTCDate()).padStart(2, "0");
+  // 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 y = d.getFullYear();
+  const m = String(d.getMonth() + 1).padStart(2, "0");
+  const day = String(d.getDate()).padStart(2, "0");
   return `${y}-${m}-${day}`;
 }
 
@@ -167,11 +170,13 @@ export function rollScoutDayIfNeeded(state) {
   return state;
 }
 
-export function recordComposeAttempt(state, title) {
+export function recordComposeAttempt(state, title, postId) {
   state.composedToday = (state.composedToday || 0) + 1;
   state.lastComposeDay = todayKey();
   if (!Array.isArray(state.recentComposeTitles)) state.recentComposeTitles = [];
-  state.recentComposeTitles.unshift(String(title || ""));
+  state.recentComposeTitles.unshift(
+    postId ? { title: String(title || ""), postId: String(postId) } : String(title || "")
+  );
   if (state.recentComposeTitles.length > 10) state.recentComposeTitles.length = 10;
   return state;
 }

package/scripts/moltbook-cli.mjs

@@ -589,6 +589,14 @@ async function cmdPropose(postId, flags) {
     )
   );
 
+  // Bump sentToday counter immediately after posting (before verification),
+  // because the comment is already created and rate-limits are consumed
+  // regardless of verification outcome.
+  const state = rollScoutDayIfNeeded(await readScoutState());
+  state.sentToday += 1;
+  markPostSeen(state, postId, "published");
+  await writeScoutState(state);
+
   if (!verification) {
     console.log("propose: no verification challenge returned — done");
     return;
@@ -651,12 +659,6 @@ async function cmdPropose(postId, flags) {
   }
   console.log(JSON.stringify({ ok: true, verify: verifyRes, answer }, null, 2));
 
-  // 5. Bump sentToday counter on success.
-  const state = rollScoutDayIfNeeded(await readScoutState());
-  state.sentToday += 1;
-  markPostSeen(state, postId, "published");
-  await writeScoutState(state);
-
   if (!prevTls) process.env.NODE_TLS_REJECT_UNAUTHORIZED = prevTls ?? "";
 }
 
@@ -667,10 +669,15 @@ async function solvePuzzleWithLLM(challengeText) {
   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. ` +
-    `Extract the numbers (written as words like "thirty five" = 35), determine the operation ` +
-    `(usually addition for "total", "combined", "new velocity"; subtraction for "difference", "minus"; ` +
-    `multiplication for "times", "product"), compute the result, and output ONLY the number with ` +
-    `exactly 2 decimal places (e.g. "58.00"). No other text.\n\n` +
+    `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}`;
 
   // Try claude first, then codex.
@@ -714,8 +721,12 @@ async function solvePuzzleWithLLM(challengeText) {
 // `null` if it can't confidently solve — caller falls back to manual.
 function solveVerificationPuzzle(challengeText) {
   if (!challengeText) return null;
+  // Strip ALL symbolic characters as noise — operations are expressed in
+  // natural language only ("and", "times", "divided by", etc.).  Previous
+  // regex missed `*` and `@` which caused `/` or `*` to be mistaken for
+  // arithmetic operators.
   const cleaned = String(challengeText)
-    .replace(/[\[\]|\\\/^\-\.~,;:!?'"(){}]/g, " ")
+    .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,
@@ -729,12 +740,42 @@ function solveVerificationPuzzle(challengeText) {
   // so try matching both the raw word and a version with collapsed runs.
   // We can't blindly collapse because natural doubles exist ("three" has "ee").
   const collapseRuns = (w) => w.replace(/([a-z])\1+/g, "$1");
-  const rawWords = cleaned
+  const rawTokens = cleaned
     .replace(/[^a-z0-9\s]/g, " ")
     .split(/\s+/)
     .filter(Boolean);
+
+  // The obfuscator inserts spaces mid-word (e.g. "th ree" → "three",
+  // "to tal" → "total"). Greedily merge adjacent tokens if the combined
+  // form (raw or collapsed) matches a known number word or operation keyword.
+  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) {
+    // Try merging up to 4 consecutive tokens.
+    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;
+  }
+
   // For each word, prefer the raw form if it's in the dictionary; otherwise try collapsed.
-  const words = rawWords.map((w) => {
+  const words = merged.map((w) => {
     if (/^\d+$/.test(w)) return w;
     if (numberWords[w] != null) return w;
     const collapsed = collapseRuns(w);
@@ -776,11 +817,11 @@ function solveVerificationPuzzle(challengeText) {
   const hasWord = (w) => words.includes(w);
   const hasAny = (...ws) => ws.some(hasWord);
   let result;
-  if (hasAny("subtract", "minus", "less", "difference", "decreased", "loses", "lost", "slower")) {
+  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", "per")) {
+  } else if (hasAny("divide", "divided", "ratio")) {
     result = b !== 0 ? a / b : a;
   } else {
     // Default to addition — the Moltbook puzzles overwhelmingly ask for
@@ -1111,6 +1152,7 @@ async function cmdComposePropose(flags) {
   const content = typeof flags.content === "string" ? flags.content : "";
   const submolt = typeof flags.submolt === "string" ? flags.submolt : "general";
   const intent = typeof flags.intent === "string" ? flags.intent : "";
+  const slot = typeof flags.slot === "string" ? flags.slot : "";
   const timeoutSec = Number(flags.timeout) || 900;
   if (!title.trim()) fail("--title is required");
   if (!content.trim()) fail("--content is required");
@@ -1139,6 +1181,7 @@ async function cmdComposePropose(flags) {
         draftType: "original_post",
         submoltName: submolt,
         intent,
+        slot,
         contextSummary: truncate(intent || content, 160),
       }),
     });
@@ -1202,10 +1245,19 @@ async function cmdComposePropose(flags) {
   if (!verification) {
     console.log("compose-propose: no verification — done");
   } else {
-    // Solve verification puzzle inline.
+    // Solve verification puzzle inline (try naive solver, then LLM fallback, retry once on wrong answer).
     let answer = solveVerificationPuzzle(verification.challenge_text);
-    if (answer == null) answer = await solvePuzzleWithLLM(verification.challenge_text);
-    if (answer != null) {
+    const source = answer != null ? "solver" : "skip";
+    console.log(`compose-propose: verification puzzle — solver answer: ${answer ?? "(null)"}`);
+
+    if (answer == null) {
+      answer = await solvePuzzleWithLLM(verification.challenge_text);
+      if (answer) console.log(`compose-propose: LLM fallback answer: ${answer}`);
+    }
+
+    if (answer == null) {
+      console.log(`VERIFICATION REQUIRED (solver + LLM both failed):\n  verification_code: ${verification.verification_code}\n  challenge_text: ${verification.challenge_text}`);
+    } else {
       try {
         const verifyRes = await mb(`/verify`, {
           method: "POST",
@@ -1213,16 +1265,34 @@ async function cmdComposePropose(flags) {
         });
         console.log(JSON.stringify({ ok: true, verify: verifyRes, answer }, null, 2));
       } catch (verifyError) {
-        console.log(`compose-propose: verify failed: ${verifyError.message}`);
+        const isWrongAnswer = /incorrect/i.test(verifyError.message);
+        if (isWrongAnswer && source === "solver") {
+          console.log(`compose-propose: solver answer ${answer} was wrong, trying LLM fallback`);
+          const llmAnswer = await solvePuzzleWithLLM(verification.challenge_text);
+          if (llmAnswer && llmAnswer !== answer) {
+            console.log(`compose-propose: LLM retry answer: ${llmAnswer}`);
+            try {
+              const verifyRes2 = await mb(`/verify`, {
+                method: "POST",
+                body: JSON.stringify({ verification_code: verification.verification_code, answer: llmAnswer }),
+              });
+              console.log(JSON.stringify({ ok: true, verify: verifyRes2, answer: llmAnswer }, null, 2));
+            } catch (retryError) {
+              console.log(`compose-propose: LLM retry also failed: ${retryError.message}`);
+            }
+          } else {
+            console.log(`compose-propose: LLM couldn't produce a different answer`);
+          }
+        } else {
+          console.log(`compose-propose: verify failed: ${verifyError.message}`);
+        }
       }
-    } else {
-      console.log(`VERIFICATION REQUIRED:\n  verification_code: ${verification.verification_code}\n  challenge_text: ${verification.challenge_text}`);
     }
   }
 
   // 4. Bump compose counter.
   const state = rollScoutDayIfNeeded(await readScoutState());
-  recordComposeAttempt(state, finalTitle);
+  recordComposeAttempt(state, finalTitle, post?.id);
   await writeScoutState(state);
 
   if (!prevTls) process.env.NODE_TLS_REJECT_UNAUTHORIZED = prevTls ?? "";