@m13v/s4l 1.6.197-rc.7

package/scripts/moltbook_post.py

@@ -0,0 +1,320 @@
+#!/usr/bin/env python3
+"""
+Moltbook post/comment helper with automatic verification.
+
+Usage:
+    python3 scripts/moltbook_post.py post --title "..." --content "..." [--submolt technology]
+    python3 scripts/moltbook_post.py comment --post-id UUID --content "..."
+
+Handles the obfuscated lobster math CAPTCHA automatically.
+"""
+import requests, json, re, sys, os, argparse, time
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+try:
+    from moltbook_tools import note_rate_limited as _note_rate_limited
+except Exception:
+    def _note_rate_limited(_retry):
+        pass
+
+
+def get_api_key():
+    key = os.environ.get("MOLTBOOK_API_KEY")
+    if not key:
+        env_file = os.path.expanduser("~/social-autoposter/.env")
+        if os.path.exists(env_file):
+            with open(env_file) as f:
+                for line in f:
+                    if line.startswith("MOLTBOOK_API_KEY="):
+                        key = line.strip().split("=", 1)[1]
+                        break
+    if not key:
+        print("ERROR: MOLTBOOK_API_KEY not found", file=sys.stderr)
+        sys.exit(1)
+    return key
+
+BASE = "https://www.moltbook.com/api/v1"
+
+NUMBER_WORDS = {
+    '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
+}
+
+def solve_challenge(challenge_text):
+    """Solve Moltbook's obfuscated lobster math CAPTCHA.
+
+    Strategy: strip ALL non-alpha chars (handles fragmented words like "tH iR tY"),
+    scan for number words using greedy longest-first matching, detect operation,
+    try all number pairs with all operations via brute force if needed.
+    """
+    # Strip non-alpha, join everything
+    nospace = re.sub(r'[^a-zA-Z]', '', challenge_text).lower()
+
+    # Build regex patterns that match each number word with optional repeated chars
+    # e.g., "three" -> "t+h+r+e+e+" matches "tthhrreeee"
+    def make_fuzzy_pattern(word):
+        return ''.join(c + '+' for c in word)
+
+    sorted_words = sorted(NUMBER_WORDS.keys(), key=len, reverse=True)
+    fuzzy_patterns = [(w, re.compile(make_fuzzy_pattern(w))) for w in sorted_words]
+
+    # Scan for number words using fuzzy matching on the raw stripped text
+    nums_raw = []
+    remaining = nospace
+    while remaining:
+        found = False
+        for word, pattern in fuzzy_patterns:
+            m = pattern.match(remaining)
+            if m:
+                nums_raw.append(NUMBER_WORDS[word])
+                remaining = remaining[m.end():]
+                found = True
+                break
+        if not found:
+            remaining = remaining[1:]
+
+    # Combine tens+ones (e.g., twenty + three = 23)
+    nums = []
+    i = 0
+    while i < len(nums_raw):
+        val = nums_raw[i]
+        if val >= 20 and val < 100 and i+1 < len(nums_raw) and nums_raw[i+1] < 10:
+            nums.append(val + nums_raw[i+1])
+            i += 2
+        else:
+            nums.append(val)
+            i += 1
+
+    # Filter to reasonable candidates (5-999)
+    candidates = [n for n in nums if 5 <= n <= 999]
+    if len(candidates) < 2:
+        candidates = [n for n in nums if n > 0]
+
+    # Detect primary operation (check raw, stripped, and deduped text)
+    lower = challenge_text.lower()
+    stripped_lower = nospace  # already lowercase stripped
+    deduped_lower = re.sub(r'(.)\1+', r'\1', stripped_lower)
+    check_texts = [lower, stripped_lower, deduped_lower]
+    if any(any(w in t for t in check_texts) for w in ['multipl', 'product', 'times', 'triple', 'double']) or '*' in challenge_text:
+        primary = 'mul'
+    elif any(any(w in t for t in check_texts) for w in ['differ', 'subtract', 'less', 'minus', 'remain', 'reduc', 'loses', 'lose', 'lost', 'slow']):
+        primary = 'sub'
+    else:
+        primary = 'add'
+
+    return candidates, primary
+
+def verify_with_brute_force(candidates, primary_op, verification_code, headers):
+    """Try all number pair + operation combinations to verify."""
+    ops = {
+        'add': lambda a, b: a + b,
+        'sub': lambda a, b: abs(a - b),
+        'mul': lambda a, b: a * b,
+    }
+
+    # Try primary op first with last two candidates
+    op_order = [primary_op] + [o for o in ['add', 'sub', 'mul'] if o != primary_op]
+
+    for op_name in op_order:
+        for i in range(len(candidates)):
+            for j in range(len(candidates)):
+                if i == j:
+                    continue
+                a, b = candidates[i], candidates[j]
+                answer = f"{ops[op_name](a, b):.2f}"
+                try:
+                    r = requests.post(
+                        f"{BASE}/verify",
+                        headers=headers,
+                        json={"answer": answer, "verification_code": verification_code},
+                        timeout=15,
+                    )
+                    if r.json().get("success"):
+                        return True, answer, f"{op_name}({a},{b})"
+                except Exception:
+                    continue
+
+    return False, None, None
+
+def create_post(title, content, submolt, api_key):
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+    r = requests.post(
+        f"{BASE}/posts",
+        headers=headers,
+        json={"title": title, "content": content, "type": "text", "submolt_name": submolt},
+        timeout=30,
+    )
+
+    if r.status_code == 429:
+        retry = r.json().get("retry_after_seconds", 160)
+        _note_rate_limited(retry)
+        print(f"Rate limited. Retry after {retry}s", file=sys.stderr)
+        sys.exit(2)
+
+    d = r.json()
+    if not d.get("success"):
+        print(f"Create failed: {d.get('message', '')}", file=sys.stderr)
+        sys.exit(1)
+
+    post = d["post"]
+    post_id = post["id"]
+    verification = post.get("verification", {})
+    challenge = verification.get("challenge_text", "")
+    code = verification.get("verification_code", "")
+
+    print(f"Post created: {post_id}")
+
+    if not challenge or not code:
+        print("No verification challenge (unexpected)")
+        return post_id, False
+
+    print(f"Challenge: {challenge}")
+
+    candidates, primary_op = solve_challenge(challenge)
+    print(f"Numbers found: {candidates}, primary op: {primary_op}")
+
+    if len(candidates) < 2:
+        print("ERROR: Could not find enough numbers in challenge", file=sys.stderr)
+        return post_id, False
+
+    ok, answer, expr = verify_with_brute_force(candidates, primary_op, code, headers)
+    if ok:
+        print(f"VERIFIED: {expr} = {answer}")
+        return post_id, True
+    else:
+        print("VERIFICATION FAILED - delete and retry", file=sys.stderr)
+        return post_id, False
+
+def create_comment(post_id, content, api_key, parent_id=None):
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+
+    body = {"content": content}
+    if parent_id:
+        body["parent_id"] = parent_id
+
+    r = requests.post(
+        f"{BASE}/posts/{post_id}/comments",
+        headers=headers,
+        json=body,
+        timeout=30,
+    )
+
+    if r.status_code == 429:
+        retry = r.json().get("retry_after_seconds", 160)
+        _note_rate_limited(retry)
+        print(f"Rate limited. Retry after {retry}s", file=sys.stderr)
+        sys.exit(2)
+
+    d = r.json()
+    if not d.get("success"):
+        msg_raw = d.get("message", "")
+        msg = " ".join(msg_raw) if isinstance(msg_raw, list) else str(msg_raw)
+        if "suspend" in msg.lower():
+            print(f"SUSPENDED: {msg}", file=sys.stderr)
+            sys.exit(3)
+        print(f"Comment failed: {msg}", file=sys.stderr)
+        sys.exit(1)
+
+    comment = d.get("comment", d)
+    comment_id = comment.get("id", "?")
+    print(f"Comment created: {comment_id}")
+
+    # Comments require verification
+    verification = comment.get("verification", d.get("verification", {}))
+    if verification.get("challenge_text") and verification.get("verification_code"):
+        challenge_text = verification["challenge_text"]
+        ver_code = verification["verification_code"]
+        print(f"Challenge: {challenge_text}")
+        candidates, primary_op = solve_challenge(challenge_text)
+        print(f"Numbers found: {candidates}, primary op: {primary_op}")
+        if len(candidates) < 2:
+            print("ERROR: Not enough numbers found", file=sys.stderr)
+            return comment_id, False
+        ok, answer, expr = verify_with_brute_force(
+            candidates, primary_op, ver_code, headers
+        )
+        if ok:
+            print(f"VERIFIED: {expr} = {answer}")
+        else:
+            print("VERIFICATION FAILED", file=sys.stderr)
+            return comment_id, False
+
+    return comment_id, True
+
+def self_upvote(item_type, item_id, api_key):
+    """Self-upvote a post or comment after verification."""
+    headers = {"Authorization": f"Bearer {api_key}", "Content-Type": "application/json"}
+    if item_type == "post":
+        url = f"{BASE}/posts/{item_id}/upvote"
+    else:
+        url = f"{BASE}/comments/{item_id}/upvote"
+    try:
+        r = requests.post(url, headers=headers, timeout=15)
+        d = r.json()
+        if d.get("success") or d.get("upvoted"):
+            print(f"Self-upvoted {item_type} {item_id[:12]}")
+            return True
+        retry = d.get("retry_after_seconds")
+        if retry:
+            _note_rate_limited(retry)
+            time.sleep(retry + 1)
+            r = requests.post(url, headers=headers, timeout=15)
+            if r.json().get("success") or r.json().get("upvoted"):
+                print(f"Self-upvoted {item_type} {item_id[:12]} (retry)")
+                return True
+    except Exception as e:
+        print(f"Upvote failed: {e}", file=sys.stderr)
+    return False
+
+
+def main():
+    parser = argparse.ArgumentParser(description="Moltbook post/comment with auto-verification")
+    sub = parser.add_subparsers(dest="action")
+
+    post_p = sub.add_parser("post")
+    post_p.add_argument("--title", required=True)
+    post_p.add_argument("--content", required=True)
+    post_p.add_argument("--submolt", default="general")
+    post_p.add_argument("--no-upvote", action="store_true", help="Skip self-upvote")
+
+    comment_p = sub.add_parser("comment")
+    comment_p.add_argument("--post-id", required=True)
+    comment_p.add_argument("--content", required=True)
+    comment_p.add_argument("--parent-id", default=None,
+                           help="UUID of comment to reply to (for threaded replies)")
+    comment_p.add_argument("--no-upvote", action="store_true", help="Skip self-upvote")
+
+    args = parser.parse_args()
+    api_key = get_api_key()
+
+    if args.action == "post":
+        post_id, verified = create_post(args.title, args.content, args.submolt, api_key)
+        if not verified:
+            print(f"Deleting unverified post {post_id}...")
+            requests.delete(
+                f"{BASE}/posts/{post_id}",
+                headers={"Authorization": f"Bearer {api_key}"},
+            )
+            sys.exit(1)
+        if not args.no_upvote:
+            self_upvote("post", post_id, api_key)
+        url = f"https://www.moltbook.com/post/{post_id}"
+        print(json.dumps({"post_id": post_id, "verified": True, "url": url}))
+    elif args.action == "comment":
+        comment_id, ok = create_comment(args.post_id, args.content, api_key,
+                                        parent_id=args.parent_id)
+        if ok and not args.no_upvote:
+            self_upvote("comment", str(comment_id), api_key)
+        url = f"https://www.moltbook.com/post/{args.post_id}#{comment_id}"
+        print(json.dumps({"ok": bool(ok), "comment_id": str(comment_id),
+                          "verified": ok, "url": url}))
+    else:
+        parser.print_help()
+        sys.exit(1)
+
+if __name__ == "__main__":
+    main()

