@m13v/s4l 1.7.6-rc.35 → 1.7.6-rc.37

package/bin/cli.js

@@ -434,19 +434,43 @@ function installBrowserHarness() {
     // we don't control the upstream repo. If it stops applying, upstream has
     // either merged the fix (detected; fine) or refactored (warn); never fail
     // the install over it.
-    const harnessPatch = path.join(PKG_ROOT, 'scripts', 'patches', 'browser-harness-loopback-cdp-proxy.patch');
-    if (fs.existsSync(harnessPatch)) {
-      const chk = spawnSync('git', ['-C', harnessDir, 'apply', '--check', harnessPatch], { stdio: 'pipe' });
+    // Vendored fixes applied on top of the pin (we don't control upstream).
+    // Each: patch file + a sentinel (file, substring) that means "already
+    // present" (upstream merged it, or we applied it) so a non-applying patch
+    // only warns when the fix is genuinely absent. NEVER fail the install.
+    const vendoredPatches = [
+      {
+        file: 'browser-harness-loopback-cdp-proxy.patch',
+        sentinelFile: path.join('src', 'browser_harness', 'admin.py'),
+        sentinelStr: 'cdp_urlopen',
+        label: 'loopback-proxy',
+        absentWarn: 'CDP probes may 403 behind a system proxy',
+      },
+      {
+        // Suppress OS-focus-stealing Target.activateTarget on offscreen
+        // automation harnesses (twitter/reddit/linkedin) — the shared fix for
+        // the 2026-07 Chrome focus-pops. See helpers.py _is_offscreen_harness.
+        file: 'browser-harness-focus-and-observability.patch',
+        sentinelFile: path.join('src', 'browser_harness', 'helpers.py'),
+        sentinelStr: '_is_offscreen_harness',
+        label: 'focus-suppression + tab-event observability',
+        absentWarn: 'harness Chrome may steal OS focus on every tab switch',
+      },
+    ];
+    for (const p of vendoredPatches) {
+      const patchPath = path.join(PKG_ROOT, 'scripts', 'patches', p.file);
+      if (!fs.existsSync(patchPath)) continue;
+      const chk = spawnSync('git', ['-C', harnessDir, 'apply', '--check', patchPath], { stdio: 'pipe' });
       if (chk.status === 0) {
-        spawnSync('git', ['-C', harnessDir, 'apply', harnessPatch], { stdio: 'inherit' });
-        console.log('    applied loopback-proxy patch to browser-harness');
+        spawnSync('git', ['-C', harnessDir, 'apply', patchPath], { stdio: 'inherit' });
+        console.log(`    applied ${p.label} patch to browser-harness`);
       } else {
-        let fixedUpstream = false;
+        let present = false;
         try {
-          fixedUpstream = fs.readFileSync(path.join(harnessDir, 'src', 'browser_harness', 'admin.py'), 'utf-8').includes('cdp_urlopen');
+          present = fs.readFileSync(path.join(harnessDir, p.sentinelFile), 'utf-8').includes(p.sentinelStr);
         } catch { /* file moved — fall through to the warning */ }
-        if (!fixedUpstream) {
-          console.warn('    WARNING: browser-harness loopback-proxy patch no longer applies and the fix is absent upstream; CDP probes may 403 behind a system proxy.');
+        if (!present) {
+          console.warn(`    WARNING: browser-harness ${p.label} patch no longer applies and the fix is absent upstream; ${p.absentWarn}.`);
         }
       }
     }

package/mcp/dist/telemetry.js

@@ -139,12 +139,21 @@ export function checkVersionChange() {
     }
     const isFirstBoot = from === null;
     const changed = !isFirstBoot && from !== to;
-    try {
-        fs.mkdirSync(snapshotStateDir(), { recursive: true });
-        fs.writeFileSync(lastVersionPath(), JSON.stringify({ version: to, seen_at: new Date().toISOString() }), "utf-8");
-    }
-    catch {
-        /* best-effort; a failed write just means the next boot re-detects from "from: null" */
+    // Write ONLY when the version actually changed (or first boot / unreadable
+    // file). The old rewrite-every-boot kept the file's timestamp meaning "when
+    // the server last booted", which reads like an install time and misled a
+    // 2026-07-18 investigation into concluding an update hadn't applied. With
+    // the guard, running_since is exactly what it says: when THIS version first
+    // booted here. Same-version boots leave the file untouched, so detection
+    // semantics are unchanged (the file already holds the current version).
+    if (changed || isFirstBoot) {
+        try {
+            fs.mkdirSync(snapshotStateDir(), { recursive: true });
+            fs.writeFileSync(lastVersionPath(), JSON.stringify({ version: to, running_since: new Date().toISOString() }), "utf-8");
+        }
+        catch {
+            /* best-effort; a failed write just means the next boot re-detects from "from: null" */
+        }
     }
     if (changed) {
         console.error(`[social-autoposter-mcp] self-update detected: ${from} -> ${to}`);

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.6-rc.35",
-  "installedAt": "2026-07-18T02:51:25.957Z"
+  "version": "1.7.6-rc.37",
+  "installedAt": "2026-07-18T16:22:24.449Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.6-rc.35",
+  "version": "1.7.6-rc.37",
   "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.6-rc.35",
+  "version": "1.7.6-rc.37",
   "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.6-rc.35",
+  "version": "1.7.6-rc.37",
   "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/patches/browser-harness-focus-and-observability.patch

@@ -0,0 +1,130 @@
+diff --git a/src/browser_harness/helpers.py b/src/browser_harness/helpers.py
+index 2014887..2887b3f 100644
+--- a/src/browser_harness/helpers.py
++++ b/src/browser_harness/helpers.py
+@@ -157,6 +157,7 @@ def _has_return_statement(expression):
+ 
+ # --- navigation / page ---
+ def goto_url(url):
++    _tab_event("goto_url", f"url={url[:90]}")
+     r = cdp("Page.navigate", url=url)
+     if os.environ.get("BH_DOMAIN_SKILLS") != "1":
+         return r
+@@ -295,12 +296,55 @@ def current_tab():
+     r = _send({"meta": "current_tab"})
+     return {"targetId": r["targetId"], "url": r["url"], "title": r["title"]}
+ 
++def _tab_event(fn, detail=""):
++    """One stderr line per tab-mutating CDP call, stamped with the entry
++    script. These calls (Target.createTarget / activateTarget / closeTarget)
++    can ACTIVATE Chrome on macOS — raise the window and steal app focus. The
++    S4L menubar's browser-foreground telemetry (s4l_browser_foreground.py,
++    [browser-foreground] lines in menubar.err.log) records every activation
++    with a timestamp; this line is the other half of the correlation: WHICH
++    harness call fired at that moment, from WHICH pipeline step. Added
++    2026-07-14 to attribute chronic 1-5x/hour focus steals."""
++    try:
++        ts = time.strftime("%Y-%m-%dT%H:%M:%SZ", time.gmtime())
++        entry = os.path.basename(sys.argv[0] or "?") if sys.argv else "?"
++        print(
++            f"[bh_tab_event] {ts} fn={fn} entry={entry} "
++            f"bu={os.environ.get('BU_NAME', '?')} {detail}",
++            file=sys.stderr, flush=True,
++        )
++    except Exception:
++        pass
++
++
+ def _mark_tab():
+     """Prepend horse emoji to tab title so the user can see which tab the agent controls."""
+     try: cdp("Runtime.evaluate", expression="if(!document.title.startsWith('\U0001F434'))document.title='\U0001F434 '+document.title")
+     except Exception: pass
+ 
+-def switch_tab(target):
++def _is_offscreen_harness():
++    """True when this harness window is parked offscreen (BH_WINDOW_POS with a
++    negative coordinate), i.e. a background automation harness that must NEVER
++    steal the user's OS focus. The three S4L harnesses (twitter/reddit/linkedin)
++    all launch at y=-1032; interactive browsers sit onscreen (e.g. 100,100).
++    Cached; env is fixed for a process's life."""
++    global _OFFSCREEN_CACHE
++    try:
++        return _OFFSCREEN_CACHE
++    except NameError:
++        pass
++    off = False
++    try:
++        xy = os.environ.get("BH_WINDOW_POS", "")
++        if xy:
++            off = any(int(float(v)) < 0 for v in xy.split(",")[:2])
++    except Exception:
++        off = False
++    globals()["_OFFSCREEN_CACHE"] = off
++    return off
++
++
++def switch_tab(target, activate=None):
+     # Accept either a raw targetId string or the dict returned by current_tab() / list_tabs(),
+     # so `switch_tab(current_tab())` works without a manual ["targetId"] dance.
+     target_id = target.get("targetId") if isinstance(target, dict) else target
+@@ -308,18 +352,48 @@ def switch_tab(target):
+     # plus the trailing space = 3 code units, so slice(3) cleanly removes the prefix.
+     try: cdp("Runtime.evaluate", expression="if(document.title.startsWith('\U0001F434 '))document.title=document.title.slice(3)")
+     except Exception: pass
+-    cdp("Target.activateTarget", targetId=target_id)
++    _tab_event("switch_tab", f"target={target_id}")
++    # Target.activateTarget raises/focuses the OS window (2026-07-15: 7/7
++    # same-second harness_browser_foregrounded correlation) but is NOT needed
++    # for CDP automation — Page.captureScreenshot and Input.dispatchMouseEvent
++    # are session-scoped and the occlusion flags keep offscreen tabs painting.
++    # So on an offscreen automation harness (twitter/reddit/linkedin) skip it:
++    # this is the SINGLE shared fix for the reddit focus-pops that twitter had
++    # to work around per-caller. Callers wanting the old behavior pass
++    # activate=True; interactive (onscreen) harnesses still activate by default.
++    if activate is None:
++        activate = not _is_offscreen_harness()
++    if activate:
++        cdp("Target.activateTarget", targetId=target_id)
+     sid = cdp("Target.attachToTarget", targetId=target_id, flatten=True)["sessionId"]
+     _send({"meta": "set_session", "session_id": sid, "target_id": target_id})
+     _mark_tab()
+     return sid
+ 
+-def new_tab(url="about:blank"):
++def new_tab(url="about:blank", background=False):
+     # Always create blank, then goto: passing url to createTarget races with
+     # attach, so the brief about:blank is "complete" by the time the caller
+     # polls and wait_for_load() returns before navigation actually starts.
+-    tid = cdp("Target.createTarget", url="about:blank")["targetId"]
+-    switch_tab(tid)
++    #
++    # background=True creates the target without focusing it AND attaches
++    # without Target.activateTarget — activation is proven to raise/focus the
++    # Chrome window on macOS (2026-07-15: 7/7 same-second correlation with
++    # harness_browser_foregrounded). Recovery paths that mint a replacement
++    # tab for a wedged one must never pop the window.
++    # On an offscreen automation harness, ALWAYS create in background (no
++    # window raise) regardless of the caller's default — same rationale as
++    # switch_tab. This is what makes the reddit DM/engage flow (which calls
++    # new_tab(background=False) per destination) stop popping without touching
++    # every caller. Onscreen/interactive harnesses keep the requested behavior.
++    bg = background or _is_offscreen_harness()
++    _tab_event("new_tab", f"url={url} background={bg}")
++    tid = cdp("Target.createTarget", url="about:blank", background=bg)["targetId"]
++    if bg:
++        sid = cdp("Target.attachToTarget", targetId=tid, flatten=True)["sessionId"]
++        _send({"meta": "set_session", "session_id": sid, "target_id": tid})
++        _mark_tab()
++    else:
++        switch_tab(tid)
+     if url != "about:blank":
+         goto_url(url)
+     return tid
+@@ -330,6 +404,7 @@ def close_tab(target=None):
+     target_id = target.get("targetId") if isinstance(target, dict) else target
+     if target_id is None:
+         target_id = current_tab()["targetId"]
++    _tab_event("close_tab", f"target={target_id}")
+     cdp("Target.closeTarget", targetId=target_id)
+ 
+ 

package/scripts/post_github.py

@@ -85,20 +85,43 @@ def _emit_run_summary_oneshot():
         return
     _RUN_STATE["emitted"] = True
     elapsed = int(time.time() - _RUN_STATE["run_start"])
+    signaled = _RUN_STATE.get("signaled")
+    if signaled:
+        # A signal ended the run; surface it the same way run-github.sh's
+        # trap used to (failed>=1 + sigterm reason) so the dashboard still
+        # sees signal-killed cycles, now with accurate counters attached.
+        _RUN_STATE["failed"] = max(int(_RUN_STATE["failed"]), 1)
+    # Print the same "=== SUMMARY: elapsed=" marker main()'s happy path emits.
+    # run-github.sh's EXIT trap greps the cycle log for this marker to decide
+    # whether Python already wrote its own run_monitor row; before 2026-07-18
+    # every early exit (no candidates, cap=0, Claude failure) lacked the
+    # marker, so the trap double-logged each of those cycles as a spurious
+    # "failed=1 sigterm:1" row + a "possible silent failure" warning. With
+    # the marker printed here, the bash trap only fires when Python died
+    # without running atexit at all (SIGKILL, interpreter crash).
     try:
-        subprocess.run(
-            [
-                PYTHON, os.path.join(os.path.dirname(os.path.abspath(__file__)), "log_run.py"),
-                "--script", "post_github",
-                "--posted", str(_RUN_STATE["posted"]),
-                "--skipped", str(_RUN_STATE["skipped"]),
-                "--failed", str(_RUN_STATE["failed"]),
-                "--cost", f"{_RUN_STATE['cost']:.4f}",
-                "--elapsed", str(elapsed),
-            ],
-            timeout=15,
-            check=False,
+        suffix = f"(signal {signaled})" if signaled else "(safety-net)"
+        print(
+            f"=== SUMMARY: elapsed={elapsed}s "
+            f"posted={_RUN_STATE['posted']} failed={_RUN_STATE['failed']} "
+            f"=== {suffix}",
+            flush=True,
         )
+    except Exception:
+        pass
+    cmd = [
+        PYTHON, os.path.join(os.path.dirname(os.path.abspath(__file__)), "log_run.py"),
+        "--script", "post_github",
+        "--posted", str(_RUN_STATE["posted"]),
+        "--skipped", str(_RUN_STATE["skipped"]),
+        "--failed", str(_RUN_STATE["failed"]),
+        "--cost", f"{_RUN_STATE['cost']:.4f}",
+        "--elapsed", str(elapsed),
+    ]
+    if signaled:
+        cmd.extend(["--failure-reasons", "sigterm:1"])
+    try:
+        subprocess.run(cmd, timeout=15, check=False)
     except Exception:
         # Trap context: never raise from the safety net. Better to lose this
         # one summary line than to crash a shutdown sequence that might be
@@ -107,7 +130,9 @@ def _emit_run_summary_oneshot():
 
 
 def _signal_to_exit(signum, _frame):
-    # Convert the signal into a normal-looking exit so atexit fires.
+    # Record which signal ended us so the atexit summary can tag the run,
+    # then convert the signal into a normal-looking exit so atexit fires.
+    _RUN_STATE["signaled"] = signum
     sys.exit(128 + signum)
 
 
@@ -215,10 +240,14 @@ KNOWN_BOT_LOGINS = {
 
 
 def _is_bot_login(login):
+    # gh's GraphQL surfaces GitHub App actors with an "app/" prefix
+    # (app/github-actions, app/renovate, sometimes bare "app/"); seen live in
+    # the 2026-07-18 phase-1 logs. Match the prefix, the known-login set, and
+    # the [bot]/-bot suffixes.
     l = (login or "").lower()
     return bool(l) and (
-        l in KNOWN_BOT_LOGINS or l.endswith("[bot]") or l.endswith("-bot")
-        or l.endswith("bot]")
+        l.startswith("app/") or l in KNOWN_BOT_LOGINS or l.endswith("[bot]")
+        or l.endswith("-bot") or l.endswith("bot]")
     )
 
 
@@ -235,6 +264,72 @@ def _our_github_handle(_memo={}):
     return _memo["h"]
 
 
+# ---------- github_candidates history (2026-07-18) ---------------------------
+# Per-candidate history mirroring the twitter/reddit candidates principle:
+# every discovered issue becomes a github_candidates row via /api/v1 (never
+# direct SQL), and every decision flips status with skip_stage + skip_reason.
+# Stages: gate_maintainer | gate_no_audience | gate_tiny_repo |
+# gate_maintainer_t1 | momentum_cut | claude | post_failed; posted rows get
+# status='posted' + post_id. All calls are best-effort: a candidates-API
+# outage must never block or slow the posting rail.
+
+def _cand_upsert(row):
+    try:
+        from http_api import api_post
+        api_post("/api/v1/github-candidates", {
+            "thread_url": row.get("url"),
+            "repo": row.get("repo"),
+            "issue_number": row.get("number"),
+            "thread_title": (row.get("title") or "")[:500],
+            "thread_author": row.get("author"),
+            "author_is_owner": bool(row.get("author_is_owner")),
+            "outside_participants": row.get("outside_participants"),
+            "repo_stars": row.get("repo_stars"),
+            "comment_count_t0": row.get("comment_count_t0"),
+            "reaction_count_t0": row.get("reaction_count_t0"),
+            "matched_project": row.get("matched_project"),
+            "search_topic": row.get("search_topic"),
+            "batch_id": os.environ.get("SA_CYCLE_ID"),
+        })
+    except Exception as e:
+        log(f"  WARNING: candidate upsert failed for {row.get('url')}: {e}")
+
+
+def _cand_mark_skipped(url, stage, reason=""):
+    try:
+        from http_api import api_patch
+        api_patch("/api/v1/github-candidates/by-thread-url", {
+            "thread_url": url, "action": "mark_skipped",
+            "skip_stage": stage, "skip_reason": str(reason or "")[:1000],
+        }, ok_on_404=True)
+    except Exception as e:
+        log(f"  WARNING: candidate mark_skipped failed for {url}: {e}")
+
+
+def _cand_set_t1(url, comment_count_t1, reaction_count_t1, delta):
+    try:
+        from http_api import api_patch
+        api_patch("/api/v1/github-candidates/by-thread-url", {
+            "thread_url": url, "action": "set_t1",
+            "comment_count_t1": comment_count_t1,
+            "reaction_count_t1": reaction_count_t1,
+            "delta_score": delta,
+        }, ok_on_404=True)
+    except Exception as e:
+        log(f"  WARNING: candidate set_t1 failed for {url}: {e}")
+
+
+def _cand_mark_posted(url, post_id=None):
+    try:
+        from http_api import api_patch
+        body = {"thread_url": url, "action": "mark_posted"}
+        if isinstance(post_id, int):
+            body["post_id"] = post_id
+        api_patch("/api/v1/github-candidates/by-thread-url", body, ok_on_404=True)
+    except Exception as e:
+        log(f"  WARNING: candidate mark_posted failed for {url}: {e}")
+
+
 def log(msg):
     print(f"[{datetime.now().strftime('%H:%M:%S')}] [post_github] {msg}", flush=True)
 
@@ -717,8 +812,17 @@ Return ONLY a single JSON object. No prose, no markdown fencing, no Bash calls:
     }}
   ],
   "skipped": [
-    {{ "url": "<issue url>", "reason": "<short reason; use 'low_relevance' when relevance < {min_relevance}>" }}
+    {{ "url": "<issue url>", "reason": "<code>: <one-line why>" }}
   ]
+
+For skip reasons, start with one snake_case code so the dashboard can
+aggregate, then a colon and a one-line specific why. Codes: low_relevance
+(relevance < {min_relevance}), restates_thread (your point is already in the
+issue/comments), owner_spec_ticket (owner's self-addressed work ticket),
+maintainer_direction (maintainer set direction), thin_audience (1 outside
+participant, nothing new to add), manufactured_expertise (would need fake
+experience), pitch_pileup (other commenters pitching tools), off_domain
+(would have to pivot topics), other (anything else).
 }}
 
 If, and ONLY if, none of the listed styles fits, you may invent one. Set
@@ -970,6 +1074,26 @@ def main():
         counts = gh_view_counts(repo, number)
         if not counts:
             continue
+        _owner, _name = repo.split("/", 1)
+        _stars = _repo_state(_owner, _name).get("stars")
+        # Record the sighting BEFORE the gates so gate skips become queryable
+        # history (github_candidates), not just log lines. Gate branches then
+        # flip the row to skipped with their stage.
+        _cand_url = counts["url"] or item.get("url")
+        _cand_upsert({
+            "url": _cand_url,
+            "repo": repo,
+            "number": number,
+            "title": counts["title"],
+            "author": counts["author"],
+            "author_is_owner": counts.get("author_is_owner"),
+            "outside_participants": counts.get("outside_participants"),
+            "repo_stars": _stars,
+            "comment_count_t0": counts["comment_count"],
+            "reaction_count_t0": counts["reaction_count"],
+            "matched_project": project_name,
+            "search_topic": item.get("search_topic"),
+        })
         # Maintainer-just-spoke gate. If the most recent comment is from someone
         # with push access (OWNER/MEMBER/COLLABORATOR), they are driving the
         # thread, so piling on reads as noise and risks LOW_QUALITY hide.
@@ -980,6 +1104,10 @@ def main():
                 f"(last={counts.get('last_commenter')}/"
                 f"{counts.get('last_comment_assoc')})"
             )
+            _cand_mark_skipped(
+                _cand_url, "gate_maintainer",
+                f"last={counts.get('last_commenter')}/"
+                f"{counts.get('last_comment_assoc')}")
             continue
         # Zero-audience gate. Nobody but the issue author (and bots) has ever
         # touched this thread, so a comment's only reader is the author's
@@ -993,13 +1121,15 @@ def main():
                 f"(author={counts.get('author')}, "
                 f"owner_authored={counts.get('author_is_owner')})"
             )
+            _cand_mark_skipped(
+                _cand_url, "gate_no_audience",
+                f"author={counts.get('author')}, "
+                f"owner_authored={counts.get('author_is_owner')}")
             continue
         # Tiny-repo audience floor. A repo with almost no stars has no
         # bystander audience reading its issues; require a real multi-person
         # discussion before engaging there. stars=None (fetch failed) passes:
         # fail open, the participant gate above already ran.
-        _owner, _name = repo.split("/", 1)
-        _stars = _repo_state(_owner, _name).get("stars")
         if (_stars is not None and _stars < STAR_FLOOR
                 and counts.get("outside_participants", 0) < 2):
             skipped_small_repo += 1
@@ -1008,6 +1138,10 @@ def main():
                 f"and thin discussion "
                 f"({counts.get('outside_participants')} outside participants)"
             )
