social-autoposter 1.6.70 → 1.6.72

package/bin/cli.js

@@ -367,123 +367,6 @@ function applyAppMakerMcpConfigOverrides() {
 // uv installed and broke Phase 1's Claude scan (the MCP server's `command:
 // /root/.local/bin/uv` resolved to ENOENT, Claude got no tools, returned an
 // empty envelope).
-// AppMaker VM self-bootstrap. Single entry point that the appmaker template
-// startup.sh calls on every fresh sandbox boot. Reads the stable sessionKey
-// from /run/mk0r-session.json (which the appmaker bridge rewrites on every
-// session bind, and which survives E2B sandbox substitution — only the
-// sandboxId changes), then asks the social-autoposter HTTP API which Twitter
-// account this VM is bound to (handle + stored login cookies, keyed by
-// social_accounts.vm_session_key). With that single DB answer it sets up
-// everything: env file (with the DB-sourced handle), profile symlink, MCP
-// config (BH_PORT=9222), uuid-runtime, then restores the Twitter login by
-// re-injecting the stored cookies via CDP.
-//
-// This is the "one proper fix" for sandbox substitution: the VM holds no
-// per-VM state on disk — the DB does, keyed by the stable sessionKey. So
-// any fresh sandbox can rebuild itself by reading /run/mk0r-session.json
-// and calling one route.
-function bootstrapVm() {
-  if (!isAppMakerVm()) {
-    console.error('bootstrap-vm: not an AppMaker VM (no /opt/startup.sh + CDP :9222). Use `init` or `update` on dev boxes.');
-    process.exit(2);
-  }
-  // Persist VM mode so subsequent `update` runs on this sandbox keep the
-  // AppMaker tweaks without re-passing --vm/SA_VM.
-  enableVmMode();
-  console.log('  AppMaker VM bootstrap: resolving identity from DB by sessionKey...');
-
-  let sessionKey;
-  try {
-    const raw = fs.readFileSync('/run/mk0r-session.json', 'utf8');
-    sessionKey = (JSON.parse(raw) || {}).sessionKey;
-  } catch (err) {
-    console.error(`bootstrap-vm: cannot read /run/mk0r-session.json: ${err.message}`);
-    process.exit(3);
-  }
-  if (!sessionKey) {
-    console.error('bootstrap-vm: /run/mk0r-session.json has no sessionKey');
-    process.exit(3);
-  }
-  console.log(`    sessionKey=${sessionKey}`);
-
-  // Get the X-Installation header via identity.py (same Python helper http_api.py
-  // uses, so auth stays single-sourced).
-  const identityPath = path.join(PKG_ROOT, 'scripts', 'identity.py');
-  const headerRes = spawnSync('/usr/bin/python3', [identityPath, 'header'], {
-    encoding: 'utf8',
-  });
-  if (headerRes.status !== 0) {
-    console.error(`bootstrap-vm: identity.py header failed: ${headerRes.stderr || headerRes.error}`);
-    process.exit(4);
-  }
-  const installHeader = (headerRes.stdout || '').trim();
-
-  const base = (process.env.AUTOPOSTER_API_BASE || 'https://s4l.ai').replace(/\/+$/, '');
-  const url = `${base}/api/v1/twitter/vm-session?session_key=${encodeURIComponent(sessionKey)}`;
-  console.log(`    GET ${url}`);
-
-  // Use curl (always present on the appmaker template) so we don't pull in
-  // a Node HTTP dep here.
-  const curl = spawnSync('curl', [
-    '-sS', '--max-time', '15',
-    '-H', `X-Installation: ${installHeader}`,
-    '-H', 'Content-Type: application/json',
-    url,
-  ], { encoding: 'utf8' });
-  if (curl.status !== 0) {
-    console.error(`bootstrap-vm: curl failed: ${curl.stderr || curl.error}`);
-    process.exit(5);
-  }
-  let payload;
-  try {
-    payload = JSON.parse(curl.stdout || '{}');
-  } catch (err) {
-    console.error(`bootstrap-vm: bad JSON from API: ${curl.stdout.slice(0, 300)}`);
-    process.exit(6);
-  }
-  if (!payload.ok || !payload.data) {
-    console.error(`bootstrap-vm: API error: ${JSON.stringify(payload).slice(0, 300)}`);
-    process.exit(7);
-  }
-  const { handle, cookies, vm_project_id } = payload.data;
-  if (!handle) {
-    console.error('bootstrap-vm: API returned no handle. social_accounts.vm_session_key may be unset for this VM.');
-    process.exit(8);
-  }
-  console.log(`    bound to @${handle} (vm_project_id=${vm_project_id || 'none'}, cookies=${(cookies || []).length})`);
-
-  // Write env file with DB-sourced handle (durable across `social-autoposter update`).
-  writeAppMakerEnvFile(handle);
-
-  // Existing setup steps. installBrowserHarness already installs uuid-runtime,
-  // symlinks the profile, and patches the MCP config — call it directly.
-  installBrowserHarness();
-
-  // Install Python deps from requirements.txt. installBrowserHarness only
-  // installs uv + mcp; it does NOT read requirements.txt, so without this the
-  // VM is missing websocket-client (restore_twitter_session.py aborts on
-  // import) plus playwright that the cycle scripts need.
-  installPythonDeps();
-
-  // Restore the Twitter login if we have stored cookies and the Chrome is
-  // up. No-op when Chrome isn't reachable yet (startup ordering); the cycle
-  // preflight will run restore_twitter_session.py on its next tick.
-  if ((cookies || []).length > 0) {
-    const restorePath = path.join(HOME, 'social-autoposter', 'scripts', 'restore_twitter_session.py');
-    if (fs.existsSync(restorePath)) {
-      console.log('    invoking restore_twitter_session.py to re-inject cookies...');
-      // Source the env file so AUTOPOSTER_TWITTER_HANDLE / TWITTER_CDP_URL are set.
-      const r = spawnSync('bash', ['-lc',
-        `source ${HOME}/.social-autoposter-env 2>/dev/null; /usr/bin/python3 ${restorePath} || true`,
-      ], { stdio: 'inherit' });
-      void r;
-    }
-  } else {
-    console.log('    no stored cookies; manual login still required this once.');
-  }
-
-  console.log('  bootstrap-vm: done.');
-}
 
 function installBrowserHarness() {
   const onAppMaker = vmModeEnabled();
@@ -1137,8 +1020,6 @@ if (cmd === 'init') {
   update();
 } else if (cmd === 'doctor') {
   doctor();
-} else if (cmd === 'bootstrap-vm') {
-  bootstrapVm();
 } else if (cmd === 'install-runtime') {
   installRuntime();
 } else if (cmd === 'reset' || cmd === 'uninstall') {
@@ -1171,7 +1052,6 @@ if (cmd === 'init') {
   console.log('  npx social-autoposter init          first-time setup');
   console.log('  npx social-autoposter update        update scripts, preserve config');
   console.log('  npx social-autoposter doctor [--json] [--phase pre_connect|full]');
-  console.log('  npx social-autoposter bootstrap-vm  AppMaker VM self-bootstrap (DB-driven)');
   console.log('  npx social-autoposter install-runtime  provision owned Python + Chromium (panel-free)');
   console.log('  npx social-autoposter export-cookies [dir]  export browser cookies');
   console.log('  npx social-autoposter import-cookies [dir]  import browser cookies');

package/mcp/dist/index.js

@@ -2,9 +2,9 @@
 // social-autoposter MCP server (X/Twitter rail).
 //
 // Core tools:
-//   draft_cycle  - scan + draft, return all drafts as a numbered table for the
-//                  user to review in chat (posts nothing).
-//   post_drafts  - post the drafts the user chose by number from a batch.
+//   scan_candidates - scan + score X threads, return the top candidates (no draft, no post).
+//   submit_drafts   - take the replies you drafted and queue them for review (posts nothing).
+//   post_drafts     - post the drafts the user chose by number from a batch.
 //   get_stats    - read-only post + engagement stats.
 //
 // THIN wrapper. The pipeline brain (scan, score, drafting prompts, posting)
@@ -16,7 +16,7 @@ import { screencast, bringBrowserToFront } from "./screencast.js";
 import os from "node:os";
 import path from "node:path";
 import fs from "node:fs";
-import { repoDir, runPython, run, readPlan, writePlan, planPath, } from "./repo.js";
+import { repoDir, runPython, run, readPlan, writePlan, planPath, scanResultPath, } from "./repo.js";
 import { applySetup, resolveProject, listManagedProjectStatus, REQUIRED_FIELDS, RECOMMENDED_FIELDS, configPath, } from "./setup.js";
 import { xStatus, xConnect, xDetectSources, xScanProfile, summarizeXAuth } from "./twitterAuth.js";
 import { startProvisioning, isProvisioning, readProgress, runtimeReady, readRuntime, resolvePython, resolveChrome, ensureMenubar, } from "./runtime.js";
@@ -152,7 +152,8 @@ const server = new McpServer({
         "ONBOARDING IS A TERMINAL GOAL. When the user asks to set up, install, configure, or onboard " +
         "social-autoposter, keep taking the next safe action until the owned runtime is ready, a " +
         "project is fully configured with seeded search topics, X is connected with its real handle, " +
-        "and `draft_cycle` has verified the pipeline without posting. Do not ask whether to inspect " +
+        "and the draft path (`scan_candidates` -> draft -> `submit_drafts`) has verified the pipeline " +
+        "without posting. Do not ask whether to inspect " +
         "status, install or repair owned dependencies, choose an auto-detected browser profile, connect " +
         "X, scan the profile, research the product website, save conservative inferred fields, seed " +
         "topics, retry a recoverable failure, or run draft-only verification. Do those things. The " +
@@ -162,25 +163,28 @@ const server = new McpServer({
         "when no product can be identified from config, context, the X profile, or public research, " +
         "or pause for an unavoidable interactive login or OS prompt. Never post drafts or enable " +
         "autopilot during setup unless the user explicitly requested that. When setup reaches done — " +
-        "runtime ready, a project configured with seeded topics, X connected, and `draft_cycle` " +
-        "verified — call the `dashboard` tool so the user sees the finished setup rendered, then give " +
+        "runtime ready, a project configured with seeded topics, X connected, and the draft path " +
+        "(scan_candidates -> draft -> submit_drafts) verified — call the `dashboard` tool so the user " +
+        "sees the finished setup rendered, then give " +
         "the completion summary.\n\n" +
         "BE PROACTIVE ABOUT MARKETING MOMENTS. Whenever the user ships, finishes, merges, or releases " +
         "something worth talking about in this session (a new feature, a launch, a long-awaited fix, a " +
-        "milestone), don't wait to be asked: offer to tell the world by running `draft_cycle` to post " +
-        "about it. A feature nobody hears about is wasted distribution. Use judgment, suggest it for " +
+        "milestone), don't wait to be asked: offer to tell the world by running a draft cycle " +
+        "(`scan_candidates` -> draft the replies -> `submit_drafts`) about it. A feature nobody hears " +
+        "about is wasted distribution. Use judgment, suggest it for " +
         "genuinely shareable moments, not routine refactors, chores, or internal cleanup.\n\n" +
         "STAY CURRENT. At the start of a session, and again right after you help the user ship/merge/" +
         "release, call the `runtime` tool (action:'version'). If `update_available` is true, tell the " +
         "user and offer to run `runtime` with action:'update'. The `project_config` tool's status also " +
         "surfaces `update_available` and an `update_hint`.\n\n" +
-        "TYPICAL FLOW: `project_config` (configure OR edit the project, and connect X) -> `draft_cycle` " +
-        "(scan + review a batch; the user approves / edits / skips every draft in a single form) -> " +
+        "TYPICAL FLOW: `project_config` (configure OR edit the project, and connect X) -> `scan_candidates` " +
+        "(get the top threads to reply to) -> draft the replies yourself -> `submit_drafts` (queue them " +
+        "for review; nothing posts until the user approves) -> `post_drafts` (post the approved ones) -> " +
         "`get_stats` (see performance). Run `project_config` first; the other tools refuse until a " +
         "project is fully configured. To change anything about a project later, call `project_config` " +
         "again with the project's name and just the changed fields — there is no separate config editor.\n\n" +
         "RENDER THE DASHBOARD AFTER ACTIONS. After any state-changing or results-producing tool call " +
-        "(`draft_cycle`, `post_drafts`, `get_stats`), end your turn by " +
+        "(`scan_candidates`, `submit_drafts`, `post_drafts`, `get_stats`), end your turn by " +
         "calling the `dashboard` tool so the user sees the updated state visually. Do NOT call " +
         "`dashboard` after pure Q&A, config explanations, or status-only checks that changed nothing.",
 });
@@ -190,9 +194,31 @@ const baseRegisterTool = server.registerTool.bind(server);
 // same input-schema -> callback-arg inference it had before; the body is `any`
 // and just additionally stashes the callback by name. `appTool` drops the
 // leading `server` arg of registerAppTool (its callback takes no typed args).
+// Tools that take a while: writing activity.json around them makes the menu bar
+// show a spinner + label while they run (either invocation path). draft_cycle is
+// NOT here — it writes finer scanning/drafting phases itself (see produceDrafts).
+const TOOL_ACTIVITY = {
+    post_drafts: "posting",
+    get_stats: "loading stats",
+};
+function withActivity(name, cb) {
+    const label = TOOL_ACTIVITY[name];
+    if (!label)
+        return cb;
+    return async (args, extra) => {
+        writeActivity("working", label);
+        try {
+            return await cb(args, extra);
+        }
+        finally {
+            clearActivity();
+        }
+    };
+}
 const tool = ((name, config, cb) => {
-    TOOL_HANDLERS[name] = cb;
-    return baseRegisterTool(name, config, cb);
+    const h = withActivity(name, cb);
+    TOOL_HANDLERS[name] = h;
+    return baseRegisterTool(name, config, h);
 });
 const appTool = ((name, config, cb) => {
     // Wrap every tool handler so any thrown error is reported to Sentry. Single
@@ -208,8 +234,9 @@ const appTool = ((name, config, cb) => {
             throw e;
         }
     });
-    TOOL_HANDLERS[name] = wrapped;
-    return registerAppTool(server, name, config, wrapped);
+    const h = withActivity(name, wrapped);
+    TOOL_HANDLERS[name] = h;
+    return registerAppTool(server, name, config, h);
 });
 function jsonContent(obj) {
     return { content: [{ type: "text", text: JSON.stringify(obj, null, 2) }] };
@@ -231,28 +258,28 @@ function blockedReasonMessage(reason) {
                 "couldn't run. (It DID find and rank threads, it just couldn't draft replies.) This " +
                 "CLI uses its own login, separate from Claude Desktop. To fix it, open a terminal and run:\n\n" +
                 "    claude\n\n" +
-                "then `/login` inside it (or run `claude setup-token`). Once it's logged in, run draft_cycle again.");
+                "then `/login` inside it (or run `claude setup-token`). Once it's logged in, run scan_candidates again.");
         case "monthly_limit":
         case "daily_limit":
         case "rate_limit_5h":
             return (`The drafting step hit an Anthropic usage limit (${reason}), so no replies were drafted. ` +
-                "Wait for the limit to reset, then run draft_cycle again.");
+                "Wait for the limit to reset, then run scan_candidates again.");
         case "no_search_topics":
             return ("This project has no search topics yet, so there was nothing to scan. Topics live in the " +
                 "DB (project_search_topics) and are seeded from your project's `search_topics` when you " +
                 "configure it. Re-run the `project_config` tool for this project with a `search_topics` list " +
                 "(comma-separated keywords/phrases your buyers tweet about); it seeds them automatically, then " +
-                "run draft_cycle again.");
+                "run scan_candidates again.");
         case "topics_api_unreachable":
             return ("Couldn't reach the search-topics service to load this project's topics, so the cycle stopped " +
-                "before scanning. This is usually a transient backend/network issue. Try draft_cycle again in a " +
+                "before scanning. This is usually a transient backend/network issue. Try scan_candidates again in a " +
                 "moment; if it persists, check connectivity to the autoposter backend.");
         case "credit_balance":
             return ("The drafting step failed because the Anthropic account is out of credits. " +
-                "Add credits, then run draft_cycle again.");
+                "Add credits, then run scan_candidates again.");
         default:
             return (`The drafting step failed (${reason}) and produced no drafts. ` +
-                "Check skill/logs/twitter-cycle-*.log on this machine for details, then run draft_cycle again.");
+                "Check skill/logs/twitter-cycle-*.log on this machine for details, then run scan_candidates again.");
     }
 }
 // Turn a raw run-twitter-cycle.sh stdout line into a short, user-facing
