@m13v/s4l 1.7.12-rc.2 → 1.7.12-rc.5

package/browser-agent-configs/linkedin-harness-mcp.json

@@ -14,7 +14,9 @@
         "PATH": "__HOME__/.local/bin:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin",
         "BU_NAME": "linkedin-harness",
         "BH_PORT": "9556",
-        "BH_PROFILE_NAME": "browser-harness-linkedin"
+        "BH_PROFILE_NAME": "browser-harness-linkedin",
+        "BH_WINDOW_POS": "3814,-1050",
+        "BH_WINDOW_SIZE": "1024,1013"
       }
     }
   }

package/browser-agent-configs/twitter-harness-mcp.json

@@ -11,7 +11,9 @@
         "__HOME__/.claude/mcp-servers/browser-harness/server.py"
       ],
       "env": {
-        "PATH": "__HOME__/.local/bin:__NODE_BIN__:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
+        "PATH": "__HOME__/.local/bin:__NODE_BIN__:/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin",
+        "BH_WINDOW_POS": "3042,-1032",
+        "BH_WINDOW_SIZE": "1024,1013"
       }
     }
   }

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.12-rc.2",
-  "installedAt": "2026-08-20T01:59:29.922Z"
+  "version": "1.7.12-rc.5",
+  "installedAt": "2026-09-01T23:32:18.166Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.12-rc.2",
+  "version": "1.7.12-rc.5",
   "description": "Draft, review, approve, and autopilot X/Twitter posts.",
   "long_description": "## **⚠️ The disclaimer above is generic Claude boilerplate.** Anthropic shows the same warning on every plugin regardless of what it does; any plugin has the same level of access as any app you download from the internet.\n\nS4L is an open source product developed by Mediar.ai Incorporated, a VC-backed San Francisco-based startup.\n\nTo get started:\n\n1\\. Copy this prompt: **Set me up on S4L plugin end to end**\n\n2\\. Quit with CMD+Q, reopen Claude, paste into a new chat.\n\nWhat happens next:\n\n* About every 5 minutes S4L scans X for posts that match your topics and drafts replies in your voice.\n* Drafts show up as review cards, usually the first within a few minutes. Nothing is posted automatically; you approve each one.\n* Posting autopilot stays off until you explicitly turn it on.",
   "author": {

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.12-rc.2",
+  "version": "1.7.12-rc.5",
   "private": true,
   "description": "Desktop MCP client for social-autoposter (X/Twitter rail): manual draft/review/approve loop, autopilot control, and stats. Thin wrapper over the existing pipeline scripts.",
   "license": "MIT",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l",
-  "version": "1.7.12-rc.2",
+  "version": "1.7.12-rc.5",
   "description": "Automated social posting pipeline for Reddit, X/Twitter, LinkedIn, and Moltbook. Install as a Claude Code agent skill.",
   "bin": {
     "social-autoposter": "bin/cli.js",

package/scripts/cdp_drive.py

@@ -0,0 +1,102 @@
+#!/usr/bin/env python3
+"""Minimal CDP driver for the harness Chrome on port 9556.
+Usage:
+  cdp_drive.py nav <url>            -> navigate active page tab, print final href
+  cdp_drive.py href                 -> print current href of active page tab
+  cdp_drive.py shot <path>          -> screenshot active page tab to path
+  cdp_drive.py click <x> <y>        -> dispatch mouse click at viewport coords
+  cdp_drive.py eval <expr>          -> evaluate JS expression, print JSON result
+"""
+import sys, json, time, base64
+import urllib.request
+import websocket  # websocket-client
+
+PORT = 9556
+BASE = f"http://localhost:{PORT}"
+
+
+def list_tabs():
+    with urllib.request.urlopen(f"{BASE}/json/list", timeout=10) as r:
+        return json.load(r)
+
+
+def active_page():
+    tabs = list_tabs()
+    pages = [t for t in tabs if t.get("type") == "page" and t.get("webSocketDebuggerUrl")]
+    # prefer a linkedin tab, else first page
+    for t in pages:
+        if "linkedin.com" in (t.get("url") or ""):
+            return t
+    if pages:
+        return pages[0]
+    raise RuntimeError("no page tab")
+
+
+class CDP:
+    def __init__(self, ws_url):
+        self.ws = websocket.create_connection(
+            ws_url, max_size=None, timeout=60, suppress_origin=True
+        )
+        self._id = 0
+
+    def cmd(self, method, **params):
+        self._id += 1
+        mid = self._id
+        self.ws.send(json.dumps({"id": mid, "method": method, "params": params}))
+        while True:
+            msg = json.loads(self.ws.recv())
+            if msg.get("id") == mid:
+                if "error" in msg:
+                    raise RuntimeError(msg["error"])
+                return msg.get("result", {})
+
+    def close(self):
+        try:
+            self.ws.close()
+        except Exception:
+            pass
+
+
+def get_href(c):
+    r = c.cmd("Runtime.evaluate", expression="location.href", returnByValue=True)
+    return r.get("result", {}).get("value")
+
+
+def main():
+    action = sys.argv[1]
+    tab = active_page()
+    c = CDP(tab["webSocketDebuggerUrl"])
+    try:
+        if action in ("nav", "click"):
+            c.cmd("Page.enable")
+        if action == "nav":
+            url = sys.argv[2]
+            c.cmd("Page.navigate", url=url)
+            time.sleep(6)
+            print(get_href(c))
+        elif action == "href":
+            print(get_href(c))
+        elif action == "shot":
+            path = sys.argv[2]
+            r = c.cmd("Page.captureScreenshot", format="png")
+            with open(path, "wb") as f:
+                f.write(base64.b64decode(r["data"]))
+            print(path)
+        elif action == "click":
+            x = float(sys.argv[2]); y = float(sys.argv[3])
+            c.cmd("Input.dispatchMouseEvent", type="mousePressed", x=x, y=y, button="left", clickCount=1)
+            c.cmd("Input.dispatchMouseEvent", type="mouseReleased", x=x, y=y, button="left", clickCount=1)
+            time.sleep(4)
+            print(get_href(c))
+        elif action == "eval":
+            expr = sys.argv[2]
+            r = c.cmd("Runtime.evaluate", expression=expr, returnByValue=True, awaitPromise=True)
+            print(json.dumps(r.get("result", {}).get("value")))
+        else:
+            print("unknown action", file=sys.stderr); sys.exit(2)
+    finally:
+        c.close()
+
+
+if __name__ == "__main__":
+    main()

package/scripts/cdp_ready_check.py

@@ -24,6 +24,18 @@ crashed ("Aw, Snap") keeps its title/url in every listing while sitting dead;
 probe each page with a trivial Runtime.evaluate and reload it IN PLACE on
 failure — fresh renderer, no kill, no new window, no focus change.
 
+DEAD SESSION DISPATCH (2026-08-20, recurred 2026-09-01): a parked tab whose
+DevTools SESSION dispatch is dead never replies to any per-tab command, so the
+in-place Page.reload hangs too and cannot revive it — while the browser-level
+ws stays healthy and this probe used to report ready anyway (Playwright then
+hung at connect for every posting attempt; on 09-01 that burned all 5 drain
+retries on two human-approved drafts). The reload is therefore RE-VERIFIED
+with a second Runtime.evaluate; a tab that still doesn't answer gets REPLACED
+via browser-level Target.createTarget(background=True) + Target.closeTarget
+(the proven fix both incidents — no Chrome restart, no focus steal, session
+cookies intact). Only if replacement itself fails does the verdict flip to
+ready=false, so hc_ensure_browser's two-strike reap finally has a real signal.
+
 Usage: cdp_ready_check.py [CDP_URL] [TIMEOUT_MS]
 
 Prints a one-line JSON verdict to stdout (same shape/keys as before; mode is
@@ -84,9 +96,13 @@ def main() -> int:
         info = _get_json(f"{url}/json/version", timeout=3)
         _ws_call(info["webSocketDebuggerUrl"], "Browser.getVersion", timeout_s)
 
-        # Renderer-liveness sweep: revive crashed tabs in place, best-effort;
-        # revival must never fail the readiness verdict the wedge gate uses.
+        # Renderer-liveness sweep. A crashed renderer revives with an in-place
+        # reload; a tab with dead session dispatch (reload hangs too) gets
+        # REPLACED via browser-level commands. Only an unfixable page tab
+        # fails the verdict — see DEAD SESSION DISPATCH in the docstring.
         revived = 0
+        replaced = 0
+        dead = 0
         pages = []
         try:
             pages = [t for t in _get_json(f"{url}/json/list", timeout=3)
@@ -95,23 +111,54 @@ def main() -> int:
                 try:
                     _ws_call(t["webSocketDebuggerUrl"], "Runtime.evaluate",
                              4.0, expression="1")
+                    continue
+                except Exception:
+                    pass
+                try:
+                    _ws_call(t["webSocketDebuggerUrl"], "Page.reload", 8.0)
+                except Exception:
+                    pass
+                # Re-verify: a reload that went through proves dispatch is
+                # alive again; one that hung proves it never will be.
+                try:
+                    _ws_call(t["webSocketDebuggerUrl"], "Runtime.evaluate",
+                             4.0, expression="1")
+                    revived += 1
+                    continue
+                except Exception:
+                    pass
+                # Dead session dispatch: replace the TAB, keep Chrome. Only
+                # http(s) tabs are recreated (the harness daemon's
+                # is_real_page refuses about:/chrome: tabs); the dead one is
+                # closed only after its replacement exists so the browser is
+                # never left tabless.
+                page_url = t.get("url") or ""
+                try:
+                    if not page_url.startswith("http"):
+                        raise ValueError(f"unreplaceable url {page_url[:40]!r}")
+                    _ws_call(info["webSocketDebuggerUrl"], "Target.createTarget",
+                             8.0, url=page_url, background=True)
+                    _ws_call(info["webSocketDebuggerUrl"], "Target.closeTarget",
+                             8.0, targetId=t["id"])
+                    replaced += 1
                 except Exception:
-                    try:
-                        _ws_call(t["webSocketDebuggerUrl"], "Page.reload", 8.0)
-                        revived += 1
-                    except Exception:
-                        pass
+                    dead += 1
         except Exception:
             pass
 
         out = {
-            "ready": True, "mode": "raw_ws", "contexts": len(pages),
+            "ready": dead == 0, "mode": "raw_ws", "contexts": len(pages),
             "elapsed_s": round(time.time() - t0, 2),
         }
         if revived:
             out["revived"] = revived
+        if replaced:
+            out["replaced"] = replaced
+        if dead:
+            out["dead_pages"] = dead
+            out["error"] = "page_session_dead_unreplaceable"
         print(json.dumps(out))
-        return 0
+        return 0 if dead == 0 else 1
     except Exception as e:
         print(json.dumps({
             "ready": False, "mode": "raw_ws",

package/scripts/engage_github.py

@@ -264,11 +264,27 @@ classification, output reason='blocklist_added:HANDLE:bot' or
 - Tier 2: Only if the thread is explicitly about a topic one of our projects solves AND nobody has offered a comparable tool yet AND the maintainer hasn't already resolved it. Mention casually.
 - Tier 3: Only if someone explicitly asks "what do you use" / "any tools for this" / "link?". Then give it directly.
 
-## Decision step: reply or skip?
+## Decision step: escalate, reply, or skip?
 
 Read the FULL thread above. There is NO cap on how many times we can reply to a thread. Active back-and-forth is encouraged when the conversation keeps developing and we have something useful to contribute. Do not skip just because we have prior comments in the thread. Skip only when one of the specific conditions below is clearly true.
 
-DEFAULT TO REPLY when you have substance. Lean toward engagement, not silence.
+CHECK ESCALATION FIRST. Escalation hands the thread to the human who owns
+this account; they answer by email and their answer is posted as the
+comment. ESCALATE (output action=escalate with a one-line reason) when any
+of these is true:
+- The replier directly addresses OUR author (by @mention or unmistakable
+  context) with a question about something WE said, e.g. "@{our_username}
+  could you expand on what you mean?". A personal question to us deserves
+  the human's own answer, not a generated one.
+- The replier reports a bug, breakage, or defect in one of OUR products
+  (anything in config.json). Bug reports need the maker's eyes.
+- The replier is the repo OWNER (or an obvious maintainer) engaging
+  seriously with our comment. Maintainer conversations are relationships
+  the human should hold personally.
+When a comment fits both ESCALATE and REPLY, escalate. Do not draft a
+reply text for an escalated comment.
+
+Otherwise, DEFAULT TO REPLY when you have substance. Lean toward engagement, not silence.
 
 SKIP (output action=skip) only when one of these is clearly true:
 - light_acknowledgment: the triggering comment is just thanks, emoji, +1, or other content-free acknowledgment
@@ -291,6 +307,9 @@ Output ONLY ONE JSON object. No markdown, no prose, no explanations, no code fen
 For skip:
 {{"action": "skip", "reason": "REASON_FROM_LIST_ABOVE"}}
 
+For escalate:
+{{"action": "escalate", "reason": "ONE_LINE_WHY_THE_HUMAN_SHOULD_ANSWER"}}
+
 For reply:
 {{"action": "reply", "text": "YOUR_REPLY_TEXT", "project": null, "engagement_style": "STYLE_NAME"}}
 
@@ -463,6 +482,7 @@ def main():
     processed = 0
     succeeded = 0
     skipped = 0
+    escalated = 0
     failed = 0
     total_usage = {"input_tokens": 0, "output_tokens": 0, "cache_read": 0, "cache_create": 0, "cost_usd": 0.0}
 
@@ -601,6 +621,28 @@ def main():
                 skipped += 1
                 print(f"[engage_github] #{reply['id']} SKIPPED: {reason} ({reply_elapsed:.0f}s) "
                       f"[${usage['cost_usd']:.4f}]")
+            elif decision.get("action") == "escalate":
+                # Flag-human escalation (2026-09-01): routes through
+                # reply_db.py escalated -> POST /api/v1/replies/{id}/flag-human,
+                # which sets status='escalated' and emails the [GH #id]
+                # escalation card from matt@s4l.ai. The human's Gmail reply is
+                # posted back to this thread verbatim by
+                # scripts/ingest_human_github_replies.py.
+                reason = (decision.get("reason") or "escalated by engage judgment").strip()
+                esc_res = subprocess.run(
+                    [PYTHON, REPLY_DB, "escalated", str(reply["id"]), reason],
+                    capture_output=True, text=True,
+                )
+                if esc_res.returncode == 0:
+                    escalated += 1
+                    print(f"[engage_github] #{reply['id']} ESCALATED: {reason} "
+                          f"({reply_elapsed:.0f}s) [{(esc_res.stdout or '').strip()[:120]}]")
+                else:
+                    # Escalation transport failed; leave the row pending so the
+                    # next cycle retries rather than losing the flag.
+                    failed += 1
+                    print(f"[engage_github] #{reply['id']} ESCALATE FAILED: "
+                          f"{(esc_res.stderr or esc_res.stdout or '')[:200]}")
             elif decision.get("action") == "reply":
                 reply_text = (decision.get("text") or "").strip()
                 project = decision.get("project")
@@ -648,7 +690,7 @@ def main():
     total_elapsed = time.time() - start_time
     print(f"\n[engage_github] === SUMMARY ===")
     print(f"[engage_github] processed={processed} succeeded={succeeded} "
-          f"skipped={skipped} failed={failed} elapsed={total_elapsed:.0f}s")
+          f"skipped={skipped} escalated={escalated} failed={failed} elapsed={total_elapsed:.0f}s")
     print(f"[engage_github] Total tokens: input={total_usage['input_tokens']} "
           f"output={total_usage['output_tokens']} "
           f"cache_read={total_usage['cache_read']} cache_create={total_usage['cache_create']}")
@@ -659,10 +701,14 @@ def main():
     # Canonical machine-readable summary line. github-engage.sh greps this and
     # writes ONE log_run.py row that also carries Phase A scan counters. See
     # the comment in engage_reddit.py for the duplicate-row history.
+    # escalated= rides along for observability; github-engage.sh's greps are
+    # token-anchored (posted=/skipped=/failed=/cost=) so the extra token is
+    # invisible to the existing log_run parsing.
     print(
         f"[engage_github] LOG_RUN_SUMMARY"
         f" posted={succeeded}"
         f" skipped={skipped}"
+        f" escalated={escalated}"
         f" failed={failed}"
         f" cost={total_usage['cost_usd']:.4f}"
         f" elapsed={int(total_elapsed)}"

package/scripts/ingest_human_github_replies.py

@@ -0,0 +1,205 @@
+#!/usr/bin/env python3
+"""Ingest human replies to GitHub escalation emails from Gmail and post them.
+
+GitHub-lane mirror of ingest_human_dm_replies.py. Flow:
+  1. engage_github.py decides action='escalate' -> reply_db.py escalated ->
+     POST /api/v1/replies/{id}/flag-human sets status='escalated' and sends an
+     escalation email with subject `[GH #<reply_id>] <author> [github]: <reason>`
+     FROM matt@s4l.ai TO NOTIFICATION_EMAIL (i@m13v.com).
+  2. The human hits Reply in Gmail and writes the answer. Because the
+     escalation's From is matt@s4l.ai (a send-as alias), the reply lands in the
+     matt@s4l.ai mailbox as a fresh unread inbound message.
+  3. This script polls that mailbox for unread `Re: [GH #N]` messages. For each,
+     it extracts the reply_id, strips quoted history, and posts the text
+     VERBATIM as a comment on the GitHub thread via gh CLI (unlike the DM lane,
+     there is no rewrite step; what the human wrote is what appears).
+  4. The replies row flips to status='replied' with the human's text and the
+     posted comment URL; "skip"/"ignore"/"not relevant" bodies dismiss the
+     escalation instead (status='skipped', no comment posted).
+  5. The Gmail message is marked read so it is never re-ingested; rows not in
+     status='escalated' are never posted (double-post guard for stale emails).
+
+Auth: same keyless DWD lane as the DM ingest (helpers imported from
+ingest_human_dm_replies.py, which owns the token refresh logic).
+
+Usage:
+    python3 scripts/ingest_human_github_replies.py             # ingest and post
+    python3 scripts/ingest_human_github_replies.py --dry-run   # print actions, no posts, no DB writes, no label changes
+"""
+
+import argparse
+import os
+import re
+import subprocess
+import sys
+
+sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
+from http_api import api_get, api_patch
+from ingest_human_dm_replies import (
+    gmail_service,
+    fetch_raw,
+    pick_plain_body,
+    strip_quoted_history,
+    extract_sender_addr,
+)
+
+GH_ID_RE = re.compile(r"\[GH\s*#(\d+)\]", re.IGNORECASE)
+RE_PREFIX_RE = re.compile(r"^\s*re\s*:", re.IGNORECASE)
+GMAIL_QUERY = 'is:unread subject:"Re: [GH #"'
+DISMISS_WORDS = {"skip", "ignore", "not relevant"}
+
+ISSUE_URL_RE = re.compile(r"github\.com/([^/]+)/([^/]+)/(?:issues|pull)/(\d+)")
+
+
+def parse_issue_coords(url):
+    m = ISSUE_URL_RE.search(url or "")
+    if not m:
+        return None, None, None
+    return m.group(1), m.group(2), int(m.group(3))
+
+
+def post_comment(owner, repo, number, body):
+    """Post via gh CLI; returns (ok, url_or_error). Same shape as engage_github."""
+    try:
+        out = subprocess.check_output(
+            ["gh", "issue", "comment", str(number), "-R", f"{owner}/{repo}", "--body", body],
+            text=True, timeout=60, stderr=subprocess.STDOUT,
+        )
+        for line in out.strip().splitlines():
+            if line.startswith("https://github.com"):
+                return True, line.strip()
+        return True, None
+    except (subprocess.CalledProcessError, subprocess.TimeoutExpired) as e:
+        err = e.output if hasattr(e, "output") and e.output else str(e)
+        return False, str(err)[:300]
+
+
+def mark_read(service, gmail_id):
+    try:
+        service.users().messages().modify(
+            userId="me", id=gmail_id, body={"removeLabelIds": ["UNREAD"]}
+        ).execute()
+    except Exception as e:
+        print(f"  WARN {gmail_id}: could not mark as read: {e}")
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument("--dry-run", action="store_true",
+                        help="Print what would be posted, do not post/patch/mark-read")
+    args = parser.parse_args()
+
+    try:
+        service = gmail_service()
+    except Exception as e:
+        print(f"FATAL: could not build Gmail service: {e}", file=sys.stderr)
+        sys.exit(2)
+
+    resp = service.users().messages().list(userId="me", q=GMAIL_QUERY, maxResults=50).execute()
+    candidates = resp.get("messages", []) or []
+    if not candidates:
+        print("No candidate Gmail messages for GitHub escalation replies.")
+        return
+
+    posted = 0
+    dismissed = 0
+    skipped = 0
+    for c in candidates:
+        gmail_id = c["id"]
+        try:
+            email_msg, _labels = fetch_raw(service, gmail_id)
+        except Exception as e:
+            print(f"  SKIP {gmail_id}: fetch failed: {e}")
+            skipped += 1
+            continue
+
+        subject = email_msg.get("Subject", "") or ""
+        sender = extract_sender_addr(email_msg.get("From", ""))
+        m = GH_ID_RE.search(subject)
+        if not m:
+            print(f"  SKIP {gmail_id}: subject has no [GH #N] token ({subject!r})")
+            skipped += 1
+            continue
+        reply_id = int(m.group(1))
+
+        # Reject forwards / originals: only true Gmail replies count.
+        if not RE_PREFIX_RE.match(subject):
+            print(f"  SKIP {gmail_id}: subject not a reply ({subject!r})")
+            skipped += 1
+            continue
+
+        r_resp = api_get(f"/api/v1/replies/{reply_id}", ok_on_404=True)
+        row = (r_resp.get("data") or {}).get("reply") if r_resp.get("ok") else None
+        if not row:
+            print(f"  SKIP {gmail_id}: reply #{reply_id} not found")
+            skipped += 1
+            if not args.dry_run:
+                mark_read(service, gmail_id)
+            continue
+
+        # Double-post guard: only an 'escalated' row is actionable. A row
+        # already flipped to replied/skipped means an earlier run (or a second
+        # email) handled it; mark the mail read and move on.
+        if row.get("status") != "escalated":
+            print(f"  SKIP {gmail_id}: reply #{reply_id} status is "
+                  f"'{row.get('status')}', not 'escalated'")
+            skipped += 1
+            if not args.dry_run:
+                mark_read(service, gmail_id)
+            continue
+
+        body_raw = pick_plain_body(email_msg)
+        reply_text = strip_quoted_history(body_raw)
+        if not reply_text:
+            print(f"  SKIP {gmail_id}: empty reply after stripping quoted history")
+            skipped += 1
+            continue
+
+        owner, repo, number = parse_issue_coords(row.get("their_comment_url") or "")
+        if not owner:
+            print(f"  SKIP {gmail_id}: reply #{reply_id} has no parseable "
+                  f"their_comment_url ({row.get('their_comment_url')!r})")
+            skipped += 1
+            continue
+
+        if reply_text.strip().lower().rstrip(".!") in DISMISS_WORDS:
+            print(f"  DISMISS {gmail_id}: reply #{reply_id} "
+                  f"({owner}/{repo}#{number}) per '{reply_text.strip()}' from {sender}")
+            if not args.dry_run:
+                api_patch(f"/api/v1/replies/{reply_id}", {
+                    "status": "skipped",
+                    "skip_reason": "escalation_dismissed_by_human",
+                })
+                mark_read(service, gmail_id)
+            dismissed += 1
+            continue
+
+        print(f"  POST {gmail_id}: reply #{reply_id} -> {owner}/{repo}#{number}: "
+              f"{reply_text[:120]!r}")
+        if args.dry_run:
+            posted += 1
+            continue
+
+        ok_post, url_or_err = post_comment(owner, repo, number, reply_text)
+        if not ok_post:
+            # Leave unread + escalated so the next run retries.
+            print(f"  ERROR {gmail_id}: gh comment failed: {url_or_err}")
+            skipped += 1
+            continue
+
+        api_patch(f"/api/v1/replies/{reply_id}", {
+            "status": "replied",
+            "our_reply_content": reply_text,
+            "our_reply_url": url_or_err,
+            "engagement_style": "human_escalation",
+        })
+        mark_read(service, gmail_id)
+        posted += 1
+        print(f"  DONE reply #{reply_id} -> {url_or_err or '(no url)'}")
+
+    print(f"Done. Posted={posted} dismissed={dismissed} skipped={skipped} "
+          f"candidates={len(candidates)}")
+
+
+if __name__ == "__main__":
+    main()

package/scripts/reply_db.py

@@ -189,6 +189,25 @@ elif cmd == "skip_batch":
             "claude_session_id": CLAUDE_SESSION_ID,
         })
     print(f"ok {len(data['ids'])}")
+elif cmd == "escalated":
+    # reply_db.py escalated ID "reason"
+    # GitHub reply lane flag-human escalation: routes through the dedicated
+    # POST /api/v1/replies/{id}/flag-human endpoint (NOT the generic PATCH),
+    # which sets status='escalated', stores the reason, and sends the
+    # [GH #id] escalation email from matt@s4l.ai in one round trip, mirroring
+    # dm_conversation.py's flag-human command. A row already replied or
+    # escalated comes back { flagged: false, skipped: true } and we print
+    # the skip instead of erroring, so a double-decision never 500s the lane.
+    from http_api import api_post
+    rid, reason = int(sys.argv[2]), sys.argv[3]
+    resp = api_post(f"/api/v1/replies/{rid}/flag-human", {"reason": reason},
+                    ok_on_conflict=True)
+    data = ((resp or {}).get("data") or {})
+    if data.get("flagged"):
+        email = "sent" if data.get("email_sent") else "NOT SENT"
+        print(f"ok {rid} escalated (email {email})")
+    else:
+        print(f"skip {rid} not re-flagged ({data.get('reason', 'unknown')})")
 elif cmd == "set_project":
     # reply_db.py set_project ID "project_name"
     # Used by engage_reddit.py to attribute a posted reply to a recommended

package/scripts/scan_github_replies.py

@@ -26,13 +26,18 @@ _cfg_sys.path.insert(0, _cfg_os.path.dirname(_cfg_os.path.abspath(__file__)))
 from config import config_path as _canonical_config_path, load_config
 CONFIG_PATH = _canonical_config_path()
 
-# NOTE: posts/replies for GitHub live under platform='github' in the DB; the
-# 'github_issues' value used here matches zero rows, so Phase A has long been a
-# no-op. Preserved verbatim during the HTTP-only migration to avoid an
-# unrequested volume/cost change (switching to 'github' would suddenly scan all
-# ~6.8k GitHub posts). If you want to actually scan GitHub replies, flip
-# SCAN_PLATFORM to 'github' deliberately.
-SCAN_PLATFORM = "github_issues"
+# posts/replies for GitHub live under platform='github' in the DB. This was
+# 'github_issues' (matching zero rows, making Phase A a no-op) until
+# 2026-09-01, when the user asked for the deliberate flip. Volume is bounded
+# so the flip does NOT scan all ~6.8k historical GitHub posts: only active
+# posts from the last SCAN_WINDOW_DAYS are fetched (218 threads at flip time),
+# and consecutive gh API failures back off and abort the scan instead of
+# hammering a spent rate limit (Phase A.5 shares the same gh quota).
+SCAN_PLATFORM = "github"
+SCAN_WINDOW_DAYS = 60
+# Stop the scan after this many CONSECUTIVE gh api failures: a run that hits
+# this is rate-limited or offline, and every further call just burns quota.
+MAX_CONSECUTIVE_ERRORS = 5
 
 
 
@@ -49,8 +54,12 @@ def main():
     # Get all active GitHub posts we've commented on. The posts GET returns id +
     # thread_url together, so we capture the post_id map here and skip the
     # per-thread lookup the direct-SQL version used to do.
+    from datetime import datetime, timedelta, timezone
+    since_iso = (datetime.now(timezone.utc) - timedelta(days=SCAN_WINDOW_DAYS)).strftime(
+        "%Y-%m-%dT%H:%M:%SZ")
     resp = api_get("/api/v1/posts",
-                   query={"platform": SCAN_PLATFORM, "status": "active", "limit": 500})
+                   query={"platform": SCAN_PLATFORM, "status": "active",
+                          "since": since_iso, "limit": 500})
     rows = ((resp or {}).get("data") or {}).get("posts") or []
 
     issues = {}
@@ -80,10 +89,16 @@ def main():
     discovered = 0
     skipped = 0
     errors = 0
+    consecutive_errors = 0
 
     for issue_key, thread_url in issues.items():
         repo, issue_num = issue_key.rsplit("/", 1)
 
+        if consecutive_errors >= MAX_CONSECUTIVE_ERRORS:
+            print(f"  ABORT: {consecutive_errors} consecutive gh api failures "
+                  f"(rate limit / offline); stopping scan to preserve quota.")
+            break
+
         # post_id captured alongside thread_url in the posts GET above.
         post_id = post_id_by_url.get(thread_url)
         if not post_id:
@@ -98,11 +113,22 @@ def main():
             )
             if result.returncode != 0:
                 errors += 1
+                consecutive_errors += 1
+                stderr_l = (result.stderr or "").lower()
+                if "rate limit" in stderr_l or "api rate limit exceeded" in stderr_l:
+                    print(f"  ABORT: gh rate limit hit on {issue_key}; stopping scan.")
+                    break
+                # Exponential backoff on consecutive failures (2s, 4s, 8s, 16s)
+                # so a flapping API gets breathing room instead of a hammer.
+                time.sleep(min(2 ** consecutive_errors, 30))
                 continue
             comments = json.loads(result.stdout) if result.stdout.strip() else []
+            consecutive_errors = 0
         except Exception as e:
             print(f"  ERROR scanning {issue_key}: {e}")
             errors += 1
+            consecutive_errors += 1
+            time.sleep(min(2 ** consecutive_errors, 30))
             continue
 
         # Find our comments to know their timestamps