+            _cand_mark_skipped(
+                _cand_url, "gate_tiny_repo",
+                f"{_stars} stars < {STAR_FLOOR}, "
+                f"{counts.get('outside_participants')} outside participants")
             continue
         candidates.append({
             "repo": repo,
@@ -1057,6 +1191,11 @@ def main():
                 f"during sleep (last={counts.get('last_commenter')}/"
                 f"{counts.get('last_comment_assoc')})"
             )
+            _cand_mark_skipped(
+                c["url"], "gate_maintainer_t1",
+                f"maintainer arrived during sleep: "
+                f"{counts.get('last_commenter')}/"
+                f"{counts.get('last_comment_assoc')}")
             continue
         c["comment_count_t1"] = counts["comment_count"]
         c["reaction_count_t1"] = counts["reaction_count"]
@@ -1068,6 +1207,8 @@ def main():
             c["comment_count_t0"], c["reaction_count_t0"],
             c["comment_count_t1"], c["reaction_count_t1"],
         )
+        _cand_set_t1(c["url"], c["comment_count_t1"], c["reaction_count_t1"],
+                     c["delta_score"])
         survivors.append(c)
     if skipped_maintainer_phase2:
         log(
@@ -1089,6 +1230,11 @@ def main():
     candidates.sort(key=lambda c: c["delta_score"], reverse=True)
     top = candidates[:CLAUDE_CANDIDATE_LIMIT]
     log(f"Phase 2b: showing Claude top {len(top)} by delta, cap = {cap}")
+    # Candidates below the top-N cut never reach Claude; record why.
+    for c in candidates[CLAUDE_CANDIDATE_LIMIT:]:
+        _cand_mark_skipped(
+            c["url"], "momentum_cut",
+            f"delta={c['delta_score']:.1f} below top {CLAUDE_CANDIDATE_LIMIT}")
 
     if cap <= 0:
         log("cap=0, nothing to post. Exiting.")
@@ -1175,6 +1321,11 @@ def main():
     if not ok:
         log(f"Claude FAILED: {output[:300]}")
         _RUN_STATE["failed"] = 1
+        # Marker line for run-github.sh's EXIT trap (see
+        # _emit_run_summary_oneshot): without it this branch was double-logged
+        # by the trap as a spurious sigterm:1 row.
+        log(f"=== SUMMARY: elapsed={int(time.time() - run_start)}s "
+            f"posted=0 failed=1 === (claude-failure)")
         subprocess.run([
             PYTHON, os.path.join(SCRIPTS, "log_run.py"),
             "--script", "post_github",
@@ -1191,6 +1342,18 @@ def main():
     posts = decisions.get("posts", []) or []
     skipped = decisions.get("skipped", []) or []
     log(f"Claude picked {len(posts)}, skipped {len(skipped)}")
+    # Full-funnel visibility (2026-07-18): phase-1 gate skips already log one
+    # line each; do the same for Claude's judgment-level skips so the cycle
+    # log answers "why didn't we post" end to end. Mirrors the twitter
+    # principle (twitter_candidates.skip_reason) at log level; GitHub has no
+    # candidates table, so the cycle log is the system of record here.
+    for _s in skipped:
+        if isinstance(_s, dict):
+            _s_url = _s.get("url") or _s.get("thread_url") or "?"
+            _s_reason = str(_s.get("reason") or "(no reason given)")
+            log(f"  claude-skip {_s_url}: {_s_reason[:220]}")
+            if _s_url != "?":
+                _cand_mark_skipped(_s_url, "claude", _s_reason)
 
     # Relevance gate. Anything Claude scored below MIN_RELEVANCE goes to the
     # skipped bucket, NOT posted, regardless of how confident the comment_text
@@ -1206,8 +1369,8 @@ def main():
             relevance_dropped.append({
                 "url": d.get("thread_url", ""),
                 "reason": (
-                    f"low_relevance (relevance={rel}, "
-                    f"rationale={(d.get('relevance_rationale') or '').strip()[:120]})"
+                    f"low_relevance: relevance={rel}, "
+                    f"rationale={(d.get('relevance_rationale') or '').strip()[:120]}"
                 ),
             })
         else:
@@ -1219,6 +1382,8 @@ def main():
         )
         for r in relevance_dropped:
             log(f"  drop {r['url']}: {r['reason']}")
+            if r.get("url"):
+                _cand_mark_skipped(r["url"], "claude", r["reason"])
     skipped.extend(relevance_dropped)
     posts = kept_posts
 
@@ -1257,6 +1422,9 @@ def main():
             log(f"SKIP: bad URL or empty text: {thread_url}")
             failed += 1
             _RUN_STATE["failed"] = failed
+            if thread_url:
+                _cand_mark_skipped(thread_url, "post_failed",
+                                   "bad URL or empty text")
             continue
 
         # URL-wrap before sending to GitHub. project for wrapping is the
@@ -1310,6 +1478,8 @@ def main():
             log(f"POST FAILED: {url_or_err}")
             failed += 1
             _RUN_STATE["failed"] = failed
+            _cand_mark_skipped(thread_url, "post_failed",
+                               str(url_or_err)[:300])
             time.sleep(3)
             continue
 
@@ -1343,6 +1513,7 @@ def main():
         _RUN_STATE["failed"] = failed
         _RUN_STATE["skipped"] = len(skipped)
         log(f"POSTED: {url_or_err or 'ok'}")
+        _cand_mark_posted(thread_url, new_post_id)
 
         # ---- Optional self-reply with ONE github blob URL ------------------
         # Restored 2026-05-17 after the April 13 over-correction stripped
@@ -1423,6 +1594,18 @@ def main():
 
         time.sleep(3)
 
+    # Any candidate shown to Claude but absent from BOTH posts and skipped is
+    # an undocumented drop (the prompt asks for every candidate to appear in
+    # one bucket, but models drift); close its row so nothing stays pending.
+    _decided_urls = {(d.get("thread_url") or "").strip() for d in posts}
+    _decided_urls |= {
+        (s.get("url") or s.get("thread_url") or "").strip()
+        for s in skipped if isinstance(s, dict)
+    }
+    for c in top:
+        if (c.get("url") or "").strip() not in _decided_urls:
+            _cand_mark_skipped(c["url"], "claude", "not_mentioned_in_decisions")
+
     # Clean up the generation_trace temp file. By this point every post
     # that landed has its trace persisted to posts.generation_trace JSONB,
     # so the on-disk JSON is redundant. macOS would eventually purge
@@ -1443,7 +1626,23 @@ def main():
     _RUN_STATE["failed"] = failed
     _RUN_STATE["skipped"] = len(skipped)
     _RUN_STATE["cost"] = usage["cost_usd"]
-    subprocess.run([
+    # Aggregate Claude's skip codes into the same `skip_reasons=code:count`
+    # segment run-twitter-cycle.sh ships, so the dashboard's yellow
+    # "skipped: <reason>" pills work for github runs too. The code is the
+    # snake_case token before the first ':' in each skip reason (see the
+    # prompt's skip-code list); free-form text degrades to a slug.
+    _skip_counts = {}
+    for _s in skipped:
+        _r = (_s.get("reason") if isinstance(_s, dict) else str(_s)) or "unspecified"
+        _code = re.sub(r"[^a-z0-9_]+", "_",
+                       str(_r).split(":", 1)[0].strip().lower()).strip("_")[:40]
+        _code = _code or "unspecified"
+        _skip_counts[_code] = _skip_counts.get(_code, 0) + 1
+    _skip_arg = ",".join(
+        f"{k}:{v}" for k, v in
+        sorted(_skip_counts.items(), key=lambda kv: -kv[1])[:8]
+    )
+    _cmd = [
         PYTHON, os.path.join(SCRIPTS, "log_run.py"),
         "--script", "post_github",
         "--posted", str(posted),
@@ -1451,7 +1650,10 @@ def main():
         "--failed", str(failed),
         "--cost", f"{usage['cost_usd']:.4f}",
         "--elapsed", f"{int(total_elapsed)}",
-    ])
+    ]
+    if _skip_arg:
+        _cmd.extend(["--skip-reasons", _skip_arg])
+    subprocess.run(_cmd)
     _RUN_STATE["emitted"] = True