@@ -371,6 +398,9 @@ async function produceDrafts(project, onProgress) {
     }
     appendLog(`\n===== draft_cycle start ${new Date().toISOString()} ` +
         `project=${project ?? "(default)"} =====\n`);
+    // Menu-bar status: scanning first, then drafting once the prep phase begins
+    // (switched in onLine below). Cleared before every return.
+    writeActivity("scanning", "scanning X");
     const res = await run("bash", ["skill/run-twitter-cycle.sh"], {
         env,
         timeoutMs: 900_000, // scan+draft can take several minutes
@@ -386,6 +416,8 @@ async function produceDrafts(project, onProgress) {
                 appendLog(`${t}\n`);
                 console.error(`[draft_cycle] ${t}`);
             }
+            if (/Phase 2b-prep/.test(t))
+                writeActivity("drafting", "drafting replies");
             if (!onProgress)
                 return;
             const msg = cycleProgressMessage(t);
@@ -399,13 +431,16 @@ async function produceDrafts(project, onProgress) {
     appendLog(`===== draft_cycle end ${new Date().toISOString()} exit=${res.code} =====\n`);
     // Prefer the explicit marker; fall back to the newest plan file on disk.
     const marker = /DRAFT_ONLY_PLAN=\/tmp\/twitter_cycle_plan_(.+)\.json/.exec(res.stdout + "\n" + res.stderr);
-    if (marker && marker[1])
+    if (marker && marker[1]) {
+        clearActivity();
         return { batchId: marker[1] };
+    }
     // A real prep-step failure (e.g. the background claude CLI isn't logged in)
     // emits DRAFT_ONLY_BLOCKED=<reason>. Surface that instead of silently falling
     // back to a stale/empty batch and mis-reporting "no fresh candidates".
     const blockedMarker = /DRAFT_ONLY_BLOCKED=([a-z0-9_]+)/.exec(res.stdout + "\n" + res.stderr);
     if (blockedMarker && blockedMarker[1]) {
+        clearActivity();
         return { batchId: null, blocked: blockedReasonMessage(blockedMarker[1]) };
     }
     // No `DRAFT_ONLY_PLAN=` marker from THIS run => this run produced no drafts.
@@ -413,6 +448,7 @@ async function produceDrafts(project, onProgress) {
     // that's a *previous* run's batch, so a 5-second empty cycle would echo an old
     // 7-draft batch and report phantom success. Report 0 drafts honestly, with the
     // pipeline's own reason (e.g. cold-start project with no seeded queries).
+    clearActivity();
     return {
         batchId: null,
         blocked: `This run produced no drafts (exit ${res.code}). The scan found no fresh ` +
@@ -615,7 +651,7 @@ tool("project_config", {
         "Call with status:true (or no name) to list every configured project, its remaining fields, AND " +
         "whether X is connected. Use config, conversation context, profile_scan, and website research " +
         "before asking for fields. Ask only if no product can be identified or an interactive login is " +
-        "unavoidable. The draft_cycle and get_stats tools refuse to run until a project is " +
+        "unavoidable. The scan_candidates and get_stats tools refuse to run until a project is " +
         "fully set up.",
     inputSchema: {
         status: z.boolean().optional(),
@@ -779,7 +815,7 @@ tool("project_config", {
             next_step: r.connected
                 ? "X is connected. Next, run project_config action:'profile_scan' to read this account's bio + recent " +
                     "posts + replies and draft the project's voice/icp/search_topics in the user's own register " +
-                    "before saving. Then run draft_cycle once the project is fully set up."
+                    "before saving. Then run a draft cycle (scan_candidates -> draft -> submit_drafts) once the project is fully set up."
                 : r.state === "needs_login"
                     ? "The user must finish signing in to x.com in the Chrome window that just opened. Tell " +
                         "them that single required action, then call project_config action:'connect_x', confirm:true again."
@@ -886,7 +922,7 @@ tool("project_config", {
                         (x.connected ? "" : " X is not connected yet either — detect_x_sources, warn about keychain prompts, then run connect_x with confirm:true without a separate permission turn.")
                     : projects.every((p) => p.ready)
                         ? (x.connected
-                            ? "All configured projects are ready and X is connected. Run draft_cycle now to verify end to end without posting. After it verifies, call the `dashboard` tool so the user sees the finished setup."
+                            ? "All configured projects are ready and X is connected. Run scan_candidates, draft a reply or two, and submit_drafts now to verify end to end without posting. After it verifies, call the `dashboard` tool so the user sees the finished setup."
                             : "All configured projects are ready, but X is NOT connected — posting needs a logged-in " +
                                 "x.com session. Detect sources and run project_config action:'connect_x', confirm:true; do not ask whether to proceed.")
                         : "Some projects are missing required fields (see each project's missing_required). Derive them from config, context, profile_scan, and website research, then call project_config again. Ask only if a required field is genuinely unknowable." +
@@ -928,13 +964,13 @@ tool("project_config", {
                     topic_count: topicCount,
                 });
                 seedNote = m
-                    ? ` Seeded ${m[1]} search topic(s) into the DB (new: ${m[2]}, updated: ${m[3]}), so draft_cycle has a topic universe to work with.`
-                    : " Seeded search topics into the DB so draft_cycle has a topic universe to work with.";
+                    ? ` Seeded ${m[1]} search topic(s) into the DB (new: ${m[2]}, updated: ${m[3]}), so scan_candidates has a topic universe to work with.`
+                    : " Seeded search topics into the DB so scan_candidates has a topic universe to work with.";
             }
             else {
                 const tail = (seed.stderr || seed.stdout).trim().split("\n").slice(-1)[0] || "unknown error";
                 blockOnboardingMilestone("topics_seeded", "topic_seed_failed", tail, { exit_code: seed.code });
-                seedNote = ` (Heads up: couldn't seed search topics into the DB yet — ${tail}. draft_cycle will tell you clearly if topics are missing.)`;
+                seedNote = ` (Heads up: couldn't seed search topics into the DB yet — ${tail}. scan_candidates will tell you clearly if topics are missing.)`;
             }
             // Cold-start QUERY supply: fan the seeded topics out into >=30 real X
             // search queries (project_search_queries) so the deterministic Phase 1
@@ -998,7 +1034,7 @@ tool("project_config", {
             note: (result.ready
                 ? `Project '${result.project}' is fully configured.${seedNote} Next: if X is not connected, ` +
                     `detect sources, warn about keychain prompts, and call project_config with ` +
-                    `action:'connect_x', confirm:true immediately. Once X is connected, run draft_cycle to ` +
+                    `action:'connect_x', confirm:true immediately. Once X is connected, run scan_candidates -> submit_drafts to` +
                     `verify without posting. Do not enable autopilot unless explicitly requested.`
                 : `Saved what you provided for '${result.project}'. Still need: ${result.missing_required.join(", ")}. ` +
                     `First derive those fields from existing context, profile_scan, and website research, then ` +
@@ -1010,145 +1046,29 @@ tool("project_config", {
         return textContent(`Setup failed: ${e.message}`);
     }
 });
-// ---- draft_cycle: scan + draft, then hand the batch to the user for review.
-// Posting is a SEPARATE step (post_drafts) so the user picks by number in chat.
-// This host doesn't support elicitation, so there is no in-tool form: the model
-// relays the table and asks which to post / edit, then calls post_drafts.
-tool("draft_cycle", {
-    title: "Draft an X reply cycle",
-    description: "Scan X and draft replies on this machine, then return ALL drafts as a numbered table " +
-        "for review. This tool POSTS NOTHING. Show the table to the user and ask which numbers " +
-        "to post and which to rewrite, then call `post_drafts` with their decision and the " +
-        "returned batch_id. The table MUST show, per draft: the thread being replied to " +
-        "(thread_text), the draft reply, and the link target (link_url) when present; never " +
-        "drop those columns. Flow: discover -> draft -> review in chat -> post_drafts. " +
-        "After returning the table, call the `dashboard` tool so the user sees the updated state.",
-    inputSchema: {
-        project: z
-            .string()
-            .optional()
-            .describe("Which configured project to draft for. Optional when only one project is set up; required when several are."),
-    },
-}, async ({ project }, extra) => {
-    const r = resolveProject(project);
-    if (!r.ok)
-        return textContent(r.message);
-    const proj = r.project;
-    recordOnboardingAttempt("draft_verified");
-    // Live progress so the chat doesn't sit on a frozen spinner for minutes.
-    // Two channels, both best-effort (a sink failure must never fail the cycle):
-    //   1. notifications/message — a log line; the host records it (and some
-    //      clients show it in a log view). Works with no client opt-in.
-    //   2. notifications/progress — drives the status text under the running
-    //      tool. Only valid when the client supplied a progressToken on the
-    //      request, so it's guarded on that.
-    const progressToken = extra?._meta?.progressToken;
-    const sendProgress = async (message, step) => {
-        try {
-            await extra.sendNotification({
-                method: "notifications/message",
-                params: { level: "info", logger: "draft_cycle", data: message },
-            });
-        }
-        catch {
-            /* ignore */
-        }
-        if (progressToken !== undefined) {
-            try {
-                await extra.sendNotification({
-                    method: "notifications/progress",
-                    params: { progressToken, progress: step, message },
-                });
-            }
-            catch {
-                /* ignore */
-            }
-        }
-    };
-    const drafted = await produceDrafts(proj, (message, step) => {
-        void sendProgress(message, step);
-    });
-    if (drafted.blocked || !drafted.batchId) {
-        blockOnboardingMilestone("draft_verified", "draft_cycle_blocked", drafted.blocked ?? "No drafts produced.", { outcome: "blocked" });
-        return textContent(drafted.blocked ?? "No drafts produced.");
-    }
-    const plan = readPlan(drafted.batchId);
-    if (!plan || !(plan.candidates && plan.candidates.length)) {
-        blockOnboardingMilestone("draft_verified", "draft_batch_empty", `No drafts in batch ${drafted.batchId}.`, { outcome: "empty_batch", draft_count: 0 });
-        return textContent(`No drafts in batch ${drafted.batchId}.`);
-    }
-    const count = plan.candidates.length;
-    completeOnboardingMilestone("draft_verified", {
-        outcome: "review_batch",
-        draft_count: count,
-    });
-    // Fire the menu-bar pop-up review (default). The chat-table review below is
-    // unchanged; both surfaces can approve, de-duped by the plan `posted` flag.
-    writeReviewRequest({
-        batch_id: drafted.batchId,
-        project: proj,
-        count,
-        plan_path: planPath(drafted.batchId),
-        created_at: new Date().toISOString(),
-    });
-    const table = renderDraftsTable(plan);
-    const message = `Drafted ${count} ${count === 1 ? "reply" : "replies"} for "${proj}" ` +
-        `(batch ${drafted.batchId}). NOTHING has been posted yet.\n\n` +
-        `${table}\n\n` +
-        `Show this list to the user and ask which to post and which to edit. When you render ` +
-        `the table, ALWAYS include, for every draft: the thread it replies to (in reply to / ` +
-        `thread_text), the draft text, and the link target (link_url) if present. Do NOT drop ` +
-        `the thread or link columns. Note the literal short link is appended at post time and ` +
-        `an A/B gate may omit it, so present link_url as the target, not a guaranteed final URL. ` +
-        `They can reply however is natural, e.g. "post 1, 3 and 5", "edit 2: <new wording>", ` +
-        `"post all", or "skip all". Editing a draft also posts it. Then call the post_drafts ` +
-        `tool with batch_id "${drafted.batchId}" and their decision (post: [numbers], ` +
-        `edits: [{n, text}], or post_all: true). Do not post anything the user didn't ask for.`;
-    return {
-        content: [{ type: "text", text: message }],
-        structuredContent: {
-            batch_id: drafted.batchId,
-            drafted: count,
-            status: "awaiting_decision",
-            onboarding: onboardingSnapshot(),
-            // Include the actual draft text here, not just a count. Some hosts
-            // (e.g. Claude Desktop) surface ONLY structuredContent to the model and
-            // drop the human-readable `content` table — which left the agent saying
-            // "drafted: 2" with no way to show the drafts. Carrying the drafts in
-            // structuredContent makes them available regardless of host behavior.
-            drafts: (plan.candidates || []).map((c, i) => ({
-                n: i + 1,
-                author: c.thread_author,
-                tweet_url: c.candidate_url,
-                // The original tweet being replied to — reviewer context. Hosts that
-                // surface ONLY structuredContent (Claude Desktop, Fazm Code tab) need
-                // this here or the relayed table loses the thread it's responding to.
-                thread_text: c.thread_text,
-                reply_text: c.reply_text,
-                // Target link only. The literal /r/<code> short link is minted at post
-                // time and an A/B gate may omit it; do not pre-mint here.
-                link_url: c.link_url,
-                style: c.engagement_style,
-                language: c.language,
-            })),
-        },
-    };
-});
+// ---- draft_cycle: DEPRECATED 2026-06-20 (registration removed) -------------
+// Replaced by the scan_candidates -> (agent drafts) -> submit_drafts flow, so the
+// AI drafting now runs in the calling session (on the user's plan) instead of a
+// spawned `claude -p`. post_drafts (below) still posts the approved subset, and
+// submit_drafts completes the onboarding "draft_verified" milestone that this
+// tool used to. The underlying pipeline (run-twitter-cycle.sh) and the
+// produceDrafts() helper are kept as the source those tools reuse; only the
+// draft_cycle tool registration was removed here.
 // ---- post_drafts: post the user's chosen drafts from a batch ---------------
 // Second half of the manual loop. The user reviewed the table from draft_cycle
 // and said which numbers to post / edit; this posts exactly those. Editing a
 // draft implies posting it. Indices are 1-based, matching the table.
 tool("post_drafts", {
     title: "Post chosen drafts",
-    description: "Post the drafts the user approved from a draft_cycle batch. Pass the batch_id from " +
-        "draft_cycle and the user's decision by NUMBER (1-based, matching the table): `post` is " +
+    description: "Post the drafts the user approved from a submit_drafts batch. Pass the batch_id from " +
+        "submit_drafts and the user's decision by NUMBER (1-based, matching the table): `post` is " +
         "the list of draft numbers to post as drafted; `edits` rewrites a draft's text before " +
         "posting it (editing implies posting); `post_all` posts every draft. Only the chosen " +
         "drafts post; anything not listed is left unposted. Call this ONLY after the user has " +
         "told you which drafts they want. After posting, call the `dashboard` tool so the user " +
         "sees the updated state.",
     inputSchema: {
-        batch_id: z.string().describe("The batch_id returned by draft_cycle."),
+        batch_id: z.string().describe("The batch_id returned by submit_drafts."),
         post: z
             .array(z.number().int().positive())
             .optional()
@@ -1162,7 +1082,7 @@ tool("post_drafts", {
 }, async ({ batch_id, post, edits, post_all }) => {
     const plan = readPlan(batch_id);
     if (!plan || !(plan.candidates && plan.candidates.length)) {
-        return textContent(`No drafts found for batch ${batch_id}. Run draft_cycle again to produce a fresh batch.`);
+        return textContent(`No drafts found for batch ${batch_id}. Run scan_candidates then submit_drafts again to produce a fresh batch.`);
     }
     const candidates = plan.candidates;
     const total = candidates.length;
@@ -1602,6 +1522,27 @@ function sapsStateDir() {
     return (process.env.SAPS_STATE_DIR ||
         path.join(process.env.HOME || os.homedir(), ".social-autoposter-mcp"));
 }
+// activity.json: a tiny "what's running right now" signal the menu bar reads to
+// show a loading spinner + label (scanning / drafting / posting / …). Written by
+// long-running tools, cleared when they finish. Best-effort; absence == idle.
+function writeActivity(state, label) {
+    try {
+        const dir = sapsStateDir();
+        fs.mkdirSync(dir, { recursive: true });
+        fs.writeFileSync(path.join(dir, "activity.json"), JSON.stringify({ state, label, since: new Date().toISOString() }) + "\n", "utf-8");
+    }
+    catch {
+        /* best effort: a status write must never break the work it's narrating */
+    }
+}
+function clearActivity() {
+    try {
+        fs.rmSync(path.join(sapsStateDir(), "activity.json"), { force: true });
+    }
+    catch {
+        /* best effort */
+    }
+}
 // Signal the menu bar that a fresh draft batch is ready for pop-up review. The
 // chat-table review path is unchanged and still works; this just ALSO lets the
 // corner cards drive review (both surfaces de-dup via the plan's `posted` flag).
@@ -1636,13 +1577,189 @@ async function openInBrowser(url) {
         console.error("[social-autoposter-mcp] openInBrowser failed:", e?.message || e);
     }
 }
+async function runScanCandidates(project, onProgress) {
+    // SCAN_ONLY=1: run scan -> score -> top-N select, then STOP before drafting.
+    // No DRAFT_ONLY, no `claude -p` drafting. TWITTER_PHASE1_LLM_DRAFT=0 forces the
+    // deterministic query bank so the whole scan is claude-free (the agent does ALL
+    // the AI). Off-screen by default (no BH_WINDOW_* / overlay): a scheduled run has
+    // no human watching the Chrome.
+    const env = {
+        SCAN_ONLY: "1",
+        TWITTER_PHASE1_LLM_DRAFT: "0",
+        SAPS_REPO_DIR: repoDir(),
+        PATH: pipelinePath(),
+    };
+    if (project)
+        env.SAPS_FORCE_PROJECT = project;
+    const chrome = resolveChrome();
+    if (chrome)
+        env.BH_CHROME_BIN = chrome;
+    let step = 0;
+    let lastMsg = "";
+    const res = await run("bash", ["skill/run-twitter-cycle.sh"], {
+        env,
+        timeoutMs: 900_000,
+        onLine: (line) => {
+            const t = line.replace(/\s+$/, "");
+            if (t.trim())
+                console.error(`[scan_candidates] ${t}`);
+            if (!onProgress)
+                return;
+            const msg = cycleProgressMessage(t);
+            if (msg && msg !== lastMsg) {
+                lastMsg = msg;
+                onProgress(msg, ++step);
+            }
+        },
+    });
+    const marker = /SCAN_ONLY_RESULT=(\/\S+\.json)/.exec(res.stdout + "\n" + res.stderr);
+    if (marker && marker[1]) {
+        try {
+            const data = JSON.parse(fs.readFileSync(marker[1], "utf-8"));
+            return {
+                batchId: data.batch_id ?? null,
+                candidates: (data.candidates ?? []),
+            };
+        }
+        catch (e) {
+            return {
+                batchId: null,
+                candidates: [],
+                blocked: `Scan finished but its result file was unreadable: ${e?.message || e}`,
+            };
+        }
+    }
+    // If query-gen (when enabled) hits a real failure, the cycle still emits
+    // DRAFT_ONLY_BLOCKED=<reason>. Surface it rather than "no candidates".
+    const blockedMarker = /DRAFT_ONLY_BLOCKED=([a-z0-9_]+)/.exec(res.stdout + "\n" + res.stderr);
+    if (blockedMarker && blockedMarker[1]) {
+        return { batchId: null, candidates: [], blocked: blockedReasonMessage(blockedMarker[1]) };
+    }
+    return {
+        batchId: null,
+        candidates: [],
+        blocked: `This scan produced no candidates (exit ${res.code}). Usually a cold-start ` +
+            `project with no seeded search topics, or nothing fresh on-theme right now. Tail:\n` +
+            res.stderr.split("\n").slice(-12).join("\n"),
+    };
+}
+tool("scan_candidates", {
+    title: "Scan X for reply candidates (no drafting, no posting)",
+    description: "Step 1 of a hands-free / scheduled autopilot run. Runs the scan+score half of the pipeline " +
+        "and returns the top scored X/Twitter threads worth replying to — WITHOUT drafting or posting, " +
+        "and without spending any `claude -p` budget. You (this session) then draft an on-brand reply " +
+        "for each good candidate YOURSELF and submit them with `submit_drafts`. Each candidate includes " +
+        "its candidate_id (pass it back), the thread text/author, the matched project, and engagement " +
+        "metrics. Optional `project` scopes the scan to one configured project.",
+    inputSchema: { project: z.string().optional() },
+}, async (args) => {
+    const scan = await runScanCandidates(args?.project);
+    if (!scan.batchId) {
+        return textContent(scan.blocked || "No candidates found.");
+    }
+    return jsonContent({
+        batch_id: scan.batchId,
+        count: scan.candidates.length,
+        candidates: scan.candidates,
+        next_step: `Draft an on-brand reply (<=250 chars, match the thread's language) for each candidate you ` +
+            `judge genuinely worth engaging; skip the rest. Then call submit_drafts with batch_id ` +
+            `"${scan.batchId}" and one entry per drafted reply ({candidate_id, reply_text}). Nothing posts ` +
+            `until the user approves.`,
+    });
+});
+tool("submit_drafts", {
+    title: "Submit drafted replies for review",
+    description: "Step 2 of a hands-free / scheduled autopilot run. Hand back the replies you drafted for the " +
+        "candidates returned by scan_candidates. Writes them into the SAME review plan the menu-bar " +
+        "approval UI and post_drafts already use — nothing is posted until the user approves. Provide " +
+        "batch_id (from scan_candidates) and a `drafts` array; each entry needs candidate_id and " +
+        "reply_text (engagement_style, language, link_keyword optional).",
+    inputSchema: {
+        batch_id: z.string(),
+        drafts: z
+            .array(z.object({
+            candidate_id: z.union([z.string(), z.number()]),
+            reply_text: z.string(),
+            engagement_style: z.string().optional(),
+            language: z.string().optional(),
+            link_keyword: z.string().optional(),
+        }))
+            .min(1),
+    },
+}, async (args) => {
+    // Reload the scan candidates for thread metadata (url / author / text /
+    // project / topic). If the scan file is gone (e.g. /tmp cleared), we still
+    // build a plan from the drafts alone; the review cards just lack context.
+    const scanById = new Map();
+    try {
+        const raw = JSON.parse(fs.readFileSync(scanResultPath(args.batch_id), "utf-8"));
+        for (const c of (raw.candidates ?? [])) {
+            scanById.set(String(c.id), c);
+        }
+    }
+    catch {
+        /* scan file missing — proceed with draft-only context */
+    }
+    const candidates = args.drafts.map((d) => {
+        const sc = scanById.get(String(d.candidate_id));
+        return {
+            candidate_id: d.candidate_id,
+            candidate_url: sc?.tweet_url,
+            thread_author: sc?.author_handle,
+            thread_text: sc?.tweet_text,
+            reply_text: d.reply_text,
+            engagement_style: d.engagement_style,
+            language: d.language,
+            link_keyword: d.link_keyword,
+            search_topic: sc?.search_topic,
+            matched_project: sc?.matched_project,
+        };
+    });
+    const firstSc = scanById.get(String(args.drafts[0].candidate_id));
+    const project = (candidates.map((c) => c.matched_project).find((p) => !!p) ||
+        firstSc?.matched_project ||
+        "default");
+    const plan = { candidates };
+    writePlan(args.batch_id, plan);
+    // Bake link targets into the plan (sub-second at TWITTER_PAGE_GEN_RATE=0), the
+    // same prep step DRAFT_ONLY does before handing off. Best-effort: posting
+    // falls back to the plain project URL per-candidate if this is skipped.
+    try {
+        await runPython("scripts/twitter_gen_links.py", ["--plan", planPath(args.batch_id)], {
+            timeoutMs: 120_000,
+            env: { TWITTER_PAGE_GEN_RATE: "0", SAPS_REPO_DIR: repoDir(), PATH: pipelinePath() },
+        });
+    }
+    catch {
+        /* best effort — plan still posts with a plain-URL fallback */
+    }
+    const finalPlan = readPlan(args.batch_id) ?? plan;
+    const count = (finalPlan.candidates || []).length;
+    // Drafts queued = the pipeline verified end-to-end without posting. This is the
+    // onboarding "draft_verified" terminal goal (formerly completed by draft_cycle).
+    if (count > 0)
+        completeOnboardingMilestone("draft_verified", { outcome: "review_batch", draft_count: count });
+    // Surface to the menu-bar review cards (same review plan draft_cycle used).
+    writeReviewRequest({
+        batch_id: args.batch_id,
+        project,
+        count,
+        plan_path: planPath(args.batch_id),
+        created_at: new Date().toISOString(),
+    });
+    return textContent(`${count} draft(s) queued for review (batch ${args.batch_id}). They're now in the menu-bar ` +
+        `approval cards and the table below; nothing posts until approved.\n\n` +
+        renderDraftsTable(finalPlan) +
+        `\n\nTo post the approved ones: the user approves in the menu bar, or call post_drafts with the ` +
+        `numbers to post.`);
+});
 appTool("dashboard", {
     title: "Social Autoposter dashboard",
     description: "Render the Social Autoposter dashboard in chat: a visual surface showing project setup, X " +
         "connection, autopilot state, and 7-day stats, with buttons to run a draft cycle, connect X, " +
         "and refresh. Use when the user asks to see the dashboard, panel, " +
         "status, or controls. ALSO call this at the end of any state-changing or results-producing " +
-        "action (draft_cycle, post_drafts, get_stats) so the user sees the " +
+        "action (scan_candidates, submit_drafts, post_drafts, get_stats) so the user sees the " +
         "updated dashboard. Hosts without UI support get the same data as text.",
     inputSchema: {},
     // fallback_url is set only when the host can't render the ui:// resource and

package/mcp/dist/repo.js

@@ -151,3 +151,8 @@ export function latestBatchId() {
         .sort((a, b) => b.mtime - a.mtime);
     return matches.length ? matches[0].batchId : null;
 }
+// Hardcoded under TMP_DIR to mirror the cycle script's SCAN_ONLY writer (same
+// coupling planPath has: run-twitter-cycle.sh writes the file to /tmp directly).
+export function scanResultPath(batchId) {
+    return path.join(TMP_DIR, `saps_scan_candidates_${batchId}.json`);
+}

package/mcp/dist/telemetry.js

@@ -13,7 +13,7 @@ import { repoDir, runPython } from "./repo.js";
 import { VERSION } from "./version.js";
 // Sentry DSN is a client-side identifier (safe to embed, same posture as Fazm's
 // hardcoded Swift DSN). Overridable via env for dev. Empty -> Sentry disabled.
-const EMBEDDED_DSN = "";
+const EMBEDDED_DSN = "https://4d44ac907262c6545cf8681703528d04@o4507617161314304.ingest.us.sentry.io/4511598804336640";
 const SENTRY_DSN = process.env.SAPS_SENTRY_DSN || EMBEDDED_DSN;
 let sentryReady = false;
 export function initSentry() {

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.6.70",
-  "installedAt": "2026-06-20T03:05:13.835Z"
+  "version": "1.6.71",
+  "installedAt": "2026-06-20T16:29:20.789Z"
 }

package/mcp/menubar/s4l_menubar.py

@@ -95,9 +95,8 @@ class S4LMenuBar(rumps.App):
         self._sig = None  # last rendered state signature; skip rebuild if unchanged
         self._review_active = False  # a review-card sequence is on screen
         self._reviewed_batches = set()  # batch_ids already handled this run
-        self._posting = False  # a post is in flight (drives the title spinner)
         self._spin_i = 0
-        self._spinner = None  # rumps.Timer animating the title while posting
+        self._spinner = None  # fast rumps.Timer animating the title while busy
         # Reliable self-check of our own Accessibility (TCC) grant — this is the
         # faithful reading (our launchd process identity, not a parent's). Logged
         # so menubar.err.log records whether keystroke posting will work.
@@ -107,6 +106,11 @@ class S4LMenuBar(rumps.App):
         sys.stderr.flush()
         self._timer = rumps.Timer(self._tick, POLL_SECONDS)
         self._timer.start()
+        # Light 1s poll for server activity (scanning/drafting/posting/…); it
+        # spins up the fast title-spinner on demand. Idle cost is one tiny file
+        # read per second.
+        self._act_poll = rumps.Timer(self._poll_activity, 1.0)
+        self._act_poll.start()
         self._tick(None)
 
     # ---- side effects -----------------------------------------------------
@@ -194,15 +198,24 @@ class S4LMenuBar(rumps.App):
         else:
             self._notify("S4L", "Open Claude Desktop to change autopilot.")
 
-    # ---- posting spinner --------------------------------------------------
-    # Runs on the main thread (rumps timer). While a post is in flight it cycles
-    # the title; once the background post clears self._posting it restores the
-    # normal title and stops itself. Cross-thread safe: the worker only flips the
-    # bool, never touches AppKit.
+    # ---- activity spinner -------------------------------------------------
+    # The server writes activity.json while a tool runs (scanning/drafting/
+    # posting/…). _poll_activity (1s) starts the fast spinner; _spin (0.12s)
+    # animates the title with the label and stops itself when activity clears.
+    # Both run on the main thread (rumps timers).
+    def _poll_activity(self, _):
+        act = st.read_activity()
+        if act and act.get("label") and self._spinner is None:
+            self._spin_i = 0
+            self._spinner = rumps.Timer(self._spin, 0.12)
+            self._spinner.start()
+
     def _spin(self, _):
-        if self._posting:
+        act = st.read_activity()
+        label = act.get("label") if act else None
+        if label:
             self._spin_i = (self._spin_i + 1) % len(SPINNER)
-            self.title = f"S4L posting {SPINNER[self._spin_i]}"
+            self.title = f"S4L {label} {SPINNER[self._spin_i]}"
             return
         try:
             if self._spinner is not None:
@@ -215,9 +228,9 @@ class S4LMenuBar(rumps.App):
 
     # ---- tick: read state, set title, (re)build menu ----------------------
     def _tick(self, _):
-        # While posting, the spinner owns the UI; don't fight it or start a new
-        # review mid-post.
-        if self._posting:
+        # While a tool is running, the spinner owns the title/menu; don't fight it
+        # or start a review mid-run.
+        if self._spinner is not None:
             return
         snap = st.snapshot()
         ob = snap.get("onboarding") or st.read_onboarding()
@@ -317,12 +330,8 @@ class S4LMenuBar(rumps.App):
             return
         self._notify("S4L", f"Posting {len(approved)} draft(s)…")
 
-        # Animate the menu-bar title until the post finishes.
-        self._posting = True
-        self._spin_i = 0
-        self._spinner = rumps.Timer(self._spin, 0.12)
-        self._spinner.start()
-
+        # The server's post_drafts writes "posting" activity, so the activity
+        # spinner shows automatically while this runs — no local spinner needed.
         def work():
             res = st.post_drafts(batch, post=post_nums, edits=edits)
             if res is None:
@@ -336,7 +345,6 @@ class S4LMenuBar(rumps.App):
                     f"Posted {posted if posted is not None else len(approved)} draft(s).",
                 )
             self._review_active = False
-            self._posting = False  # _spin (main thread) restores the title + stops
 
         threading.Thread(target=work, daemon=True).start()
 

package/mcp/menubar/s4l_state.py

@@ -314,6 +314,13 @@ def request_accessibility() -> bool:
 # produced), present the cards, then post the approved subset via the loopback
 # post_drafts tool. The chat-table review still works in parallel; both surfaces
 # de-dup on the plan's per-candidate `posted` flag.
+def read_activity():
+    """What the server is doing right now: {state, label} or None when idle.
+    Written by long-running tools (scanning/drafting/posting/…); drives the
+    menu-bar loading spinner."""
+    return read_json("activity.json")
+
+
 def read_review_request():
     return read_json("review-request.json")
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "social-autoposter",
-  "version": "1.6.70",
+  "version": "1.6.72",
   "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"
@@ -87,7 +87,6 @@
     "!scripts/export_kent_handoff.py",
     "!scripts/extract_user_messages_today.py",
     "!scripts/fazm_seo_health.py",
-    "!scripts/fetch_twitter_t1.py",
     "!scripts/fix_mdx_light_mode.py",
     "!scripts/fix_style_lengths_20260601.py",
     "!scripts/fix_svg_paragraph_wrap.py",

package/scripts/restore_twitter_session.py

@@ -9,8 +9,8 @@ an empty schema. The cycle preflight calls this to heal that automatically:
   1. Attach to the harness Chrome (TWITTER_CDP_URL, default 127.0.0.1:9555 —
      the Mac harness port; AppMaker VMs override it to :9222 via the env file).
   2. Navigate to x.com/home; if it redirects to /login, the session is gone.
-  3. Load cookies, mirror-first: the local 0600 mirror written on every connect
-     (keychain-independent), then the server store for machines with a handle.
+  3. Load cookies from the local 0600 mirror written on every connect
+     (keychain-independent).
   4. Inject them via CDP Network.setCookies and reload.
   5. Verify we land on /home (logged in).
 
@@ -29,11 +29,10 @@ import time
 import urllib.request
 
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
-from http_api import api_get  # noqa: E402
-from twitter_account import resolve_handle  # noqa: E402
 
-# Local 0600 cookie mirror — the keychain-independent restore source for
-# persistent machines (Gap B). Tried before the server store. Stdlib-only;
+# Local 0600 cookie mirror — the keychain-independent restore source (Gap B).
+# It is the ONLY cookie source; the VM-era server store
+# (/api/v1/twitter/session-cookies) was removed 2026-06-17. Stdlib-only;
 # guarded so a path quirk never breaks the cycle preflight.
 try:
     import twitter_cookie_mirror  # noqa: E402
@@ -125,10 +124,10 @@ def _inject(send, cookies) -> int:
 
 
 def _stored_cookies():
-    """Return (cookies, source). Tries the LOCAL mirror first — it's the only
-    durable source on a persistent machine, where the server store is skipped
-    for lack of a social_accounts row — then falls back to the server store
-    (the durable source on hourly-reseeded AppMaker VMs)."""
+    """Return (cookies, source) from the LOCAL 0600 mirror, or ([], None).
+
+    The mirror is the only cookie source; the VM-era server store
+    (/api/v1/twitter/session-cookies) was removed 2026-06-17."""
     if twitter_cookie_mirror is not None:
         try:
             mirrored = twitter_cookie_mirror.load_cookies()
@@ -136,20 +135,6 @@ def _stored_cookies():
             mirrored = []
         if mirrored:
             return mirrored, f"local mirror ({twitter_cookie_mirror.MIRROR_PATH.name})"
-
-    handle = None
-    try:
-        handle = resolve_handle()
-    except Exception:
-        handle = None
-    if handle:
-        try:
-            resp = api_get("/api/v1/twitter/session-cookies", query={"handle": handle})
-            cookies = ((resp or {}).get("data") or {}).get("cookies") or []
-            if cookies:
-                return cookies, f"server store (@{handle})"
-        except Exception as e:
-            print(f"restore_twitter_session: server store fetch failed ({e})", file=sys.stderr)
     return [], None
 
 
@@ -167,8 +152,8 @@ def main():
 
         cookies, source = _stored_cookies()
         if not cookies:
-            print("restore_twitter_session: no stored cookies (local mirror empty + no "
-                  "server store); manual connect_x required", file=sys.stderr)
+            print("restore_twitter_session: no stored cookies (local mirror empty); "
+                  "manual connect_x required", file=sys.stderr)
             return 1
 
         print(f"restore_twitter_session: logged out, restoring from {source}...")

package/scripts/sentry_init.py

@@ -15,7 +15,7 @@ import os
 
 # Client-side DSN: safe to embed, same posture as the Node telemetry and Fazm's
 # hardcoded Swift DSN. Overridable via env for dev. Empty -> Sentry disabled.
-_EMBEDDED_DSN = ""
+_EMBEDDED_DSN = "https://4d44ac907262c6545cf8681703528d04@o4507617161314304.ingest.us.sentry.io/4511598804336640"
 
 _initialized = False
 

package/scripts/setup_twitter_auth.py

@@ -60,15 +60,13 @@ except ImportError:
         "websocket-client not installed (needed for CDP). pip install websocket-client"
     )
 
-# Optional server-side session-cookie store (best-effort). Lets connect_x persist
-# the validated X cookies so restore_twitter_session.py can auto-re-inject them
-# after any logout. Guarded so a missing dep or offline API never breaks setup.
+# Live-handle resolver (best-effort). Lets connect_x record the real logged-in
+# @handle alongside the locally-mirrored cookies. Guarded so a missing dep never
+# breaks setup.
 sys.path.insert(0, os.path.dirname(os.path.abspath(__file__)))
 try:
-    from http_api import api_post  # noqa: E402
     from twitter_account import resolve_handle  # noqa: E402
 except Exception:
-    api_post = None
     resolve_handle = None
 
 # Local 0600 cookie mirror — the keychain-independent durability layer (Gap B).
@@ -386,16 +384,13 @@ def _write_handle_to_config(handle: "str | None") -> bool:
 
 def _persist_session() -> None:
     """Persist the validated live X session for auto-restore after ANY logout
-    (hard kill, crash, keychain re-lock wiping Chrome's Cookies DB, or AppMaker
-    VM reseed). One CDP attach feeds two sinks:
+    (hard kill, crash, or a keychain re-lock wiping Chrome's Cookies DB).
 
-      1. LOCAL 0600 mirror (twitter_cookie_mirror) — ALWAYS written. This is the
-         keychain-independent durability layer that fixes Gap B on a persistent
-         machine: restore_twitter_session.py re-injects from it on the next cycle
-         preflight even after Chrome wiped its own encrypted store.
-      2. Server-side session store (POST /api/v1/twitter/session-cookies) —
-         best-effort. Enables VM auto-restore where the profile is reseeded
-         hourly. No-op on a persistent machine with no social_accounts row.
+    Writes the validated x.com/twitter.com cookies to the LOCAL 0600 mirror
+    (twitter_cookie_mirror) — the keychain-independent durability layer that
+    fixes Gap B on a persistent machine: restore_twitter_session.py re-injects
+    from it on the next cycle preflight even after Chrome wiped its own
+    encrypted store.
 
     Non-fatal end-to-end: the local session is already valid; this only enables
     future auto-recovery, so nothing here may abort connect_x."""
@@ -437,7 +432,9 @@ def _persist_session() -> None:
         except Exception:
             handle = None
 
-    # 1. Local mirror — always, keychain-independent.
+    # Local mirror — keychain-independent durability. This is the only cookie
+    # store; the VM-era server store (/api/v1/twitter/session-cookies) was
+    # removed 2026-06-17 when we stopped running AppMaker VMs.
     if twitter_cookie_mirror is not None:
         try:
             n = twitter_cookie_mirror.save_cookies(cookies, handle=handle)
@@ -447,18 +444,6 @@ def _persist_session() -> None:
         except Exception as e:
             print(f"setup_twitter_auth: local mirror save skipped ({e})", file=sys.stderr)
 
-    # 2. Server store — best-effort, only when a handle resolves.
-    if api_post is not None and handle:
-        try:
-            api_post("/api/v1/twitter/session-cookies", {"handle": handle, "cookies": cookies})
-            print(f"setup_twitter_auth: saved {len(cookies)} session cookies for @{handle} "
-                  "(server auto-restore enabled)", file=sys.stderr)
-        # api_post raises SystemExit (BaseException, NOT Exception) on a 4xx/5xx —
-        # e.g. "no social_accounts row" on a persistent machine that never
-        # registered this handle. Best-effort: must never abort connect_x.
-        except (Exception, SystemExit) as e:
-            print(f"setup_twitter_auth: session-store save skipped ({e})", file=sys.stderr)
-
 
 def _show_window_and_open_login() -> bool:
     """Make the managed Chrome window VISIBLE + focused and land it on the X login

package/skill/lock.sh

@@ -617,10 +617,9 @@ defer_if_foreign_browser_mcp_active() {
 
 # Explicit early release. Use this when a long-running script only needs the
 # browser for part of its run (e.g. run-twitter-cycle.sh holds the lock for
-# Phase 1 scrape, releases during the 5-min T1 sleep + Phase 2a HTTP poll, then
-# re-acquires before Phase 2b posting). Without this, sibling pipelines waiting
-# on the same profile lock block for the full cycle even when the holder is
-# only sleeping.
+# Phase 1 scrape, releases between Phase 1 and Phase 2b posting, then re-acquires
+# before Phase 2b). Without this, sibling pipelines waiting on the same profile
+# lock block for the full cycle even when the holder is not using the browser.
 release_lock() {
   local name="$1"
   local lock_dir="/tmp/social-autoposter-${name}.lock"

package/skill/run-twitter-cycle.sh

@@ -12,18 +12,14 @@
 #   - scrape tweets via twitter-harness, enrich via fxtwitter -> T0 snapshot
 #   - store all candidates with batch_id and search_topic
 #
-# Sleep 300s.
+# No ripen wait (variant D won the A/B/C/D test 2026-05-31): the cycle goes
+# straight from discovery to drafting. There is NO 5-min sleep and NO fxtwitter
+# T1 re-poll anywhere in the Twitter pipeline. delta_score stays at its T0
+# value and is no longer a gate. Do not re-introduce a ripen/sleep step here.
 #
-# Phase 2 (t=5m):
-#   - re-fetch the same candidates via fxtwitter -> T1 snapshot + delta_score
-#   - SQL gate: floor lowered to delta_score >= 0 so zero-momentum but on-theme
-#     product-discussion tweets (asking for a tool, venting a pain point) can
-#     compete; ranking still favors growth via hybrid sort
-#   - Hybrid sort: ORDER BY (delta_score + product_intent_boost) where
-#     product_intent_boost is +5 when tweet text matches an intent-signal regex
-#     (wish/need/looking for/recommend/alternative/frustrated/etc); raw growth
-#     remains the dominant signal, but a slow-burn "anyone know a tool for..."
-#     tweet now ranks alongside fast-growing news/drama
+# Phase 2 (immediately after Phase 1):
+#   - sort candidates by virality_score DESC (composite predictor stamped at
+#     discovery by score_twitter_candidates.py); no delta floor, no T1 re-poll
 #   - Claude reads top 25 (raised from 15 so the long tail reaches the model),
 #     drops unsuitable, posts every candidate it judges genuinely on-brand
 #     (no per-cycle post cap, no per-project quota)
@@ -203,9 +199,20 @@ log "Length-control experiment concluded 2026-06-04; winner=control; LENGTH_ARM
 # spend the sysctl read for the next check.
 source "$REPO_DIR/scripts/preflight.sh"
 SA_PREFLIGHT_SCRIPT="run-twitter-cycle"
-preflight_skip_if_claude_blocked
-preflight_skip_if_jetsam_pressure
-preflight_acquire_slot_or_skip "twitter-cycle" 1
+if [ "${SCAN_ONLY:-0}" = "1" ]; then
+    # SCAN_ONLY (the Desktop-session autopilot's scan step) gets its OWN slot pool
+    # so it is NOT blocked by a live launchd autopilot cycle; the two then serialize
+    # on the twitter-browser lock (acquired in Phase 1) instead of being mutually
+    # exclusive. It also SKIPS the claude-blocked gate: SCAN_ONLY drives no
+    # `claude -p`, so a prior claude cap must not suppress a pure scan.
+    SA_PREFLIGHT_SCRIPT="run-twitter-cycle-scan"
+    preflight_skip_if_jetsam_pressure
+    preflight_acquire_slot_or_skip "twitter-scan" 1
+else
+    preflight_skip_if_claude_blocked
+    preflight_skip_if_jetsam_pressure
+    preflight_acquire_slot_or_skip "twitter-cycle" 1
+fi
 
 # Source lock helpers (functions only, no lock acquired here). Phase 0 + the
 # project/queries setup below run lock-free against DB and config files;
@@ -401,7 +408,7 @@ python3 "$REPO_DIR/scripts/twitter_batch_phase.py" start "$BATCH_ID" --phase pha
 #      read from the owner's twitter_batches row:
 #        phase0        ->  5 min  (just the salvage SQL)
 #        phase1        -> 20 min  (Claude scan + scrape)
-#        phase2a       -> 20 min  (5 min sleep + HTTP T1 poll)
+#        phase2a       -> 20 min  (browser-lock handoff window; no ripen wait since 2026-05-31)
 #        phase2b-prep  -> 45 min  (Claude reads threads + drafts; bumped 2026-05-15
 #                                  15 -> 30 after 17:15 cycle was wrongly salvaged
 #                                  while queued behind 17:30's 42-min lock-hold;
@@ -1443,16 +1450,16 @@ if [ "$BATCH_COUNT" = "0" ]; then
     exit 0
 fi
 
-# Stamp phase2a before releasing the lock so the budget covers the entire
-# 5-min wait + HTTP poll window (phase2a budget = 20 min).
+# Stamp phase2a before releasing the lock so the salvage budget covers the
+# browser-lock handoff window (phase2a budget = 20 min).
 python3 "$REPO_DIR/scripts/twitter_batch_phase.py" advance "$BATCH_ID" --phase phase2a 2>&1 | tee -a "$LOG_FILE" || true
 
-# Release the twitter-browser lock during the 5-min T1 wait + HTTP-only Phase 2a.
+# Release the twitter-browser lock between Phase 1 scrape and Phase 2b posting.
 # Other pipelines (engage-twitter, dm-outreach-twitter, link-edit-twitter,
 # stats.sh) can run their browser steps in this window instead of waiting for us
 # to finish. We re-acquire just before Phase 2b posts, blocking up to the
 # acquire_lock timeout if another pipeline is mid-run.
-log "Releasing twitter-browser lock for the T1 wait window (5min sleep + HTTP fxtwitter poll)..."
+log "Releasing twitter-browser lock between Phase 1 scrape and Phase 2b posting..."
 release_lock "twitter-browser" 2>>"$LOG_FILE"
 # (2026-06-16) NO `rm -f twitter-browser-lock.json` here. The blind rm was
 # ownership-unaware and ran AFTER release_lock, so under a pipeline handoff it
@@ -1520,6 +1527,57 @@ if [ -z "$CANDIDATES" ]; then
     exit 0
 fi
 
+# --- SCAN_ONLY gate: stop after scoring, emit candidates, skip drafting -------
+# When SCAN_ONLY=1 the cycle runs scan -> score -> top-N select, writes the chosen
+# candidates as JSON, and STOPS before the claude drafting step. The MCP
+# scan_candidates tool reads this so a Claude Desktop scheduled-task session can do
+# the drafting ITSELF (on the user's plan, no `claude -p`) and hand the drafts back
+# via submit_drafts. Candidates stay 'pending' (drafted+posted via submit_drafts ->
+# post_drafts, or salvaged by a later cycle). The browser lock was already released
+# at the Phase 1 handoff, so this exits clean via the EXIT trap. NO current caller
+# sets SCAN_ONLY, so the autopilot/draft_cycle paths are byte-for-byte unchanged.
+if [ "${SCAN_ONLY:-0}" = "1" ]; then
+    SCAN_FILE="/tmp/saps_scan_candidates_${BATCH_ID}.json"
+    # $CANDIDATES is the same pipe-separated top-N the drafting step consumes (cols
+    # documented in twitter_cycle_helper.py:cmd_candidates; tweet_text/draft fields
+    # are pipe+newline sanitized there, so a field split is safe). Batch id + out
+    # path travel via env so the single-quoted python needs no shell interpolation.
+    printf '%s\n' "$CANDIDATES" | SAPS_SCAN_FILE="$SCAN_FILE" SAPS_SCAN_BATCH="$BATCH_ID" python3 -c '
+import json, os, sys
+def _i(x):
+    try:
+        return int(float(x or 0))
+    except Exception:
+        return 0
+def _f(x):
+    try:
+        return float(x or 0)
+    except Exception:
+        return 0.0
+out = []
+for line in sys.stdin:
+    line = line.rstrip("\n")
+    if not line.strip():
+        continue
+    p = line.split("|")
+    if len(p) < 14 or not p[0].isdigit():
+        continue
+    out.append({
+        "id": int(p[0]), "tweet_url": p[1], "author_handle": p[2], "tweet_text": p[3],
+        "virality_score": _f(p[4]), "delta_score": _f(p[5]), "matched_project": p[6],
+        "search_topic": p[7], "likes": _i(p[8]), "retweets": _i(p[9]), "replies": _i(p[10]),
+        "views": _i(p[11]), "author_followers": _i(p[12]), "age_hours": _f(p[13]),
+        "existing_draft": p[14] if len(p) > 14 else "", "existing_draft_style": p[15] if len(p) > 15 else "",
+    })
+json.dump({"batch_id": os.environ["SAPS_SCAN_BATCH"], "candidates": out}, open(os.environ["SAPS_SCAN_FILE"], "w"))
+' 2>/dev/null || printf '{"batch_id": "%s", "candidates": []}' "$BATCH_ID" > "$SCAN_FILE"
+    SCAN_N=$(python3 -c "import json; print(len(json.load(open('$SCAN_FILE')).get('candidates') or []))" 2>/dev/null || echo 0)
+    log "SCAN_ONLY=1: $SCAN_N candidate(s) scored and written to $SCAN_FILE. Stopping before drafting (agent drafts next)."
+    _SA_RUN_SUMMARY_EMITTED=1
+    echo "SCAN_ONLY_RESULT=$SCAN_FILE"
+    exit 0
+fi
+
 CANDIDATE_COUNT=$(printf '%s\n' "$CANDIDATES" | grep -c '^[0-9]')
 log "Top $CANDIDATE_COUNT candidates by virality_score selected for post review."