@m13v/s4l 1.7.4-rc.4 → 1.7.4

package/scripts/autopilot_stall_watch.py

@@ -14,7 +14,8 @@ autopilot" item). This watcher is the part the user can't see: a fleet-side aler
 so a sustained stall pages us even when nobody is looking at the menu bar.
 
 Design mirrors the stall signal in mcp/menubar/s4l_menubar.py (_autopilot_stalled)
-and mcp/src/index.ts (autopilotStalled) — keep the threshold in sync:
+and mcp/src/index.ts (autopilotStalled); the thresholds are shared via
+schedule_state.py (index.ts mirrors by hand):
   stalled = the autopilot is configured (a complete worker set's SKILL.md
             files present — see WORKER_TASK_SETS)
             AND a draft job has sat unclaimed in pending/ past STALL_SECONDS.
@@ -46,19 +47,34 @@ import identity  # noqa: E402  (lives next to this file in scripts/)
 
 s4l_env.mirror()
 
-# Keep in sync with AUTOPILOT_STALL_SECONDS (menubar) / AUTOPILOT_STALL_MS (index.ts).
-STALL_SECONDS = 180
-# A job CLAIMED but never finished (sits in running/ this long) means a worker
-# picked it up and then died mid-run — the claude -p drafting child never came up
-# or crashed. Must be generous enough to clear the longest real drafting turn so a
-# healthy run never trips it. Keep in sync with AUTOPILOT_RUNNING_STALL_SECONDS
-# (menubar). See _oldest_running_age.
-RUNNING_STALL_SECONDS = 900
+# Stall thresholds live in schedule_state.py (HEALTHY_DRAIN_MAX_SECONDS and the
+# names derived from it) — retune there, not here. STALL_SECONDS = pending job
+# unclaimed; RUNNING_STALL_SECONDS = claimed but wedged (see _oldest_running_age).
+from schedule_state import STALL_SECONDS, RUNNING_STALL_SECONDS  # noqa: E402
 # Require the stall to persist this many consecutive checks before paging, so a
 # transient slow claim (e.g. right after a Claude restart) doesn't false-alarm.
 # At StartInterval 120 that is ~6 min of continuous stall.
 ALERT_AFTER = 3
 
+# --- Host-sleep awareness (2026-07-13, Sentry S4L-4B) ------------------------
+# launchd does NOT fire StartInterval jobs while the host is suspended, so the
+# wall-clock gap between consecutive ticks of THIS watchdog is a reliable sleep
+# detector: a gap of 3+ intervals means the box was asleep (or powered off),
+# not stalled. S4L-4B (Nhat's MacBook Air, 2026-07-11): laptop slept mid-cycle,
+# one producer enqueue timeout latched, no cycle ran to clear it, and the page
+# fired with pending=0/running=0 and a bogus "account change?" cause while the
+# telemetry showed 9 samples in a 2h window (40-min gaps). Laptops that sleep
+# between cycles would re-trigger that page forever.
+TICK_INTERVAL_SECONDS = 120  # keep in sync with launchd StartInterval
+SLEEP_GAP_SECONDS = TICK_INTERVAL_SECONDS * 3  # missed >=3 ticks -> host slept
+# For this long after a detected sleep gap, pre-existing latch/age signals are
+# treated as sleep-tainted: they must be corroborated by actual queued work
+# (pending/running > 0) or the outcome-level batches_stuck backstop to page.
+SLEEP_GAP_RECENT_SECONDS = 1800
+# A worker-task transcript modified this recently proves the routines are
+# firing, which rules out the "orphaned routines / account change" cause.
+WORKER_RECENT_SECONDS = 1800
+
 # A box counts as configured when ANY complete worker set has its SKILL.md on
 # disk: the universal type-blind worker, its short-lived staging predecessor, or
 # the legacy per-type pair. Keep in sync with WORKER_TASK_SETS in
@@ -142,6 +158,46 @@ def _recent_rate_limit(window: int = 1200) -> bool:
     return False
 
 