package/scripts/moltbook_tools.py

@@ -0,0 +1,159 @@
+#!/usr/bin/env python3
+"""Shared Moltbook API helpers with cooperative cross-process rate-limit state.
+
+Mirrors the pattern in scripts/reddit_tools.py so multiple concurrent Moltbook
+callers (scan_moltbook_replies.py, stats.py, find_threads.py,
+moltbook_post.py) back off together when any one of them hits a 429.
+
+State file: /tmp/moltbook_ratelimit.json
+  {"remaining": int, "reset_at": epoch_seconds}
+
+On 429, the Moltbook API returns a JSON body with `retry_after_seconds`.
+We persist that reset into the shared file so the next caller (in any process)
+can decide to wait inline or raise MoltbookRateLimitedError to exit early.
+"""
+
+import json
+import os
+import sys
+import time
+import urllib.error
+import urllib.request
+
+
+RATELIMIT_FILE = "/tmp/moltbook_ratelimit.json"
+
+# Same threshold as Reddit: resets under 90s are absorbed inline, longer resets
+# raise MoltbookRateLimitedError so the caller exits rather than blocking a slot.
+MAX_INLINE_WAIT_SECONDS = 90
+
+# Default 429 retry when the server does not return retry_after_seconds.
+DEFAULT_RETRY_SECONDS = 160
+
+
+class MoltbookRateLimitedError(Exception):
+    """Raised when Moltbook returns 429 and reset is longer than MAX_INLINE_WAIT_SECONDS."""
+    def __init__(self, reset_seconds):
+        self.reset_seconds = reset_seconds
+        super().__init__(f"moltbook_rate_limited_wait_{int(reset_seconds)}s")
+
+
+class HttpNotFoundError(Exception):
+    """Raised when a Moltbook GET returns HTTP 404."""
+    pass
+
+
+def _read_ratelimit():
+    try:
+        with open(RATELIMIT_FILE) as f:
+            return json.load(f)
+    except Exception:
+        return {"remaining": 100, "reset_at": 0}
+
+
+def _write_ratelimit(remaining, reset_seconds):
+    reset_at = time.time() + reset_seconds
+    try:
+        with open(RATELIMIT_FILE, "w") as f:
+            json.dump({"remaining": remaining, "reset_at": reset_at}, f)
+    except Exception:
+        pass
+
+
+def _wait_if_needed():
+    """Block or raise before making a Moltbook request if a prior 429 is still pending."""
+    rl = _read_ratelimit()
+    if rl.get("remaining", 100) <= 2 and rl.get("reset_at", 0) > time.time():
+        wait = int(rl["reset_at"] - time.time()) + 2
+        if wait <= 0:
+            return
+        if wait > MAX_INLINE_WAIT_SECONDS:
+            raise MoltbookRateLimitedError(wait)
+        print(f"Moltbook rate limit cooling down, waiting {wait}s...", file=sys.stderr)
+        time.sleep(wait)
+
+
+def _parse_retry_seconds(body_bytes):
+    """Parse retry_after_seconds from a 429 response body."""
+    try:
+        payload = json.loads(body_bytes.decode("utf-8", errors="replace"))
+        retry = payload.get("retry_after_seconds")
+        if isinstance(retry, (int, float)) and retry > 0:
+            return float(retry)
+    except Exception:
+        pass
+    return float(DEFAULT_RETRY_SECONDS)
+
+
+def note_rate_limited(retry_seconds):
+    """Public: record a rate-limit event so other processes back off.
+
+    Used by moltbook_post.py (which uses the `requests` library) to feed
+    the shared state without rewriting its HTTP layer.
+    """
+    _write_ratelimit(0, float(retry_seconds))
+
+
+def fetch_moltbook_json(url, api_key=None, headers=None,
+                       user_agent="social-autoposter/1.0", timeout=15):
+    """GET a Moltbook JSON endpoint with cooperative rate-limit handling.
+
+    - Waits or raises MoltbookRateLimitedError based on shared state before firing.
+    - On 200: clears the shared "near zero" signal.
+    - On 404: raises HttpNotFoundError (callers typically use this for deletion detection).
+    - On 429: persists retry_after_seconds. If <= MAX_INLINE_WAIT_SECONDS, sleeps
+      once and retries; otherwise raises MoltbookRateLimitedError.
+    - On other HTTPError / network error: prints and returns None (preserves the
+      existing callers' "return None on error" contract).
+    """
+    _wait_if_needed()
+
+    hdrs = {"User-Agent": user_agent}
+    if api_key:
+        hdrs["Authorization"] = f"Bearer {api_key}"
+    if headers:
+        hdrs.update(headers)
+
+    req = urllib.request.Request(url, headers=hdrs)
+
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as resp:
+            # Success: clear any lingering "near zero" from a stale 429.
+            _write_ratelimit(100, 0)
+            return json.loads(resp.read())
+    except urllib.error.HTTPError as e:
+        if e.code == 404:
+            raise HttpNotFoundError(url)
+        if e.code == 429:
+            body = e.read() if hasattr(e, "read") else b""
+            retry = _parse_retry_seconds(body)
+            _write_ratelimit(0, retry)
+            if retry > MAX_INLINE_WAIT_SECONDS:
+                raise MoltbookRateLimitedError(retry)
+            print(f"Moltbook 429, waiting {int(retry)+2}s... ({url})", file=sys.stderr)
+            time.sleep(int(retry) + 2)
+            # Single retry, propagate any errors from the retry.
+            try:
+                with urllib.request.urlopen(req, timeout=timeout) as resp:
+                    _write_ratelimit(100, 0)
+                    return json.loads(resp.read())
+            except urllib.error.HTTPError as e2:
+                if e2.code == 404:
+                    raise HttpNotFoundError(url)
+                if e2.code == 429:
+                    body2 = e2.read() if hasattr(e2, "read") else b""
+                    retry2 = _parse_retry_seconds(body2)
+                    _write_ratelimit(0, retry2)
+                    raise MoltbookRateLimitedError(retry2)
+                print(f"  ERROR fetching {url}: {e2}", file=sys.stderr)
+                return None
+            except Exception as ex:
+                print(f"  ERROR fetching {url}: {ex}", file=sys.stderr)
+                return None
+        print(f"  ERROR fetching {url}: {e}", file=sys.stderr)
+        return None
+    except HttpNotFoundError:
+        raise
+    except Exception as e:
+        print(f"  ERROR fetching {url}: {e}", file=sys.stderr)
+        return None

