@m13v/s4l 1.7.12-rc.8 → 1.7.12-rc.9

package/mcp/dist/index.js

@@ -3832,8 +3832,8 @@ async function autopilotLoaded() {
 // fires every minute, claims ONE job, runs the pipeline's own prompt as its
 // Claude turn, writes the result back, and stops.
 // ===========================================================================
-const QUEUE_WORKER_PROMPT_VERSION = 9; // v9 (2026-07-17): poll window widened 240s -> 900s (see QUEUE_WORKER_POLL_SECONDS); version bump forces the prompt refresh that carries the new --wait-seconds onto existing installs. v8: worker polls internally (claude_job.py next --wait-seconds) instead of single-shot check-then-die. Empirically verified (2026-07-06) that a single long-running Bash call survives well past the host's ~90s between-tool-call inactivity kill — that timer only fires on MODEL silence, not on one in-flight tool call — so one Bash call can safely poll for QUEUE_WORKER_POLL_SECONDS before giving up. This cuts the every-minute spin-up-empty-then-die husk cycle down to roughly one session per poll window instead of one per cron tick. v7: universal type-blind worker. ONE task claims `--type any`; per-type execution notes (e.g. the v6 incremental-draft pacing for twitter-prep) moved into claude_job.py TYPE_TO_WORKER_NOTES and ride the prompt sidecar, so the worker prompt never mentions job types. Legacy per-type tasks get this same body on refresh and become interchangeable universal workers.
-// v10 (PLANNED, NOT IMPLEMENTED): delegate the actual drafting to a fresh
+const QUEUE_WORKER_PROMPT_VERSION = 10; // v10 (2026-10-29): poll window 900s -> 540s so one `next` call fits inside the Bash tool's 600s default timeout, self-reap disabled (S4L_WORKER_SELF_REAP=0 on every claude_job call), and the session ends by archiving itself instead of a SIGTERM. v9 (2026-07-17): poll window widened 240s -> 900s; version bump forces the prompt refresh that carries the new --wait-seconds onto existing installs. v8: worker polls internally (claude_job.py next --wait-seconds) instead of single-shot check-then-die. Empirically verified (2026-07-06) that a single long-running Bash call survives well past the host's ~90s between-tool-call inactivity kill — that timer only fires on MODEL silence, not on one in-flight tool call — so one Bash call can safely poll for QUEUE_WORKER_POLL_SECONDS before giving up. This cuts the every-minute spin-up-empty-then-die husk cycle down to roughly one session per poll window instead of one per cron tick. v7: universal type-blind worker. ONE task claims `--type any`; per-type execution notes (e.g. the v6 incremental-draft pacing for twitter-prep) moved into claude_job.py TYPE_TO_WORKER_NOTES and ride the prompt sidecar, so the worker prompt never mentions job types. Legacy per-type tasks get this same body on refresh and become interchangeable universal workers.
+// v11 (PLANNED, NOT IMPLEMENTED): delegate the actual drafting to a fresh
 // sub-agent per claimed job (claim -> delegate -> wait -> claim next, looped
 // within one continuous worker session) instead of drafting inline. Validated
 // via throwaway probe tasks 2026-07-07/08 (10 loop iterations, ~210s of real
@@ -3842,10 +3842,19 @@ const QUEUE_WORKER_PROMPT_VERSION = 9; // v9 (2026-07-17): poll window widened 2
 // notification) or the host kills the whole parent+child chain in 1-3 min.
 // Never live-fire tested against a real production job. Full design, what's
 // validated vs not, and the implementation steps: docs/queue-worker-delegation-plan.md
-// Bump this constant to 10 only once that plan is actually implemented.
+// Bump this constant to 11 only once that plan is actually implemented.
 const QUEUE_WORKER_PROMPT_MARKER = "s4l_queue_worker_prompt_version";
 // How long ONE `next --wait-seconds` call polls before giving up and exiting.
-// 900s (15 min, per Matthew 2026-07-17, up from 240s): sits AT the single-
+// 540s (9 min, 2026-10-29, down from 900s): MUST stay below the Bash tool's
+// 600s default timeout. Measured on 2026-10-29 in Claude Desktop 4.29: the
+// 900s poll hit the 600s tool timeout on every empty cycle (81 of 106 runs
+// that day), the CLI then re-emitted a ~200KB prompt snapshot (a 7s
+// main-thread stall in the app), the poller kept running as an orphaned
+// background task for the remaining 300s, and its self-reap SIGTERM cost one
+// or two more 7s stalls plus an exit-143 re-attach. With the poll inside the
+// tool timeout the call returns normally, nothing is orphaned, and the worker
+// archives itself (step 5 of the prompt) at zero measured cost.
+// Earlier rationale (900s, per Matthew 2026-07-17, up from 240s): sits AT the single-
 // Bash-call survival ceiling verified live on 2026-07-06 (the host's ~90s
 // inactivity kill fires only on model silence, and one in-flight tool call
 // survived a full 900s probe). This covers the ~8min average real job
@@ -3861,7 +3870,7 @@ const QUEUE_WORKER_PROMPT_MARKER = "s4l_queue_worker_prompt_version";
 // poll window is legitimately still working, not a husk, and a too-tight
 // claim_grace would SIGTERM it mid-poll before it ever gets to claim.
 // (Bumped to 1020s alongside this change.)
-const QUEUE_WORKER_POLL_SECONDS = 900;
+const QUEUE_WORKER_POLL_SECONDS = 540;
 // One spec per worker task. queueType MUST match scripts/claude_job.py TAG_TO_TYPE.
 const QUEUE_WORKERS = [
     { taskId: WORKER_TASK_ID, queueType: "any", human: "universal queue" },
@@ -3983,8 +3992,9 @@ function queueWorkerBody(spec) {
         `The deterministic pipeline runs on this Mac. When it needs a Claude turn it ` +
             `drops a job on a local file queue. Your only job: pick up the next job, do ` +
             `EXACTLY what its prompt says, hand the result back. You do this with Bash, ` +
-            `Read, and Write, and NOTHING else. This run is unattended — reaching for any ` +
-            `other tool, or trying to "investigate", STALLS it forever.`,
+            `Read, and Write, and NOTHING else (except the single archive call in step 5). ` +
+            `This run is unattended — reaching for any other tool, or trying to ` +
+            `"investigate", STALLS it forever.`,
         ``,
         `PACING — CRITICAL: this unattended session is terminated ~90 seconds after ` +
             `your LAST tool call (a host inactivity timeout). That clock only runs BETWEEN ` +
@@ -4000,11 +4010,16 @@ function queueWorkerBody(spec) {
         `1. Look for the next job. Run this EXACT Bash command and let it run to ` +
             `completion — it polls internally for up to ${Math.round(QUEUE_WORKER_POLL_SECONDS / 60)} ` +
             `minutes before giving up, so it may take a while to return. That is normal: ` +
-            `do NOT interrupt it and do NOT make any other tool call while it is running.`,
-        `     ${py} ${job} next --type any --prompt-file --wait-seconds ${QUEUE_WORKER_POLL_SECONDS} --state-dir ${sd}`,
+            `do NOT interrupt it and do NOT make any other tool call while it is running. ` +
+            `Pass the Bash tool's timeout parameter as 600000 (its 10-minute maximum) so ` +
+            `the call is never moved to the background. If the result nevertheless says ` +
+            `the command was moved to the background (this happens when the Mac sleeps ` +
+            `mid-poll; the timeout is wall-clock), do NOT wait for it: call TaskStop with ` +
+            `the ID it gives you, report "no jobs" in one line, and go to step 5.`,
+        `     S4L_WORKER_SELF_REAP=0 ${py} ${job} next --type any --prompt-file --wait-seconds ${QUEUE_WORKER_POLL_SECONDS} --state-dir ${sd}`,
         `   It prints one line of JSON once it returns. If it prints "{}" (empty), no ` +
             `job showed up during the whole poll window — report "no jobs" in one line ` +
-            `and STOP. You are done.`,
+            `and go to step 5.`,
         `2. Otherwise it prints {"job_id":"...","prompt_file":"...","schema_file":...}. ` +
             `Use the Read tool to read prompt_file; it is the complete, self-contained ` +
             `instruction the pipeline wrote for you. If the Read result says it is partial ` +
@@ -4014,20 +4029,28 @@ function queueWorkerBody(spec) {
             `ONLY that JSON object — no prose, no markdown, no code fences.`,
         `3. Submit it. Write your JSON object to ${outDir}/out-<job_id>.json using the ` +
             `Write tool (substitute the real job_id), then run this EXACT Bash command:`,
-        `     ${py} ${job} result --job <job_id> --result-file ${outDir}/out-<job_id>.json --state-dir ${sd}`,
+        `     S4L_WORKER_SELF_REAP=0 ${py} ${job} result --job <job_id> --result-file ${outDir}/out-<job_id>.json --state-dir ${sd}`,
         `   If it reports the result was rejected (bad JSON / missing keys), fix your JSON ` +
             `and submit again — at most twice. If it still fails, run ` +
-            `\`${py} ${job} result --job <job_id> --error --state-dir ${sd}\` (type a one-line ` +
-            `reason, then Ctrl-D) and STOP.`,
-        `4. Report in ONE short line what you did, then STOP. Do NOT claim another job, ` +
-            `do NOT loop, do NOT read other files, do NOT call any other tool.`,
+            `\`S4L_WORKER_SELF_REAP=0 ${py} ${job} result --job <job_id> --error --state-dir ${sd}\` (type a one-line ` +
+            `reason, then Ctrl-D) and go to step 5.`,
+        `4. Report in ONE short line what you did. Do NOT claim another job, ` +
+            `do NOT loop, do NOT read other files.`,
+        `5. End this session yourself. Call ToolSearch with the query ` +
+            `"select:mcp__ccd_session_mgmt__archive_session", then call ` +
+            `mcp__ccd_session_mgmt__archive_session with session_id "self" and reason ` +
+            `"s4l worker done". That archive call must be your very last tool call; it ` +
+            `ends the session cleanly (no SIGTERM, no idle wait). If the tool is not ` +
+            `available, just STOP.`,
         ``,
         `HARD RULES: use ONLY the Bash tool (to run claude_job.py AND any persist ` +
             `commands the job's prompt explicitly gives you), the Read tool (the ` +
             `prompt/schema sidecar + the SKILL/config files the prompt names), and the ` +
-            `Write tool (the result file). NEVER post, reply, open a browser, or run any ` +
-            `command the prompt does not explicitly give you. An empty queue is the ` +
-            `NORMAL, expected case most minutes — it is success, not a problem to debug.`,
+            `Write tool (the result file), plus TaskStop ONLY for a backgrounded poll, and ` +
+            `ToolSearch and mcp__ccd_session_mgmt__archive_session ONLY as the final step 5. NEVER post, ` +
+            `reply, open a browser, or run any command the prompt does not explicitly ` +
+            `give you. An empty queue is the NORMAL, expected case most minutes — it is ` +
+            `success, not a problem to debug.`,
     ].join("\n");
 }
 // Full canonical SKILL.md (frontmatter + body + version marker) the MCP writes

package/mcp/dist/setup.js

@@ -45,6 +45,37 @@ export function configPath() {
         return p; // not created yet: return the intended path unresolved
     }
 }
+// Atomic config.json write (2026-10-30). Never write config.json in place:
+// writeFileSync truncates the file first, so a reader in that window (or an
+// interrupted write) sees a torn file and every pipeline lane dies on it.
+// Write a same-directory temp file, fsync, then rename over the target so
+// readers only ever see the old or the new complete file. Keeps the
+// timestamped .bak- copy the call sites used to make.
+export function writeConfigAtomic(cfg) {
+    const cfgPath = configPath();
+    if (fs.existsSync(cfgPath)) {
+        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+        fs.copyFileSync(cfgPath, `${cfgPath}.bak-${stamp}`);
+    }
+    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
+    const tmp = `${cfgPath}.tmp-${process.pid}`;
+    try {
+        const fd = fs.openSync(tmp, "w");
+        try {
+            fs.writeSync(fd, JSON.stringify(cfg, null, 2) + "\n");
+            fs.fsyncSync(fd);
+        }
+        finally {
+            fs.closeSync(fd);
+        }
+        fs.renameSync(tmp, cfgPath);
+    }
+    finally {
+        if (fs.existsSync(tmp))
+            fs.unlinkSync(tmp);
+    }
+    return cfgPath;
+}
 // One-time (idempotent) migration to the state-dir home, run at server boot.
 // Cases:
 //   - no state config, legacy is a REAL file  -> move it up, leave a symlink
@@ -360,13 +391,7 @@ export function applySetup(input) {
         cfg.projects.push(entry);
         created = true;
     }
-    const cfgPath = configPath();
-    if (fs.existsSync(cfgPath)) {
-        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-        fs.copyFileSync(cfgPath, `${cfgPath}.bak-${stamp}`);
-    }
-    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
-    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+    writeConfigAtomic(cfg);
     void sendStateSnapshot("config_write");
     if (!persona)
         recordManagedProject(input.name);
@@ -418,13 +443,7 @@ export function recordRedditAccount(username) {
     if (!reddit.login_method)
         reddit.login_method = "browser";
     try {
-        const cfgPath = configPath();
-        if (fs.existsSync(cfgPath)) {
-            const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-            fs.copyFileSync(cfgPath, `${cfgPath}.bak-${stamp}`);
-        }
-        fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
-        fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+        writeConfigAtomic(cfg);
         void sendStateSnapshot("config_write");
         return { written: true, detail: `accounts.reddit.username = ${clean}` };
     }
@@ -541,13 +560,7 @@ export function ensurePersonaProject(grounding) {
         name = PERSONA_DEFAULT_NAME;
         created = true;
     }
-    const cfgPath = configPath();
-    if (fs.existsSync(cfgPath)) {
-        const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-        fs.copyFileSync(cfgPath, `${cfgPath}.bak-${stamp}`);
-    }
-    fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
-    fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+    const cfgPath = writeConfigAtomic(cfg);
     // Raw dictation transcript -> persona_corpus.txt sidecar (NOT config.json).
     // Mirrors scripts/build_persona.py cmd_apply: config.json is inlined into many
     // prompts (ALL_PROJECTS_JSON), so a multi-KB corpus there would bloat every
@@ -598,13 +611,7 @@ export function ensureShortLinksDefault() {
             changed = true;
         }
         if (changed) {
-            const cfgPath = configPath();
-            if (fs.existsSync(cfgPath)) {
-                const stamp = new Date().toISOString().replace(/[:.]/g, "-");
-                fs.copyFileSync(cfgPath, `${cfgPath}.bak-${stamp}`);
-            }
-            fs.mkdirSync(path.dirname(cfgPath), { recursive: true });
-            fs.writeFileSync(cfgPath, JSON.stringify(cfg, null, 2) + "\n", "utf-8");
+            writeConfigAtomic(cfg);
             void sendStateSnapshot("config_write");
         }
     }

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.12-rc.8",
-  "installedAt": "2026-09-28T16:44:48.332Z"
+  "version": "1.7.12-rc.9",
+  "installedAt": "2026-10-30T18:59:09.558Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.12-rc.8",
+  "version": "1.7.12-rc.9",
   "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.8",
+  "version": "1.7.12-rc.9",
   "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.8",
+  "version": "1.7.12-rc.9",
   "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",
@@ -41,6 +41,23 @@
     "!scripts/_gsc_roi_query.py",
     "!scripts/batch_send_dms.py",
     "!scripts/finalize_post_*.py",
+    "!scripts/insert_[0-9]*.py",
+    "!scripts/insert[0-9]*.py",
+    "!scripts/ins[0-9]*.py",
+    "!scripts/tlh_pick_*.py",
+    "!scripts/tlh_freshness_*.py",
+    "!scripts/tlh_fresh.py",
+    "!scripts/tlh_stale.py",
+    "!scripts/fresh[0-9]*.py",
+    "!scripts/hist[0-9]*.py",
+    "!scripts/q[0-9]*.py",
+    "!scripts/show[0-9]*.py",
+    "!scripts/stale[0-9]*.py",
+    "!scripts/stale_[0-9]*.py",
+    "!scripts/stale_classes_*.py",
+    "!scripts/stale_clips_*.py",
+    "!scripts/r[0-9]*.py",
+    "!scripts/w[0-9]*.py",
     "!scripts/insert_li_notifs.py",
     "!scripts/li_notif_scan_process.py",
     "!scripts/phase_d_edit.py",

package/scripts/angles.py

@@ -0,0 +1,8 @@
+import os,psycopg2
+from dotenv import load_dotenv
+load_dotenv(os.path.expanduser('~/social-autoposter/.env'))
+c=psycopg2.connect(os.environ['DATABASE_URL']).cursor()
+c.execute("select distinct metadata->>'theme_angle' from media_posts")
+print(' '.join(sorted(r[0] or '' for r in c.fetchall())))
+c.execute("select distinct metadata->>'engagement_style' from media_posts")
+print([r[0] for r in c.fetchall()])

package/scripts/claude_job.py

@@ -1303,38 +1303,22 @@ def cmd_provider(ns) -> int:
 # next (consumer side, run by a scheduled task)                               #
 # --------------------------------------------------------------------------- #
 def _agent_session_pid():
-    """Best-effort: the Claude agent-mode SESSION pid running THIS worker — the
-    exact process the stale-session reaper (reap_stale_claude_sessions.py) would
-    target. We climb our own process tree to the ancestor whose cmd carries the
-    reaper's worker signature ('claude-code/' + 'local-agent-mode-sessions') and
-    return its pid, so the claim can be stamped with it and the reaper can SPARE
-    that session for the whole drafting turn (instead of SIGTERMing it at the short
-    grace window — the 2026-06-29 draft-kill regression). None if not identifiable;
-    the reaper then falls back to its newest-spare heuristic.
-    """
+    """Best-effort: pid of the Claude agent-mode SESSION running THIS worker —
+    the exact process the stale-session reaper (reap_stale_claude_sessions.py)
+    would target. The claim is stamped with it
+    so the reaper (a) SPARES that session for the whole drafting turn (the
+    2026-06-29 draft-kill regression) and (b) re-queues the job once that
+    session is dead (release_stale_claims, ~2 min). Shares _find_own_session's
+    signature: the old private copy matched 'local-agent-mode-sessions', which
+    current Desktop builds no longer put on the cmdline, so every claim went
+    unstamped and a claim whose session died stranded its producer for the full
+    ~30 min timeout (2026-10-30: Desktop relaunched a minute after a claim).
+    None if not identifiable."""
     try:
-        out = subprocess.run(
-            ["/bin/ps", "-axo", "pid=,ppid=,command="],
-            capture_output=True, text=True, timeout=10,
-        ).stdout
-        info = {}
-        for line in out.splitlines():
-            m = re.match(r"\s*(\d+)\s+(\d+)\s+(.*)$", line)
-            if m:
-                info[int(m.group(1))] = (int(m.group(2)), m.group(3))
-        pid = os.getpid()
-        for _ in range(16):  # bounded climb up the tree
-            ent = info.get(pid)
-            if not ent or ent[0] <= 1:
-                break
-            ppid = ent[0]
-            pcmd = info.get(ppid, (0, ""))[1]
-            if ("claude-code/" in pcmd) and ("local-agent-mode-sessions" in pcmd):
-                return ppid
-            pid = ppid
+        found = _find_own_session(_ps_pid_map())
     except Exception:
         return None
-    return None
+    return found[0] if found else None
 
 
 def _attempt_claim(ns, qtype: str) -> bool:

package/scripts/config.py

@@ -27,15 +27,22 @@ Resolution order for the repo root (single source of truth):
 $S4L_CONFIG_PATH overrides the config file location outright (some installs
 pin the operator config, e.g. ~/s4l/config.json, independent of the code dir).
 
-Do NOT add write helpers here. Config writes go through the MCP server's
-project_config tool (it owns validation and the state snapshot); pipeline
-scripts are readers.
+Config writes: user-facing edits go through the MCP server's project_config
+tool (it owns validation and the state snapshot). The few pipeline scripts
+that must persist runtime state into config.json (subreddit bans) MUST use
+update_config() below and nothing else: never `open(config, "w")` +
+json.dump. That in-place pattern truncates the file to 0 bytes and streams it
+back, so any interruption leaves a torn prefix that breaks every reader
+(2026-09-06, 09-30, 10-22, 10-29 outages; the 10-29 one stopped all X
+drafting for ~23h).
 """
 
 from __future__ import annotations
 
+import fcntl
 import json
 import os
+import sys
 
 _CACHE: dict | None = None
 _CACHE_PATH: str | None = None
@@ -98,6 +105,47 @@ def load_config(fresh: bool = False) -> dict:
     return _CACHE
 
 
+def update_config(mutate, path: str | None = None):
+    """Locked, atomic read-modify-write of config.json.
+
+    `mutate(cfg)` edits the dict in place and returns a truthy value when it
+    changed something (nothing is written otherwise); its return value is
+    passed back to the caller. The whole read->mutate->write span holds the
+    same fcntl lock on <config>.lock that learned_preferences.py takes, so
+    concurrent writers cannot erase each other's edits. The new content goes
+    to a temp file in the same directory and is swapped in with os.replace,
+    so readers only ever see the complete old file or the complete new one;
+    a writer killed mid-write leaves a stray temp file, never a torn config.
+
+    Raises if config.json is missing or unparseable: callers must not
+    "repair" a broken config by writing a partial dict over it.
+    """
+    global _CACHE, _CACHE_PATH, _CACHE_MTIME
+    path = path or config_path()
+    with open(path + ".lock", "w") as lock_f:
+        fcntl.flock(lock_f, fcntl.LOCK_EX)
+        with open(path) as f:
+            cfg = json.load(f)
+        result = mutate(cfg)
+        if not result:
+            return result
+        tmp = f"{path}.tmp-{os.getpid()}"
+        try:
+            with open(tmp, "w") as f:
+                f.write(json.dumps(cfg, indent=2) + "\n")
+                f.flush()
+                os.fsync(f.fileno())
+            os.replace(tmp, path)
+        finally:
+            if os.path.exists(tmp):
+                os.unlink(tmp)
+        # One attribution line per write, so the next incident names its writer.
+        caller = os.path.basename(sys.argv[0]) if sys.argv and sys.argv[0] else "?"
+        print(f"[config] saved {path} by {caller} pid={os.getpid()}", file=sys.stderr)
+        _CACHE, _CACHE_PATH, _CACHE_MTIME = None, None, None
+    return result
+
+
 def get(path: str, default=None):
     """Dotted-path lookup into config.json: get("accounts.twitter.handle").
     A single-segment path reads a top-level key. Lists are not traversed;

package/scripts/post_reddit.py

@@ -48,7 +48,7 @@ REPO_DIR = os.path.expanduser(os.environ.get("S4L_REPO_DIR") or "~/social-autopo
 # its hardcoded config path (the S4L-4H dead-path class on customer boxes).
 import os as _cfg_os, sys as _cfg_sys
 _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
+from config import config_path as _canonical_config_path, load_config, update_config
 CONFIG_PATH = _canonical_config_path()
 REDDIT_BROWSER = os.path.join(REPO_DIR, "scripts", "reddit_browser.py")
 REDDIT_BROWSER_LOCK = os.path.join(REPO_DIR, "scripts", "reddit_browser_lock.py")
@@ -665,18 +665,16 @@ def mark_comment_blocked(thread_url: str,
     if not sub_match:
         return
     sub = sub_match.group(1).lower()
+    def _add(config):
+        blocked = config.setdefault("subreddit_bans", {}).setdefault("comment_blocked", [])
+        if sub in _ban_entries_to_subs(blocked):
+            return False
+        blocked.append(_make_ban_entry(sub, reason, project))
+        blocked.sort(key=lambda e: _ban_entry_sub(e) or "")
+        return True
+
     try:
-        with open(CONFIG_PATH) as f:
-            config = json.load(f)
-        bans = config.setdefault("subreddit_bans", {})
-        blocked = bans.setdefault("comment_blocked", [])
-        existing = _ban_entries_to_subs(blocked)
-        if sub not in existing:
-            blocked.append(_make_ban_entry(sub, reason, project))
-            blocked.sort(key=lambda e: _ban_entry_sub(e) or "")
-            with open(CONFIG_PATH, "w") as f:
-                json.dump(config, f, indent=2)
-                f.write("\n")
+        if update_config(_add, CONFIG_PATH):
             print(f"[post_reddit] Added r/{sub} to subreddit_bans.comment_blocked "
                   f"(reason={reason!r} project={project!r})")
     except Exception as e:
@@ -780,43 +778,42 @@ def mark_thread_blocked(subreddit: str, abort_reason: str = "",
     if not force and abort_reason and not _abort_is_permanent_block(abort_reason):
         return
     reason_str: str | None = (abort_reason or "").strip()[:280] or None
-    try:
-        with open(CONFIG_PATH) as f:
-            config = json.load(f)
-        bans = config.setdefault("subreddit_bans", {})
-        blocked = bans.setdefault("thread_blocked", [])
-        existing = _ban_entries_to_subs(blocked)
-        if sub not in existing:
+
+    def _block(config):
+        """Returns ("added"|"refreshed", entry) when config changed, else None."""
+        blocked = config.setdefault("subreddit_bans", {}).setdefault("thread_blocked", [])
+        if sub not in _ban_entries_to_subs(blocked):
             new_entry = _make_ban_entry(sub, reason_str, project)
             blocked.append(new_entry)
             blocked.sort(key=lambda e: _ban_entry_sub(e) or "")
-            with open(CONFIG_PATH, "w") as f:
-                json.dump(config, f, indent=2)
-                f.write("\n")
+            return ("added", new_entry)
+        # Re-arm an existing QUARANTINE entry on a fresh quarantine strike
+        # (both old and new reasons carry the prefix). Never overwrite a
+        # permanent entry with a weaker time-limited one.
+        entry = next((e for e in blocked
+                      if isinstance(e, dict) and _ban_entry_sub(e) == sub), None)
+        old_reason = (entry or {}).get("reason") or ""
+        new_is_q = (reason_str or "").startswith(QUARANTINE_REASON_PREFIX)
+        if entry is not None and new_is_q and old_reason.startswith(QUARANTINE_REASON_PREFIX):
+            from datetime import datetime, timezone
+            entry["reason"] = reason_str
+            entry["added_at"] = datetime.now(timezone.utc).strftime(
+                "%Y-%m-%dT%H:%M:%SZ")
+            return ("refreshed", entry)
+        return None
+
+    try:
+        changed = update_config(_block, CONFIG_PATH)
+        if not changed:
+            print(f"[post_reddit] r/{sub} already in thread_blocked, skipping")
+        elif changed[0] == "added":
             print(f"[post_reddit] Auto-blocked r/{sub} from future thread posts "
                   f"(reason={reason_str!r} project={project!r})")
-            _mirror_ban_to_backend("thread_blocked", new_entry)
+            _mirror_ban_to_backend("thread_blocked", changed[1])
         else:
-            # Re-arm an existing QUARANTINE entry on a fresh quarantine strike
-            # (both old and new reasons carry the prefix). Never overwrite a
-            # permanent entry with a weaker time-limited one.
-            entry = next((e for e in blocked
-                          if isinstance(e, dict) and _ban_entry_sub(e) == sub), None)
-            old_reason = (entry or {}).get("reason") or ""
-            new_is_q = (reason_str or "").startswith(QUARANTINE_REASON_PREFIX)
-            if entry is not None and new_is_q and old_reason.startswith(QUARANTINE_REASON_PREFIX):
-                from datetime import datetime, timezone
-                entry["reason"] = reason_str
-                entry["added_at"] = datetime.now(timezone.utc).strftime(
-                    "%Y-%m-%dT%H:%M:%SZ")
-                with open(CONFIG_PATH, "w") as f:
-                    json.dump(config, f, indent=2)
-                    f.write("\n")
-                print(f"[post_reddit] Refreshed r/{sub} thread quarantine "
-                      f"(30-day clock re-armed)")
-                _mirror_ban_to_backend("thread_blocked", entry)
-            else:
-                print(f"[post_reddit] r/{sub} already in thread_blocked, skipping")
+            print(f"[post_reddit] Refreshed r/{sub} thread quarantine "
+                  f"(30-day clock re-armed)")
+            _mirror_ban_to_backend("thread_blocked", changed[1])
     except Exception as e:
         print(f"[post_reddit] WARNING: could not persist thread-blocked sub r/{sub}: {e}")
 

package/scripts/reddit_ban_check.py

@@ -184,7 +184,7 @@ def record_confirmed_bans(subs, project=None) -> dict:
     'account_blocked_in_sub' (the reason platform_strike_events reads to emit
     platform_banned learning events). Upgrades pre-existing weak entries
     (reason=None) to the confirmed reason. Never records on None (unknown)."""
-    from config import config_path
+    from config import update_config
     from post_reddit import _make_ban_entry, _ban_entry_sub
 
     state = banned_state(subs)
@@ -194,33 +194,33 @@ def record_confirmed_bans(subs, project=None) -> dict:
     if not banned:
         return {"banned": [], "recorded": [], "upgraded": [], "unknown": unknown}
 
-    path = config_path()
-    with open(path) as f:
-        cfg = json.load(f)
-    bans = cfg.setdefault("subreddit_bans", {})
-    blocked = bans.setdefault("comment_blocked", [])
-    by_sub = {(_ban_entry_sub(e) or "").lower(): e for e in blocked}
-
-    for sub in banned:
-        entry = by_sub.get(sub)
-        if entry is None:
-            blocked.append(_make_ban_entry(sub, "account_blocked_in_sub", project))
-            recorded.append(sub)
-        elif entry.get("reason") != "account_blocked_in_sub":
-            # upgrade a weak/manual entry so the digest ban event can fire
-            from datetime import datetime, timezone
-            entry["reason"] = "account_blocked_in_sub"
-            if not entry.get("added_at"):
-                entry["added_at"] = datetime.now(timezone.utc).strftime(
-                    "%Y-%m-%dT%H:%M:%SZ")
-            entry.setdefault("noticed_by_project", project)
-            upgraded.append(sub)
-
-    if recorded or upgraded:
-        blocked.sort(key=lambda e: (_ban_entry_sub(e) or ""))
-        with open(path, "w") as f:
-            json.dump(cfg, f, indent=2)
-            f.write("\n")
+    blocked: list = []  # filled with the saved list, for the backend mirror
+
+    def _mutate(cfg):
+        entries = cfg.setdefault("subreddit_bans", {}).setdefault("comment_blocked", [])
+        blocked[:] = entries
+        by_sub = {(_ban_entry_sub(e) or "").lower(): e for e in blocked}
+        for sub in banned:
+            entry = by_sub.get(sub)
+            if entry is None:
+                entries.append(_make_ban_entry(sub, "account_blocked_in_sub", project))
+                recorded.append(sub)
+            elif entry.get("reason") != "account_blocked_in_sub":
+                # upgrade a weak/manual entry so the digest ban event can fire
+                from datetime import datetime, timezone
+                entry["reason"] = "account_blocked_in_sub"
+                if not entry.get("added_at"):
+                    entry["added_at"] = datetime.now(timezone.utc).strftime(
+                        "%Y-%m-%dT%H:%M:%SZ")
+                entry.setdefault("noticed_by_project", project)
+                upgraded.append(sub)
+        if not (recorded or upgraded):
+            return False
+        entries.sort(key=lambda e: (_ban_entry_sub(e) or ""))
+        blocked[:] = entries
+        return True
+
+    if update_config(_mutate):
         # Mirror to the backend subreddit_bans table (source of truth as of
         # 2026-07-19; config.json is the write-through cache). Best-effort:
         # readers union both sources, so a failed mirror never un-bans.

package/scripts/voice_exemplars.py

@@ -226,10 +226,15 @@ def _upsert_corpus_section(corpus_path: Path, section: str) -> str:
 
 
 def _is_hand_written(proj: dict) -> bool:
-    """examples present but never stamped by us = a human typed them."""
+    """examples present but never stamped by us = a human typed them.
+    A curated examples_good set counts too: the account-wide scan is the
+    user's general X register, which would override a project's own voice."""
     voice = proj.get("voice")
-    return (isinstance(voice, dict) and bool(voice.get("examples"))
-            and not voice.get("examples_scanned_at"))
+    if not isinstance(voice, dict):
+        return False
+    if voice.get("examples_good"):
+        return True
+    return bool(voice.get("examples")) and not voice.get("examples_scanned_at")
 
 
 def _set_examples(proj: dict, scan: dict, top: int, min_chars: int,

package/scripts/tlh_freshness_284.py

@@ -1,134 +0,0 @@
-import os, re, subprocess, hashlib, itertools, json
-import psycopg2
-from collections import defaultdict
-
-REM = os.path.expanduser("~/social-autoposter/mixer/remotion")
-PUB = os.path.join(REM, "public", "mixer")
-FFPROBE = "ffprobe"
-os.environ["PATH"] = "/opt/homebrew/Cellar/ffmpeg/8.1.1/bin:" + os.environ.get("PATH","")
-
-def dburl():
-    with open(os.path.expanduser("~/social-autoposter/.env")) as f:
-        for line in f:
-            if line.startswith("DATABASE_URL="):
-                return line.split("=",1)[1].strip()
-    raise SystemExit("no DATABASE_URL")
-
-def probe_dur(p):
-    try:
-        out = subprocess.check_output([FFPROBE,"-v","error","-show_entries","format=duration","-of","csv=p=0",p]).decode().strip()
-        return float(out)
-    except Exception:
-        return None
-
-def md5(p):
-    h=hashlib.md5()
-    with open(p,"rb") as f:
-        for chunk in iter(lambda:f.read(1<<20), b""):
-            h.update(chunk)
-    return h.hexdigest()
-
-# 1. all tlh-*.mp4 slot files, their duration + content md5
-slots={}
-for fn in os.listdir(PUB):
-    if fn.startswith("tlh-") and fn.endswith(".mp4"):
-        p=os.path.join(PUB,fn)
-        d=probe_dur(p)
-        slots[fn]={"dur":d,"md5":md5(p)}
-
-# content class = md5. Map filename -> class
-fn2class={fn:info["md5"] for fn,info in slots.items()}
-# which classes are ~2.0s (target 2.0 slots). Consider a file 2.0s if 1.95<=dur<=2.05
-two_sec_classes=set()
-class_dur=defaultdict(list)
-for fn,info in slots.items():
-    if info["dur"] is not None:
-        class_dur[info["md5"]].append(info["dur"])
-for cls,durs in class_dur.items():
-    avg=sum(durs)/len(durs)
-    if 1.95<=avg<=2.05:
-        two_sec_classes.add(cls)
-
-# 2. DB: all lesson-% rows, source_clips + post_number
-conn=psycopg2.connect(dburl())
-cur=conn.cursor()
-cur.execute("""SELECT post_number, variant_id, source_clips, metadata->>'theme_angle'
-               FROM media_posts WHERE variant_id LIKE 'lesson-%' AND source_clips IS NOT NULL
-               ORDER BY post_number""")
-rows=cur.fetchall()
-
-# map each row -> set of content classes (from src basenames), record post ordering
-variant_classes=[]  # (post_number, variant_id, frozenset(classes))
-class_last_post=defaultdict(lambda:-1)
-for pn,vid,sc,angle in rows:
-    if isinstance(sc,str):
-        sc=json.loads(sc)
-    classes=set()
-    for c in sc:
-        src=c.get("src","")
-        base=os.path.basename(src)
-        cls=fn2class.get(base)
-        if cls:
-            classes.add(cls)
-    variant_classes.append((pn,vid,frozenset(classes)))
-    for cls in classes:
-        if pn>class_last_post[cls]:
-            class_last_post[cls]=pn
-
-# recent organic renders = last 5 lesson rows by post_number
-recent5=set()
-for pn,vid,cls in sorted(variant_classes,key=lambda x:-x[0])[:5]:
-    recent5|=set(cls)
-
-# candidate 2.0s classes, ranked by staleness (lowest last_post first)
-cands=[(class_last_post[c],c) for c in two_sec_classes]
-cands.sort()  # stalest first
-print("== 2.0s content classes, stalest first (last_post, class, example_files) ==")
-class_files=defaultdict(list)
-for fn,cls in fn2class.items():
-    class_files[cls].append(fn)
-for lp,c in cands[:20]:
-    print(f"  last_post={lp:>4}  {c[:12]}  files={sorted(class_files[c])[:4]}")
-
-# no-3+-co-occurrence: chosen 4-set shares <=2 classes with ANY prior variant
-def ok_set(fourset):
-    fs=set(fourset)
-    for pn,vid,cls in variant_classes:
-        if len(fs & set(cls))>=3:
-            return False
-    return True
-
-# not in recent5
-pool=[c for lp,c in cands if c not in recent5]
-print(f"\n== pool (stale, not in last-5) size={len(pool)} ==")
-
-# greedily search: take combinations of the stalest, prefer overall stalest sum
-chosen=None
-# limit search to stalest ~14 for tractability
-search=pool[:14]
-best=None
-for combo in itertools.combinations(search,4):
-    if ok_set(combo):
-        score=sum(class_last_post[c] for c in combo)
-        if best is None or score<best[0]:
-            best=(score,combo)
-if best:
-    chosen=best[1]
-    print("\n== CHOSEN 4-set (min staleness score, no 3+ co-occurrence) ==")
-    for c in chosen:
-        print(f"  last_post={class_last_post[c]:>4}  {c[:12]}  pick_file={sorted(class_files[c])[0]}")
-    # verify max pairwise co-occurrence
-    maxco=0
-    for pn,vid,cls in variant_classes:
-        ov=len(set(chosen)&set(cls))
-        maxco=max(maxco,ov)
-    print(f"  max overlap with any prior variant = {maxco}")
-    print("  RESULT_FILES="+",".join(sorted(class_files[c])[0] for c in chosen))
-else:
-    print("NO VALID SET FOUND")
-
-# also report existing max lesson number
-cur.execute("SELECT variant_id FROM media_posts WHERE variant_id ~ '^lesson-[0-9]+$'")
-nums=[int(r[0].split('-')[1]) for r in cur.fetchall()]
-print("\nDB max lesson num =", max(nums) if nums else None)
-cur.close(); conn.close()

package/scripts/tlh_pick_248.py

@@ -1,92 +0,0 @@
-import re, os, subprocess, json, hashlib
-from collections import Counter, defaultdict
-from itertools import combinations
-
-DATA = os.path.expanduser("~/social-autoposter/mixer/remotion/src/mixer/data.ts")
-PUB  = os.path.expanduser("~/social-autoposter/mixer/remotion/public/mixer")
-src = open(DATA).read()
-
-# Extract every clipsV2 block and legacy clips arrays referencing tlh-*.mp4
-# Find all "mixer/tlh-...mp4" occurrences grouped per variant via clipsV2:[ ... ] blocks
-sets = []
-for m in re.finditer(r'clipsV2:\s*\[(.*?)\]', src, re.S):
-    clips = re.findall(r'mixer/(tlh-[0-9a-z\-]+\.mp4)', m.group(1))
-    if clips:
-        sets.append(clips)
-# legacy v1: clips arrays inside TLH? lesson-1 uses clips[] with tlh-1..5
-for m in re.finditer(r'clips:\s*\[(.*?)\]', src, re.S):
-    clips = re.findall(r'"(tlh-[0-9a-z\-]+\.mp4)"', m.group(1))
-    if clips:
-        sets.append(clips)
-
-def family(fn):
-    # tlh-<firstint>-... -> first integer group
-    mm = re.match(r'tlh-(\d+)', fn)
-    return mm.group(1) if mm else fn
-
-usage = Counter()
-cooc = Counter()
-for s in sets:
-    for c in set(s):
-        usage[c]+=1
-    for a,b in combinations(sorted(set(s)),2):
-        cooc[(a,b)]+=1
-
-# available encoded tlh clips on disk
-avail = sorted([f for f in os.listdir(PUB) if re.match(r'tlh-[0-9a-z\-]+\.mp4$', f)])
-
-def probe(fn):
-    p = os.path.join(PUB, fn)
-    out = subprocess.run(["ffprobe","-v","error","-select_streams","v:0",
-        "-show_entries","stream=width,height:format=duration","-of","json",p],
-        capture_output=True,text=True).stdout
-    j = json.loads(out)
-    st = j["stream"][0] if "stream" in j else j["streams"][0]
-    dur = float(j["format"]["duration"])
-    return st["width"], st["height"], dur
-
-def blackframes(fn):
-    p = os.path.join(PUB, fn)
-    r = subprocess.run(["ffmpeg","-v","error","-i",p,"-vf","blackdetect=d=0.1:pic_th=0.98",
-        "-an","-f","null","-"],capture_output=True,text=True)
-    return "black_start" in r.stderr
-
-def sha(fn):
-    return hashlib.sha256(open(os.path.join(PUB,fn),'rb').read()).hexdigest()
-
-# Filter avail to valid 1080x1920, dur>=1.75 (holds a 2.0s slot acceptably or exact), non-black
-os.environ["PATH"]="/opt/homebrew/Cellar/ffmpeg/8.1.1/bin:"+os.environ["PATH"]
-valid=[]
-info={}
-for f in avail:
-    try:
-        w,h,d = probe(f)
-    except Exception as e:
-        continue
-    if (w,h)!=(1080,1920): continue
-    info[f]=(w,h,d)
-    valid.append(f)
-
-print("total prior sets:", len(sets))
-print("valid 1080x1920 clips on disk:", len(valid))
-
-# Build candidate 4-sets: distinct families, zero pairwise co-occurrence, low total usage.
-# Rank by (max pairwise cooc, total usage). Verify durations >=1.75 and non-black + distinct sha lazily on the winner.
-from itertools import combinations as comb
-# group valid by family, prefer low-usage clips
-valid_sorted = sorted(valid, key=lambda f:(usage[f], f))
-best=None
-# to keep it tractable, restrict candidate pool to the 40 lowest-usage valid clips across distinct families
-pool = valid_sorted[:60]
-results=[]
-for quad in comb(pool,4):
-    fams=[family(f) for f in quad]
-    if len(set(fams))!=4: continue
-    pairs=list(comb(sorted(quad),2))
-    maxco=max(cooc[p] for p in pairs)
-    tot=sum(usage[f] for f in quad)
-    results.append((maxco,tot,quad))
-results.sort(key=lambda x:(x[0],x[1]))
-print("\ntop 15 candidate quads (maxcooc, totalusage, clips):")
-for maxco,tot,quad in results[:15]:
-    print(maxco,tot,list(quad),"durs",[round(info[f][2],3) for f in quad])

package/scripts/tlh_pick_504.py

@@ -1,115 +0,0 @@
-import os, re, glob, json, subprocess, hashlib
-import psycopg
-from collections import defaultdict
-
-FFPROBE="/opt/homebrew/Cellar/ffmpeg/8.1.1/bin/ffprobe"
-FFMPEG="/opt/homebrew/Cellar/ffmpeg/8.1.1/bin/ffmpeg"
-PUB=os.path.expanduser("~/social-autoposter/mixer/remotion/public/mixer")
-
-def dburl():
-    for line in open(os.path.expanduser("~/social-autoposter/.env")):
-        if line.startswith("DATABASE_URL="):
-            return line.split("=",1)[1].strip()
-url=dburl()
-
-with psycopg.connect(url) as conn, conn.cursor() as cur:
-    cur.execute("SELECT MAX(post_number) FROM media_posts")
-    print("MAX_post_number:", cur.fetchone()[0])
-    cur.execute("SELECT COUNT(*) FROM media_posts WHERE post_number=504")
-    print("post_504_rows:", cur.fetchone()[0])
-    cur.execute("SELECT COUNT(*) FROM media_posts WHERE variant_id='lesson-506'")
-    print("lesson506_rows:", cur.fetchone()[0])
-    # used theme angles ever
-    cur.execute("SELECT DISTINCT metadata->>'theme_angle' FROM media_posts WHERE metadata->>'theme_angle' IS NOT NULL")
-    angles=sorted(r[0] for r in cur.fetchall())
-    print("USED_ANGLES_COUNT:", len(angles))
-    # recent posts source_clips + variant + post_number
-    cur.execute("""SELECT post_number, variant_id, source_clips FROM media_posts
-                   WHERE source_clips IS NOT NULL ORDER BY post_number DESC LIMIT 12""")
-    recent=cur.fetchall()
-    # per-clip-src -> last post_number across ALL rows
-    cur.execute("SELECT post_number, source_clips FROM media_posts WHERE source_clips IS NOT NULL")
-    allrows=cur.fetchall()
-
-print("\n=== RECENT 12 (post_number, variant, srcs) ===")
-recent_srcs_by_post={}
-for pn,vid,sc in recent:
-    srcs=[os.path.basename(c.get('src','')) for c in sc] if sc else []
-    recent_srcs_by_post[pn]=srcs
-    print(pn, vid, srcs)
-
-# save angles
-json.dump(angles, open("/tmp/tlh504_angles.json","w"))
-
-# Build clip -> last post_number map, keyed by basename
-lastpost_by_base=defaultdict(int)
-for pn,sc in allrows:
-    for c in (sc or []):
-        b=os.path.basename(c.get('src',''))
-        if b: lastpost_by_base[b]=max(lastpost_by_base[b], pn)
-
-# Now probe every tlh-*.mp4: video md5 class, dims, duration
-def vmd5(path):
-    out=subprocess.run([FFMPEG,"-i",path,"-map","0:v","-an","-f","md5","-"],
-                       capture_output=True,text=True)
-    m=re.search(r'MD5=([0-9a-f]+)', out.stdout+out.stderr)
-    return m.group(1)[:10] if m else None
-def dims_dur(path):
-    out=subprocess.run([FFPROBE,"-v","error","-select_streams","v:0",
-        "-show_entries","stream=width,height","-show_entries","format=duration",
-        "-of","json",path],capture_output=True,text=True)
-    j=json.loads(out.stdout)
-    w=j["streams"][0]["width"]; h=j["streams"][0]["height"]
-    d=float(j["format"]["duration"])
-    return w,h,d
-
-clips=sorted(glob.glob(os.path.join(PUB,"tlh-*.mp4")))
-info={}  # base -> dict
-cls_members=defaultdict(list)
-for p in clips:
-    b=os.path.basename(p)
-    w,h,d=dims_dur(p)
-    cl=vmd5(p)
-    info[b]={"w":w,"h":h,"dur":round(d,3),"cls":cl}
-    cls_members[cl].append(b)
-
-# class last-used = max lastpost among its member basenames
-cls_last={}
-for cl,members in cls_members.items():
-    cls_last[cl]=max((lastpost_by_base[m] for m in members), default=0)
-
-# candidates: 1080x1920 classes with on-disk dur >= 1.5, sorted by staleness (class_last asc)
-cand=[]
-for cl,members in cls_members.items():
-    reps=[m for m in members if info[m]["w"]==1080 and info[m]["h"]==1920 and info[m]["dur"]>=1.5]
-    if not reps: continue
-    # pick representative basename (shortest dur>=1.5 tiebreak by name)
-    rep=sorted(reps, key=lambda m:(info[m]["dur"], m))[0]
-    cand.append((cls_last[cl], cl, rep, info[rep]["dur"], members))
-cand.sort(key=lambda x:(x[0], x[2]))
-
-recent5=set()
-for pn in sorted(recent_srcs_by_post, reverse=True)[:3]:
-    recent5.update(recent_srcs_by_post[pn])
-    # also add classes of those srcs
-print("\n=== recent 3 posts clip basenames (avoid classes) ===")
-print(sorted(recent5))
-recent_classes=set()
-for b in recent5:
-    if b in info: recent_classes.add(info[b]["cls"])
-print("recent_classes:", recent_classes)
-
-print("\n=== STALEST 1080x1920 classes (dur>=1.5), class_last asc ===")
-picked=[]
-for class_last, cl, rep, dur, members in cand:
-    if cl in recent_classes: 
-        tag="(SKIP recent)"
-    else:
-        tag=""
-        if len(picked)<8:
-            picked.append((rep,dur,cl,class_last))
-    print(f"class_last={class_last} cls={cl} rep={rep} dur={dur} members={members} {tag}")
-
-print("\n=== PICK (first 5 non-recent stalest) ===")
-for rep,dur,cl,cl_last in picked[:5]:
-    print(rep, "dur=",dur, "cls=",cl, "class_last=",cl_last)

package/scripts/tlh_pick_505.py

@@ -1,61 +0,0 @@
-import os, glob, subprocess, json, hashlib, psycopg2
-os.chdir(os.path.expanduser("~/social-autoposter/mixer/remotion"))
-os.environ["PATH"]="/opt/homebrew/Cellar/ffmpeg/8.1.1/bin:"+os.environ["PATH"]
-FF="/opt/homebrew/Cellar/ffmpeg/8.1.1/bin/ffmpeg"; FP="/opt/homebrew/Cellar/ffmpeg/8.1.1/bin/ffprobe"
-clips=sorted(glob.glob("public/mixer/tlh-*.mp4"))
-info={}
-for c in clips:
-    base=os.path.basename(c)
-    # skip the post-505 leftover slots (belong to posted lesson-505)
-    dur=subprocess.run([FP,"-v","error","-show_entries","format=duration","-of","csv=p=0",c],capture_output=True,text=True).stdout.strip()
-    dims=subprocess.run([FP,"-v","error","-select_streams","v:0","-show_entries","stream=width,height","-of","csv=p=0:s=x",c],capture_output=True,text=True).stdout.strip()
-    md5=subprocess.run([FF,"-i",c,"-map","0:v","-an","-f","md5","-"],capture_output=True,text=True).stdout.strip().split("=")[-1]
-    info[base]={"dur":float(dur) if dur else 0,"dims":dims,"md5":md5[:10]}
-# DB: most recent post_number per basename
-import os as _o
-from urllib.parse import urlparse
-# load .env DATABASE_URL
-env={}
-for line in open(os.path.expanduser("~/social-autoposter/.env")):
-    if line.strip() and not line.startswith("#") and "=" in line:
-        k,v=line.split("=",1); env[k.strip()]=v.strip().strip('"').strip("'")
-conn=psycopg2.connect(env["DATABASE_URL"]); cur=conn.cursor()
-cur.execute("select post_number, source_clips from media_posts where source_clips is not null")
-last_by_base={}
-for pn,sc in cur.fetchall():
-    if not sc: continue
-    for e in sc:
-        s=(e.get("src") or "")
-        b=os.path.basename(s)
-        if b:
-            last_by_base[b]=max(last_by_base.get(b,0),pn)
-# class_last = max post over all basenames sharing md5 class
-class_last={}
-by_class={}
-for base,d in info.items():
-    by_class.setdefault(d["md5"],[]).append(base)
-for md5,bases in by_class.items():
-    cl=max((last_by_base.get(b,0) for b in bases), default=0)
-    class_last[md5]=cl
-# recent renders to avoid (post 500..504)
-cur.execute("select post_number, source_clips from media_posts where post_number>=500 order by post_number desc")
-recent={}
-for pn,sc in cur.fetchall():
-    recent[pn]=[os.path.basename(e.get("src","")) for e in (sc or [])]
-print("RECENT RENDERS 500..504:")
-for pn in sorted(recent,reverse=True): print(" ",pn,recent[pn])
-# candidate classes: 1080x1920, on-disk dur>=1.5, exclude tlh-505-* leftovers
-rows=[]
-seen_class=set()
-for md5,bases in by_class.items():
-    bs=[b for b in bases if not b.startswith("tlh-505-")]
-    if not bs: continue
-    # representative: pick one 1080x1920 with dur>=1.5
-    reps=[b for b in bs if info[b]["dims"]=="1080x1920" and info[b]["dur"]>=1.5]
-    if not reps: continue
-    rep=sorted(reps)[0]
-    rows.append((class_last[md5], md5, rep, info[rep]["dur"], [b for b in bs]))
-rows.sort(key=lambda r:(r[0], r[2]))
-print("\nSTALEST 1080x1920 classes (dur>=1.5), by class_last asc:")
-for r in rows[:14]:
-    print(f"  class_last=post-{r[0]:>3}  md5={r[1]}  rep={r[2]:<14} dur={r[3]:.3f}  bases={r[4]}")