+def _worker_ran_recently(window: int = WORKER_RECENT_SECONDS) -> bool:
+    """True if any s4l-worker scheduled-task transcript was written in the last
+    `window` seconds — direct on-disk proof the worker routines are firing, so
+    a stall can NOT be the orphaned-routines / account-change shape. Same
+    transcript bucket _recent_rate_limit reads."""
+    try:
+        now = time.time()
+        for f in glob.glob(os.path.expanduser("~/.claude/projects/*s4l-worker*/*.jsonl")):
+            try:
+                if (now - os.path.getmtime(f)) <= window:
+                    return True
+            except OSError:
+                continue
+    except Exception:
+        pass
+    return False
+
+
+def _api_reachable(timeout: float = 3.0) -> bool:
+    """True if the S4L API host answers HTTP at all. ANY HTTP status counts as
+    reachable (a 4xx/5xx still proves the network path is up); only a socket /
+    URL error means offline. Used to hold the Sentry page while the box has no
+    network — an offline box is a different, self-healing condition, and the
+    page would be misleading (plus the event can't ship anyway). The stall
+    episode keeps counting, so if it's still stalled when connectivity returns,
+    the page fires then."""
+    import urllib.error
+    import urllib.request
+
+    base = os.environ.get("AUTOPOSTER_API_BASE", "https://s4l.ai").rstrip("/")
+    try:
+        req = urllib.request.Request(base, method="HEAD")
+        urllib.request.urlopen(req, timeout=timeout)
+        return True
+    except urllib.error.HTTPError:
+        return True  # server answered; network is up
+    except Exception:
+        return False
+
+
 BATCH_PROGRESSION_MIN_BATCHES = 5
 BATCH_PROGRESSED_PHASES = {"phase2b-gen", "phase2b-post"}
 