package/scripts/pending_threads.py

@@ -0,0 +1,188 @@
+#!/usr/bin/env python3
+"""
+pending_threads.py — persistence layer for thread drafts that may need retry.
+
+Why this exists:
+  Pre-2026-05-01 the run-reddit-threads pipeline drafted a post inside one
+  Claude session and submitted it via the reddit-agent MCP within the same
+  session. If the MCP child process died mid-flow (e.g. flair-click step on
+  r/AutoHotkey, 2026-05-01), the entire $4-24 of work was lost: the title +
+  body lived only in the Claude transcript JSON, not in the DB. Subsequent
+  pipeline runs regenerated everything from scratch.
+
+  pending_threads is a durable holding pen. The shell wrapper writes a row
+  here BEFORE attempting to submit, and the row's `status` tracks lifecycle:
+
+      pending  - drafted, not yet submitted (or submit aborted before permalink)
+      posted   - submit succeeded, posted_post_id + posted_permalink filled
+      abandoned - too many failed retries, or permanent_block on the sub
+
+  Recovery flow (next pipeline run): pick the oldest pending row for the
+  project before generating a fresh draft.
+
+Sub-commands (called from shell pipelines):
+  create        Insert a draft row, print id
+  mark-posted   status=posted, fill posted_post_id + posted_permalink
+  mark-aborted  bump attempts, fill abort_reason / abort_stage; keep pending
+  abandon       status=abandoned (e.g. sub got permanent_block)
+  list-pending  print all pending rows for a project (or all if no project)
+
+HTTP-only lane (2026-06-01): every read/write routes through the s4l.ai API
+(/api/v1/pending-threads). No DATABASE_URL, no psql, no db.get_conn(), no
+fallback. The function signatures + CLI shapes are unchanged so callers
+(run-reddit-threads.sh) need no edits beyond the DB-insert swap.
+"""
+from __future__ import annotations
+
+import argparse
+import json
+import os
+import sys
+from typing import Any, Optional
+
+# scripts/ is on sys.path when called from skill/*.sh; ensure it works
+# standalone too.
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_get, api_post, api_patch  # noqa: E402
+
+
+def create(
+    *,
+    project: str,
+    subreddit: str,
+    account: str,
+    title: str,
+    body: str,
+    flair_target: Optional[str] = None,
+    engagement_style: Optional[str] = None,
+    topic_angle: Optional[str] = None,
+    source_summary: Optional[str] = None,
+    claude_session_id: Optional[str] = None,
+    cost_usd: Optional[float] = None,
+) -> int:
+    resp = api_post("/api/v1/pending-threads", {
+        "project": project,
+        "subreddit": subreddit,
+        "account": account,
+        "title": title,
+        "body": body,
+        "flair_target": flair_target,
+        "engagement_style": engagement_style,
+        "topic_angle": topic_angle,
+        "source_summary": source_summary,
+        "claude_session_id": claude_session_id,
+        "cost_usd": cost_usd,
+    })
+    return int((resp.get("data") or {}).get("id"))
+
+
+def mark_posted(*, pending_id: int, post_id: int, permalink: str) -> None:
+    api_patch(f"/api/v1/pending-threads/{pending_id}", {
+        "action": "mark_posted",
+        "post_id": post_id,
+        "permalink": permalink,
+    })
+
+
+def mark_aborted(*, pending_id: int, abort_reason: str, abort_stage: Optional[str] = None) -> None:
+    api_patch(f"/api/v1/pending-threads/{pending_id}", {
+        "action": "mark_aborted",
+        "abort_reason": abort_reason,
+        "abort_stage": abort_stage,
+    })
+
+
+def abandon(*, pending_id: int, reason: str) -> None:
+    api_patch(f"/api/v1/pending-threads/{pending_id}", {
+        "action": "abandon",
+        "reason": reason,
+    })
+
+
+def list_pending(project: Optional[str] = None) -> list[dict[str, Any]]:
+    resp = api_get("/api/v1/pending-threads",
+                   query={"project": project} if project else None)
+    return (resp.get("data") or {}).get("pending_threads") or []
+
+
+def get(pending_id: int) -> Optional[dict[str, Any]]:
+    resp = api_get(f"/api/v1/pending-threads/{pending_id}", ok_on_404=True)
+    if resp.get("_not_found"):
+        return None
+    return (resp.get("data") or {}).get("pending_thread")
+
+
+def main() -> int:
+    p = argparse.ArgumentParser(description="pending_threads helper")
+    sub = p.add_subparsers(dest="cmd", required=True)
+
+    pc = sub.add_parser("create")
+    pc.add_argument("--project", required=True)
+    pc.add_argument("--subreddit", required=True)
+    pc.add_argument("--account", required=True)
+    pc.add_argument("--title", required=True)
+    pc.add_argument("--body", required=True)
+    pc.add_argument("--flair-target")
+    pc.add_argument("--engagement-style")
+    pc.add_argument("--topic-angle")
+    pc.add_argument("--source-summary")
+    pc.add_argument("--claude-session-id")
+    pc.add_argument("--cost-usd", type=float)
+
+    pp = sub.add_parser("mark-posted")
+    pp.add_argument("--id", required=True, type=int)
+    pp.add_argument("--post-id", required=True, type=int)
+    pp.add_argument("--permalink", required=True)
+
+    pa = sub.add_parser("mark-aborted")
+    pa.add_argument("--id", required=True, type=int)
+    pa.add_argument("--abort-reason", required=True)
+    pa.add_argument("--abort-stage")
+
+    pab = sub.add_parser("abandon")
+    pab.add_argument("--id", required=True, type=int)
+    pab.add_argument("--reason", required=True)
+
+    pl = sub.add_parser("list-pending")
+    pl.add_argument("--project")
+
+    pg = sub.add_parser("get")
+    pg.add_argument("--id", required=True, type=int)
+
+    args = p.parse_args()
+
+    if args.cmd == "create":
+        i = create(
+            project=args.project,
+            subreddit=args.subreddit,
+            account=args.account,
+            title=args.title,
+            body=args.body,
+            flair_target=args.flair_target,
+            engagement_style=args.engagement_style,
+            topic_angle=args.topic_angle,
+            source_summary=args.source_summary,
+            claude_session_id=args.claude_session_id,
+            cost_usd=args.cost_usd,
+        )
+        print(json.dumps({"ok": True, "id": i}))
+    elif args.cmd == "mark-posted":
+        mark_posted(pending_id=args.id, post_id=args.post_id, permalink=args.permalink)
+        print(json.dumps({"ok": True}))
+    elif args.cmd == "mark-aborted":
+        mark_aborted(pending_id=args.id, abort_reason=args.abort_reason, abort_stage=args.abort_stage)
+        print(json.dumps({"ok": True}))
+    elif args.cmd == "abandon":
+        abandon(pending_id=args.id, reason=args.reason)
+        print(json.dumps({"ok": True}))
+    elif args.cmd == "list-pending":
+        rows = list_pending(args.project)
+        print(json.dumps(rows, indent=2))
+    elif args.cmd == "get":
+        rec = get(args.id)
+        print(json.dumps(rec, indent=2))
+    return 0
+
+
+if __name__ == "__main__":
+    sys.exit(main())