@@ -348,6 +404,30 @@ def _report_queue_health_sample(
 
 
 def main() -> int:
+    now = time.time()
+    st = _read_state()
+
+    # Sleep detection: launchd skips ticks while the host is suspended, so a
+    # wall-clock gap between this tick and the previous one of >= 3 intervals
+    # means the box slept (see the S4L-4B block by the constants above).
+    last_tick_at = st.get("last_tick_at")
+    last_sleep_gap_at = st.get("last_sleep_gap_at")
+    if last_tick_at is not None:
+        tick_gap = now - float(last_tick_at)
+        if tick_gap > SLEEP_GAP_SECONDS:
+            last_sleep_gap_at = now
+            sys.stderr.write(
+                f"[stall-watch] tick gap {int(tick_gap)}s (> {SLEEP_GAP_SECONDS}s) — "
+                "host was asleep/off; treating stall signals as sleep-tainted for "
+                f"{SLEEP_GAP_RECENT_SECONDS}s\n"
+            )
+    sleep_gap_recent = bool(
+        last_sleep_gap_at is not None
+        and (now - float(last_sleep_gap_at)) < SLEEP_GAP_RECENT_SECONDS
+    )
+
+    pending = _pending_count()
+    running = _running_count()
     age = _oldest_pending_age()
     run_age = _oldest_running_age()
     timeouts = _consecutive_timeouts()
@@ -362,8 +442,16 @@ def main() -> int:
     # never claimed), (3) running-age (job claimed then wedged mid-run) — (3) is
     # the only one of the first three that catches a worker dying after it picked
     # up the job — (4) batches_stuck, the outcome-level backstop above.
+    # Latch sanity gate (S4L-4B): consecutive_timeouts is durable and only
+    # clears on a successful drain, so ONE timed-out enqueue keeps a box
+    # looking stalled for as long as no cycle runs — even with a provably idle
+    # queue (pending=0, running=0). A single timeout only counts when there is
+    # actual queued work to corroborate it; an idle-queue latch needs >= 2.
+    # NOTE: deliberately stricter than the menubar/_index.ts stall HINT
+    # (timeouts >= 1) — a UI hint may over-trigger, a fleet page must not.
+    timeouts_signal = timeouts >= 2 or (timeouts >= 1 and (pending > 0 or running > 0))
     stalled = configured and (
-        timeouts >= 1
+        timeouts_signal
         or (age is not None and age > STALL_SECONDS)
         or (run_age is not None and run_age > RUNNING_STALL_SECONDS)
         or batches_stuck
@@ -373,13 +461,17 @@ def main() -> int:
     # episode resets and a LATER real stall (orphaned routines) still alerts.
     if stalled and _recent_rate_limit():
         stalled = False
+    # Sleep suppression: right after a wake, the latch (and any pre-nap ages)
+    # predate the sleep, not a worker failure. Require corroboration by real
+    # queued work or the outcome-level backstop before calling it a stall.
+    if stalled and sleep_gap_recent and not (pending > 0 or running > 0 or batches_stuck):
+        stalled = False
 
     # Record this tick regardless of outcome — see _report_queue_health_sample.
     _report_queue_health_sample(
-        _pending_count(), _running_count(), timeouts, age, run_age, stalled, batches_stuck
+        pending, running, timeouts, age, run_age, stalled, batches_stuck
     )
 
-    st = _read_state()
     consecutive = int(st.get("consecutive", 0))
     alerted = bool(st.get("alerted", False))
     # first_seen_at: first check this episode looked stalled at all (predates
@@ -390,6 +482,10 @@ def main() -> int:
     first_seen_at = st.get("first_seen_at")
     alerted_at = st.get("alerted_at")
 
+    # Tick bookkeeping persisted on EVERY exit path — the sleep detector needs
+    # an unbroken last_tick_at chain even (especially) while healthy.
+    tick_state = {"last_tick_at": now, "last_sleep_gap_at": last_sleep_gap_at}
+
     if not stalled:
         # Recovered (or never stalled) -> reset the episode so the next stall pages.
         if consecutive or alerted:
@@ -397,7 +493,7 @@ def main() -> int:
                 total_duration = time.time() - float(first_seen_at)
                 paged_duration = (time.time() - float(alerted_at)) if alerted_at else None
                 _report_recovery(total_duration, paged_duration)
-            _write_state({"consecutive": 0, "alerted": False})
+        _write_state({**tick_state, "consecutive": 0, "alerted": False})
         return 0
 
     consecutive += 1
@@ -411,60 +507,86 @@ def main() -> int:
     # the fallback is the classic orphaned-routine case.
     wedged_inflight = run_age is not None and run_age > RUNNING_STALL_SECONDS
     if consecutive >= ALERT_AFTER and not alerted:
-        try:
-            sentry = _sentry()
-            sentry.init()
-            if wedged_inflight:
-                cause = (
-                    "a worker claimed a draft job and then died mid-run (claude -p child "
-                    "never came up / crashed)"
-                )
-                stall_shape = "inflight_wedged"
-            elif batches_stuck:
-                cause = (
-                    f"last {BATCH_PROGRESSION_MIN_BATCHES} twitter_batches all failed to "
-                    "reach phase2b-gen — drafting is not actually happening even if the "
-                    "queue-level counters look ambiguous"
-                )
-                stall_shape = "batches_not_progressing"
-            else:
-                cause = "scheduled-task routines likely orphaned — Claude Desktop account change?"
-                stall_shape = "not_draining"
-            # Our own staging/QA/dev boxes (identity.is_internal_install) get set
-            # up and rebuilt with nobody actively feeding the queue, which looks
-            # identical to a real stall on the signals above. Downgrade those to
-            # warning instead of error so they don't page as a customer incident
-            # (the digest only scans error/fatal) while still leaving a Sentry
-            # record if we ever need to look one up by hand.
-            is_internal = identity.is_internal_install()
-            sentry.capture_message(
-                "social-autoposter autopilot stalled: draft jobs are not being "
-                f"drained ({cause}). producer consecutive timeouts={timeouts}, "
-                f"oldest pending job age={age_str}, oldest in-flight (running) job "
-                f"age={run_age_str}, sustained {consecutive} checks.",
-                level=("warning" if is_internal else "error"),
-                tags={
-                    "component": "autopilot",
-                    "issue": "stall",
-                    "stall_shape": stall_shape,
-                    "consecutive_timeouts": str(timeouts),
-                    "oldest_pending_age_s": str(int(age)) if age is not None else "",
-                    "oldest_running_age_s": str(int(run_age)) if run_age is not None else "",
-                    "batches_stuck": str(batches_stuck),
-                    "internal_install": str(is_internal),
-                },
-            )
-            sentry.flush()
-        except Exception:
-            # No Sentry (helper/SDK missing) -> at least leave a local breadcrumb.
+        if not _api_reachable():
+            # No network: an offline box is a different, self-healing condition,
+            # the page would misattribute it to the worker (and the event can't
+            # ship anyway). Keep the episode counting so a stall that survives
+            # the outage still pages the tick connectivity returns.
             sys.stderr.write(
-                f"[stall-watch] autopilot stalled (timeouts={timeouts}, "
-                f"pending_age={age_str}, running_age={run_age_str}) but Sentry report failed\n"
+                f"[stall-watch] stall persisted {consecutive} checks but the API is "
+                "unreachable (box offline?); deferring the page until network returns\n"
             )
-        alerted = True
-        alerted_at = time.time()
+        else:
+            try:
+                sentry = _sentry()
+                sentry.init()
+                if wedged_inflight:
+                    cause = (
+                        "a worker claimed a draft job and then died mid-run (claude -p child "
+                        "never came up / crashed)"
+                    )
+                    stall_shape = "inflight_wedged"
+                elif batches_stuck:
+                    cause = (
+                        f"last {BATCH_PROGRESSION_MIN_BATCHES} twitter_batches all failed to "
+                        "reach phase2b-gen — drafting is not actually happening even if the "
+                        "queue-level counters look ambiguous"
+                    )
+                    stall_shape = "batches_not_progressing"
+                elif _worker_ran_recently():
+                    # On-disk transcripts prove the worker routines ARE firing, so
+                    # this cannot be the orphaned-routines shape (S4L-4B paged with
+                    # exactly that bogus cause while the registry sample showed the
+                    # task had run seconds earlier).
+                    cause = (
+                        "producer timeout latch, but worker-task transcripts show recent "
+                        "runs — routines are firing; suspect a transient enqueue timeout"
+                        + (" or a host sleep gap" if sleep_gap_recent else "")
+                        + ", NOT orphaned routines"
+                    )
+                    stall_shape = "latch_worker_alive"
+                else:
+                    cause = "scheduled-task routines likely orphaned — Claude Desktop account change?"
+                    stall_shape = "not_draining"
+                # Our own staging/QA/dev boxes (identity.is_internal_install) get set
+                # up and rebuilt with nobody actively feeding the queue, which looks
+                # identical to a real stall on the signals above. Downgrade those to
+                # warning instead of error so they don't page as a customer incident
+                # (the digest only scans error/fatal) while still leaving a Sentry
+                # record if we ever need to look one up by hand.
+                is_internal = identity.is_internal_install()
+                sentry.capture_message(
+                    "social-autoposter autopilot stalled: draft jobs are not being "
+                    f"drained ({cause}). producer consecutive timeouts={timeouts}, "
+                    f"oldest pending job age={age_str}, oldest in-flight (running) job "
+                    f"age={run_age_str}, sustained {consecutive} checks.",
+                    level=("warning" if is_internal else "error"),
+                    tags={
+                        "component": "autopilot",
+                        "issue": "stall",
+                        "stall_shape": stall_shape,
+                        "consecutive_timeouts": str(timeouts),
+                        "oldest_pending_age_s": str(int(age)) if age is not None else "",
+                        "oldest_running_age_s": str(int(run_age)) if run_age is not None else "",
+                        "batches_stuck": str(batches_stuck),
+                        "internal_install": str(is_internal),
+                        "pending": str(pending),
+                        "running": str(running),
+                        "recent_sleep_gap": str(sleep_gap_recent),
+                    },
+                )
+                sentry.flush()
+            except Exception:
+                # No Sentry (helper/SDK missing) -> at least leave a local breadcrumb.
+                sys.stderr.write(
+                    f"[stall-watch] autopilot stalled (timeouts={timeouts}, "
+                    f"pending_age={age_str}, running_age={run_age_str}) but Sentry report failed\n"
+                )
+            alerted = True
+            alerted_at = time.time()
 
     _write_state({
+        **tick_state,
         "consecutive": consecutive,
         "alerted": alerted,
         "first_seen_at": first_seen_at,

package/scripts/cdp_ready_check.py

@@ -0,0 +1,94 @@
+#!/usr/bin/env python3
+"""Real CDP readiness probe for the harness Chrome.
+
+Exit 0 when a full Playwright connect_over_cdp handshake completes against the
+given CDP URL, 1 when it does not. /json/version alone is a LIVENESS check: a
+wedged Chrome (process alive, HTTP answering, websocket upgrade completing,
+but the browser loop never servicing the CDP session) passes it, and every
+downstream attach then eats Playwright's 180s default timeout while holding
+the browser lock (S4L-4H, Karol 2026-07-11; identical wedge locally 2026-07-09,
+twice, same Chrome instance both times).
+
+Usage: cdp_ready_check.py [CDP_URL] [TIMEOUT_MS]
+
+Prints a one-line JSON verdict to stdout so the caller can persist it
+(twitter-backend.sh writes it to skill/logs/cdp-health.json, which
+memory_snapshot.py carries onto the per-minute heartbeat sample).
+
+Falls back to an HTTP-only probe when playwright is not importable under the
+invoking interpreter, so a bare python3 caller degrades to the legacy
+liveness behavior instead of hard-failing.
+"""
+import json
+import sys
+import time
+
+
+def main() -> int:
+    url = (sys.argv[1] if len(sys.argv) > 1 else "http://127.0.0.1:9555").rstrip("/")
+    timeout_ms = int(sys.argv[2]) if len(sys.argv) > 2 else 8000
+    t0 = time.time()
+    try:
+        from playwright.sync_api import sync_playwright
+    except Exception:
+        import urllib.request
+        try:
+            # ProxyHandler({}): loopback CDP must never route through a proxy.
+            # macOS system proxy settings leak into urllib's default opener, and
+            # a box-wide forwarder 403s 127.0.0.1 probes (2026-07-13 root cause
+            # of the "wedged Chrome" misdiagnosis).
+            opener = urllib.request.build_opener(urllib.request.ProxyHandler({}))
+            opener.open(f"{url}/json/version", timeout=3)
+            print(json.dumps({"ready": True, "mode": "http-only"}))
+            return 0
+        except Exception as e:
+            print(json.dumps({
+                "ready": False, "mode": "http-only", "error": str(e)[:120],
+            }))
+            return 1
+    try:
+        with sync_playwright() as p:
+            browser = p.chromium.connect_over_cdp(url, timeout=timeout_ms)
+            n_contexts = len(browser.contexts)
+            # Renderer-liveness sweep (2026-07-14). A tab whose RENDERER
+            # crashed ("Aw, Snap", error code 5) keeps its normal title/url in
+            # every CDP listing and the browser-level handshake stays green,
+            # so it sat visibly dead for 20+ minutes with nothing entitled to
+            # touch it — below the wedge detector (browser-level) and the
+            # stall guard (scan-progress-level). Probe each page with a
+            # trivial evaluate; on failure reload the tab IN PLACE, which
+            # spawns a fresh renderer. No kill, no new window, no focus
+            # change. Best-effort: revival must never fail the readiness
+            # verdict the wedge gate depends on.
+            revived = 0
+            for ctx in browser.contexts:
+                for page in ctx.pages:
+                    try:
+                        page.set_default_timeout(4000)
+                        page.evaluate("1")
+                    except Exception:
+                        try:
+                            page.reload(timeout=15000, wait_until="commit")
+                            revived += 1
+                        except Exception:
+                            pass
+            browser.close()
+        out = {
+            "ready": True, "mode": "cdp", "contexts": n_contexts,
+            "elapsed_s": round(time.time() - t0, 2),
+        }
+        if revived:
+            out["revived"] = revived
+        print(json.dumps(out))
+        return 0
+    except Exception as e:
+        print(json.dumps({
+            "ready": False, "mode": "cdp",
+            "elapsed_s": round(time.time() - t0, 2),
+            "error": str(e)[:200].replace("\n", " "),
+        }))
+        return 1
+
+
+if __name__ == "__main__":
+    raise SystemExit(main())

package/scripts/engage_twitter_helper.py

@@ -144,6 +144,59 @@ def _render_media_block(media) -> str:
     )
 
 
+def _build_chain_block(row) -> str:
+    """Conversation chain reconstructed from replies.parent_reply_id linkage.
+
+    Walks ancestors bottom-up via GET /api/v1/replies/:id and renders the
+    chain root-first, each hop showing the inbound comment and (when we
+    responded) our reply. Empty string when the row has no parent linkage:
+    the root post itself already rides PENDING_DATA via the posts JOIN
+    (our_content / thread_title), so a chain block would add nothing.
+
+    Like counterparty_history_block, the block is self-titled and lands
+    inline in PENDING_DATA — no shell-side prompt change needed.
+    """
+    parent_id = row.get("parent_reply_id")
+    if not parent_id:
+        return ""
+    hops = []
+    seen = set()
+    cur = parent_id
+    for _ in range(10):
+        if not cur or cur in seen:
+            break
+        seen.add(cur)
+        try:
+            resp = api_get(f"/api/v1/replies/{cur}")
+        except Exception:
+            break
+        r = (resp.get("data") or {}).get("reply") or {}
+        if not r:
+            break
+        hops.append(r)
+        cur = r.get("parent_reply_id")
+    if not hops:
+        return ""
+
+    def _one_line(text):
+        return " ".join((text or "").split())
+
+    lines = [
+        "## Conversation chain (reconstructed from our DB; root first — "
+        "the row you are drafting for replies to the LAST message)"
+    ]
+    for r in reversed(hops):
+        lines.append(f"@{r.get('their_author') or '?'}: {_one_line(r.get('their_content'))}")
+        ours = _one_line(r.get("our_reply_content"))
+        if ours:
+            lines.append(f"  our reply: {ours}")
+    lines.append(
+        f"@{row.get('their_author') or '?'}: {_one_line(row.get('their_content'))}"
+        "   <- you are replying to this"
+    )
+    return "\n".join(lines)
+
+
 def cmd_pending_data(batch_size: int) -> int:
     try:
         from account_resolver import resolve as _resolve_account  # noqa: WPS433
@@ -173,38 +226,50 @@ def cmd_pending_data(batch_size: int) -> int:
     # top slot then and get enriched.
     ENRICH_TOP_N = 60
     history_blocks = [""] * len(rows)
+    chain_blocks = [""] * len(rows)
     try:
         from concurrent.futures import ThreadPoolExecutor
         from counterparty_history import get_counterparty_history_block
 
         def _enrich(r):
             author = r.get("their_author")
-            if not author:
-                return ""
+            history = ""
+            if author:
+                try:
+                    _disengage, history = get_counterparty_history_block(
+                        platform="x",
+                        author=author,
+                        current_post_id=r.get("post_id"),
+                        current_reply_id=r.get("id"),
+                    )
+                    history = history or ""
+                except Exception as e:
+                    print(
+                        f"[engage_twitter_helper] counterparty_history failed "
+                        f"for @{author}: {e}",
+                        file=sys.stderr,
+                    )
             try:
-                _disengage, block = get_counterparty_history_block(
-                    platform="x",
-                    author=author,
-                    current_post_id=r.get("post_id"),
-                    current_reply_id=r.get("id"),
-                )
-                return block or ""
+                chain = _build_chain_block(r)
             except Exception as e:
                 print(
-                    f"[engage_twitter_helper] counterparty_history failed "
-                    f"for @{author}: {e}",
+                    f"[engage_twitter_helper] chain block failed "
+                    f"for reply {r.get('id')}: {e}",
                     file=sys.stderr,
                 )
-                return ""
+                chain = ""
+            return (history, chain)
 
         top_rows = rows[:ENRICH_TOP_N]
         with ThreadPoolExecutor(max_workers=8) as ex:
-            for idx, block in enumerate(ex.map(_enrich, top_rows)):
-                history_blocks[idx] = block
+            for idx, (history, chain) in enumerate(ex.map(_enrich, top_rows)):
+                history_blocks[idx] = history
+                chain_blocks[idx] = chain
         non_empty = sum(1 for b in history_blocks if b)
+        chains_non_empty = sum(1 for b in chain_blocks if b)
         print(
-            f"[engage_twitter_helper] counterparty_history enriched "
-            f"{len(top_rows)}/{len(rows)} rows ({non_empty} with non-empty block)",
+            f"[engage_twitter_helper] enriched {len(top_rows)}/{len(rows)} rows "
+            f"(history={non_empty}, chain={chains_non_empty} non-empty)",
             file=sys.stderr,
         )
     except Exception as e:
@@ -215,7 +280,7 @@ def cmd_pending_data(batch_size: int) -> int:
         )
 
     out = []
-    for r, history_block in zip(rows, history_blocks):
+    for r, history_block, chain_block in zip(rows, history_blocks, chain_blocks):
         out.append({
             "id": r.get("id"),
             "platform": r.get("platform"),
@@ -231,6 +296,7 @@ def cmd_pending_data(batch_size: int) -> int:
             "is_our_original_post": int(r.get("is_our_original_post") or 0),
             "project_name": r.get("project_name"),
             "counterparty_history_block": history_block,
+            "conversation_chain_block": chain_block,
             "their_media_block": _render_media_block(r.get("their_media")),
         })
     # json_agg(...) returns null when the array is empty; engage-twitter.sh's