@m13v/s4l 1.7.9-rc.2 → 1.7.9

package/mcp/dist/version.json

@@ -1,4 +1,4 @@
 {
-  "version": "1.7.9-rc.2",
-  "installedAt": "2026-08-09T00:22:23.419Z"
+  "version": "1.7.9",
+  "installedAt": "2026-08-10T22:28:09.611Z"
 }

package/mcp/manifest.json

@@ -2,7 +2,7 @@
   "dxt_version": "0.1",
   "name": "social-autoposter",
   "display_name": "S4L",
-  "version": "1.7.9-rc.2",
+  "version": "1.7.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": {
@@ -10,14 +10,17 @@
     "email": "i@m13v.com",
     "url": "https://s4l.ai"
   },
+  "compatibility": {
+    "platforms": [
+      "darwin"
+    ]
+  },
   "server": {
     "type": "node",
     "entry_point": "dist/index.js",
     "mcp_config": {
-      "command": "${__dirname}/vendor/node-darwin-arm64/bin/node",
-      "args": [
-        "${__dirname}/dist/index.js"
-      ],
+      "command": "${__dirname}/launch.js",
+      "args": [],
       "env": {
         "PATH": "/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
       }

package/mcp/menubar/s4l_browser_foreground.py

@@ -158,14 +158,12 @@ class _Worker(threading.Thread):
         # unaffected (CDP is offscreen-raster + synthetic input; the occlusion
         # flags keep hidden tabs painting).
         # DEFAULT ON (user decision 2026-08-07, reverses the 2026-07-30 default-off
-        # call): the guard hides an offscreen harness that steals the foreground
-        # unless explicitly opted out. Two knobs, by design:
-        #   S4L_NO_HARNESS_HIDE  -> HARD override, force off, checked FIRST so it
-        #       always wins (this is the one-time interactive-login escape hatch).
-        #   S4L_HARNESS_HIDE=0   -> SOFT opt-out for a machine that wants it off.
-        # Unset or any non-"0" value => hide is active (the new default).
-        if os.environ.get("S4L_NO_HARNESS_HIDE"):
-            return
+        # call). ONE flag by design (2026-08-08 — the old S4L_NO_HARNESS_HIDE
+        # override was removed to end the double-flag confusion):
+        #   S4L_HARNESS_HIDE unset / any value except "0" => hide active (default)
+        #   S4L_HARNESS_HIDE=0                            => disabled — the single
+        #       off switch (e.g. to keep a harness window visible for a one-time
+        #       interactive login, then set it back to 1 / unset it).
         if os.environ.get("S4L_HARNESS_HIDE", "1") == "0":
             return
         pos = details.get("window_position") or ""

package/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@m13v/s4l-mcp",
-  "version": "1.7.9-rc.2",
+  "version": "1.7.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.9-rc.2",
+  "version": "1.7.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",

package/scripts/install.sh

@@ -32,7 +32,12 @@ log() { echo "[s4l-install] $*"; }
 die() { echo "[s4l-install] ERROR: $*" >&2; exit 1; }
 
 [ "$(uname -s)" = "Darwin" ] || die "macOS only for now."
-[ "$(uname -m)" = "arm64" ] || die "Apple Silicon only for now (the bundle vendors a darwin-arm64 Node)."
+# The bundle vendors both darwin-arm64 and darwin-x64 Node binaries (1.7.9+);
+# pick the one matching this machine.
+case "$(uname -m)" in
+  x86_64|amd64) NODE_ARCH="x64" ;;
+  *)            NODE_ARCH="arm64" ;;
+esac
 
 URL="$STABLE_URL"
 [ "${S4L_CHANNEL:-}" = "staging" ] && URL="$STAGING_URL"
@@ -45,7 +50,9 @@ log "downloading $URL"
 mkdir -p "$TMP/app"
 /usr/bin/unzip -q "$TMP/s4l.mcpb" -d "$TMP/app" || die "unzip failed"
 [ -f "$TMP/app/dist/index.js" ] || die "bundle missing dist/index.js (bad download?)"
-[ -x "$TMP/app/vendor/node-darwin-arm64/bin/node" ] || die "bundle missing vendored node"
+# Older bundles (pre-1.7.9) only vendor arm64; accept either so a staging box
+# pinned to an old release still installs on Apple Silicon.
+[ -x "$TMP/app/vendor/node-darwin-$NODE_ARCH/bin/node" ] || [ -x "$TMP/app/vendor/node-darwin-arm64/bin/node" ] || die "bundle missing vendored node for $NODE_ARCH"
 
 mkdir -p "$STATE_DIR"
 rm -rf "$APP_DIR.new"
@@ -55,7 +62,8 @@ mv "$APP_DIR.new" "$APP_DIR"
 rm -rf "$APP_DIR.old"
 log "installed bundle to $APP_DIR"
 
-NODE="$APP_DIR/vendor/node-darwin-arm64/bin/node"
+NODE="$APP_DIR/vendor/node-darwin-$NODE_ARCH/bin/node"
+[ -x "$NODE" ] || NODE="$APP_DIR/vendor/node-darwin-arm64/bin/node"
 SERVER="$APP_DIR/dist/index.js"
 SAFE_PATH="/opt/homebrew/bin:/usr/local/bin:/usr/bin:/bin"
 

package/scripts/link_tail.py

@@ -35,6 +35,18 @@ Usage (CLI / from twitter_post_plan.py):
         --project "studyly" \\
         --platform "twitter"
 
+    # 'name' CTA arm (twitter-tail-cta experiment, launched 2026-08-08): end
+    # the bridge with the PLAIN product name instead of a tracked URL. No link,
+    # not clickable — intentional. Requires --product-name (or a resolvable
+    # config.json entry for --project); no --link-url is used.
+    python3 link_tail.py \\
+        --reply-text "Step 2 CK was the one that burned me out worst..." \\
+        --cta-mode name \\
+        --product-name "Studyly" \\
+        --thread-text "huge milestone, just passed step 2..." \\
+        --project "studyly" \\
+        --platform "twitter"
+
 Stdout (single JSON object):
     {"ok": true, "text": "<reply_text with bridge tail + URL>",
      "tail": "<just the bridge sentence with URL>",
@@ -137,6 +149,26 @@ def enforce_budget(text: str, link_url: str,
     return _trim_to_chars(text, limit), True
 
 
+def enforce_budget_name(text: str, product_name: str,
+                        limit: int = TWEET_LIMIT) -> tuple[str, bool]:
+    """Name-arm analogue of enforce_budget: guarantee x_weighted_len(text) <=
+    limit by trimming the BODY, never the trailing plain product name. Unlike
+    the URL arm there is no flat t.co weighting — the product name counts as
+    its own real length. Returns (text, was_trimmed)."""
+    if x_weighted_len(text) <= limit:
+        return text, False
+    stripped = text.rstrip()
+    if product_name and stripped.endswith(product_name):
+        head = stripped[: stripped.rfind(product_name)].rstrip()
+        # Budget left for the body after reserving the product name + a joining
+        # space.
+        max_head = limit - x_weighted_len(product_name) - 1
+        trimmed_head = _trim_to_chars(head, max_head)
+        return (trimmed_head + " " + product_name).strip(), True
+    # No product name at the tail (shouldn't happen): hard word-trim.
+    return _trim_to_chars(text, limit), True
+
+
 def _load_project_entry(project: str) -> dict:
     """Load the matched project's raw config.json entry (case-insensitive
     name match), or {} if config.json is unreadable or the project is
@@ -174,6 +206,28 @@ def resolve_learned_preferences_block(project_entry: dict) -> str:
     no entries yet."""
     return learned_preferences.prompt_block(project_entry)
 
+
+def resolve_product_name(project_entry: dict, override: str | None,
+                         project: str = "") -> str:
+    """Plain-text product name for the 'name' CTA arm (twitter-tail-cta).
+
+    Priority: an explicit --product-name override, then the config.json
+    entry's `product_name`, then its `name`, then a title-cased fallback
+    derived from the --project arg (so we always have SOMETHING to plant even
+    for a project missing from config.json). The name arm has nothing to
+    append otherwise, so this deliberately never returns empty when a project
+    string is present.
+    """
+    if override and override.strip():
+        return override.strip()
+    pn = (project_entry.get("product_name") or "").strip()
+    if pn:
+        return pn
+    nm = (project_entry.get("name") or "").strip()
+    if nm:
+        return nm
+    return (project or "").replace("_", " ").replace("-", " ").strip().title()
+
 # Paths to the Claude Code CLI in order of preference. run_claude.sh resolves
 # `claude` from PATH; we fall back to a direct nvm path if PATH lookup fails
 # (twitter_post_plan.py is invoked from a launchd shell that may have a thin
@@ -207,9 +261,18 @@ def build_prompt(*, reply_text: str, link_url: str, thread_text: str,
                  project: str, platform: str,
                  voice_relationship: str = "first_party",
                  learned_prefs_block: str = "",
-                 bridge_budget: int | None = None) -> str:
+                 bridge_budget: int | None = None,
+                 cta_mode: str = "url", product_name: str = "") -> str:
     """Compose the one-shot prompt for the bridge sentence ONLY.
 
+    `cta_mode` selects how the bridge ENDS (twitter-tail-cta experiment,
+    launched 2026-08-08):
+      - "url"  (default): the sentence ends with the tracked landing-page URL,
+        the historical behavior — unchanged, byte-for-byte.
+      - "name": the sentence ends with the PLAIN product name (`product_name`)
+        as ordinary text, NOT a link. No URL, no "http", no domain. This plants
+        brand awareness without spending a raw tracked link's engagement cost.
+
     The model is never asked to reproduce or rewrite the reply already
     drafted; it's shown that text for context and told explicitly not to
     repeat it. main() appends whatever comes back to the UNMODIFIED
@@ -256,6 +319,21 @@ def build_prompt(*, reply_text: str, link_url: str, thread_text: str,
             f"  - \"we ship the same recall-on-revisit pattern in {project}, scores against a 4-axis rubric, {link_url}\""
         )
 
+    # Name arm: replace the URL-ending example sentences with product-NAME-ending
+    # ones (voice-matched, same form). The bridge must END with the plain
+    # product name as ordinary text \u2014 no URL anywhere.
+    if cta_mode == "name":
+        if voice_relationship == "third_party":
+            example_block = (
+                f"  - \"fwiw the rubric scoring on rephrased stems is what {project} ships, {product_name}\"\n"
+                f"  - \"same recall-on-revisit pattern, scored against a 4-axis rubric, that's {product_name}\""
+            )
+        else:
+            example_block = (
+                f"  - \"fwiw the rubric scoring on rephrased stems is what we built {product_name} for\"\n"
+                f"  - \"we ship the same recall-on-revisit pattern, scored against a 4-axis rubric, in {product_name}\""
+            )
+
     # X-specific hard length budget. The reply's body is FIXED (never resized
     # by the model); only the bridge sentence's own budget matters, computed
     # by the caller from how much room the already-drafted body leaves.
@@ -263,14 +341,23 @@ def build_prompt(*, reply_text: str, link_url: str, thread_text: str,
     # no tight cap there.
     length_rule = ""
     if platform == "twitter" and bridge_budget is not None:
-        length_rule = (
-            f"HARD LENGTH LIMIT for YOUR SENTENCE ONLY (X counts EVERY link as "
-            f"exactly {URL_WEIGHT} characters, no matter how long it looks; "
-            f"that's already reserved below):\n"
-            f"- Everything you write BEFORE the URL must be \u2264 {max(bridge_budget, 0)} "
-            f"characters. The reply above is fixed length; you are not resizing "
-            f"it, only adding a short sentence after it.\n"
-        )
+        if cta_mode == "name":
+            length_rule = (
+                f"HARD LENGTH LIMIT for YOUR SENTENCE ONLY:\n"
+                f"- Everything you write, INCLUDING the product name at the end, "
+                f"must be \u2264 {max(bridge_budget, 0)} characters. The reply above is "
+                f"fixed length; you are not resizing it, only adding a short "
+                f"sentence after it.\n"
+            )
+        else:
+            length_rule = (
+                f"HARD LENGTH LIMIT for YOUR SENTENCE ONLY (X counts EVERY link as "
+                f"exactly {URL_WEIGHT} characters, no matter how long it looks; "
+                f"that's already reserved below):\n"
+                f"- Everything you write BEFORE the URL must be \u2264 {max(bridge_budget, 0)} "
+                f"characters. The reply above is fixed length; you are not resizing "
+                f"it, only adding a short sentence after it.\n"
+            )
 
     learned_prefs_section = ""
     if learned_prefs_block:
@@ -284,6 +371,42 @@ def build_prompt(*, reply_text: str, link_url: str, thread_text: str,
             "your job here.\n"
         )
 
+    if cta_mode == "name":
+        return f"""You are writing ONLY the bridge sentence that gets APPENDED after a social media reply we already drafted (shown below). This is a one-shot task. Output ONLY the bridge sentence itself: no preamble, no explanation, no quotes, and do NOT repeat, paraphrase, or rewrite any part of the reply below \u2014 it is already final and will be appended before your output automatically, verbatim.
+
+PLATFORM: {platform}
+PROJECT: {project}
+PRODUCT NAME: {product_name}
+
+{voice_rule}
+
+{learned_prefs_section}
+
+{length_rule}
+
+ORIGINAL THREAD WE ARE REPLYING TO:
+{thread_text}
+
+REPLY ALREADY DRAFTED (fixed, DO NOT repeat or modify \u2014 your sentence is appended after this automatically):
+{reply_text}
+
+YOUR TASK:
+Write ONE bridge sentence (\u2264 22 words) that:
+  1. References the SINGLE strongest specific claim, mechanism, or detail from the reply above (e.g. "rephrasing on revisit", "a 4-axis rubric", "200ms p95", "automatic distractor scoring") \u2014 pick ONE concrete thing, not a category.
+  2. Names a CONCRETE PRODUCT MECHANISM that delivers it (verb + noun, inferred from the project context). Do NOT say "a tool for this", "something that helps", "made this for it" \u2014 those are banned.
+  3. Ends with the plain product name "{product_name}" written as ORDINARY TEXT \u2014 NOT a link. This is intentional and required: do NOT include any URL, any "http" or "https", any "www", and no domain (nothing that looks like "name.com" / "name.io"). No "click here", "check it out", "give it a try".
+  4. Reads in the voice of the reply above (lowercase if reply is lowercase, casual if reply is casual).
+  5. Obeys the VOICE RELATIONSHIP rule above. This rule overrides any default phrasing instinct.
+  6. Obeys the LEARNED PREFERENCES above when present. This rule overrides the example sentences below on conflict.
+
+OUTPUT FORMAT (strict):
+Output ONLY your bridge sentence, ending in the plain product name "{product_name}", on a single line. Nothing else: no JSON, no markdown, no quotes, no URL, and absolutely none of the reply text shown above.
+
+Example bridge sentences (do NOT copy verbatim \u2014 these are FORM examples, voice-matched to this project, each ending in the product NAME, no link):
+{example_block}
+
+Write the bridge sentence now."""
+
     return f"""You are writing ONLY the bridge sentence that gets APPENDED after a social media reply we already drafted (shown below). This is a one-shot task. Output ONLY the bridge sentence itself: no preamble, no explanation, no quotes, and do NOT repeat, paraphrase, or rewrite any part of the reply below \u2014 it is already final and will be appended before your output automatically, verbatim.
 
 PLATFORM: {platform}
@@ -465,9 +588,15 @@ THIRD_PARTY_VOICE_VIOLATIONS = (
 )
 
 
-def passes_quality_gate(bridge: str, link_url: str,
+# Name-arm URL guards: the 'name' CTA must NOT contain any link. Reject a
+# full URL or a bare domain (so the model can't sneak the tracked link back in
+# under the product-name arm).
+_BARE_DOMAIN_RE = re.compile(r"\b[a-z0-9-]+\.[a-z]{2,}\b", re.IGNORECASE)
+
+
+def passes_quality_gate(bridge: str, mention: str, *,
                         voice_relationship: str = "first_party",
-                        ) -> tuple[bool, str]:
+                        cta_mode: str = "url") -> tuple[bool, str]:
     """Return (passes, reason_if_not).
 
     Validates the model-written BRIDGE SENTENCE ALONE. reply_text is trusted,
@@ -475,28 +604,53 @@ def passes_quality_gate(bridge: str, link_url: str,
     the append-only contract means reply_text can't fail this gate, only the
     newly generated bridge can.
 
-    Hard rules:
-      - must contain link_url
-      - must end with link_url (allow trailing whitespace, nothing else)
+    `mention` is the CTA target the bridge must end with: the landing-page URL
+    in url mode, the plain product name in name mode.
+
+    url-mode hard rules (unchanged):
+      - must contain the URL
+      - must end with the URL (allow trailing whitespace, nothing else)
       - must NOT contain banned phrases
-      - must not be wildly longer than a sentence (MAX_BRIDGE_CHARS): the
-        model ignored the "bridge sentence only" contract and is attempting
-        a full rewrite — a structural violation, not a phrasing nitpick
+      - must not be wildly longer than a sentence (MAX_BRIDGE_CHARS)
       - on third_party projects, must NOT use first-person-plural product
-        ownership phrases ("we ship", "we built", "our product", ...). The
-        link_tail prompt selects voice-matched examples but the model can
-        still drift; on violation we fall back to the mechanical concat so
-        the post still ships without impersonating the client (root cause of
-        the 2026-05-27 Agora OODAO incident).
+        ownership phrases (root cause of the 2026-05-27 Agora OODAO incident).
+
+    name-mode hard rules:
+      - must CONTAIN the product name
+      - must NOT contain any URL or bare domain (the model may not smuggle the
+        tracked link back into the no-link arm)
+      - same banned-phrase, third_party-voice, and MAX_BRIDGE_CHARS checks.
     """
     if not bridge:
         return (False, "empty")
-    if link_url not in bridge:
+
+    if cta_mode == "name":
+        if mention and mention not in bridge:
+            return (False, "no_product_name")
+        if re.search(r"https?://", bridge, re.IGNORECASE):
+            return (False, "url_in_name_arm")
+        if _BARE_DOMAIN_RE.search(bridge):
+            return (False, "domain_in_name_arm")
+        lower = bridge.lower()
+        for phrase in BANNED_PHRASES:
+            if phrase in lower:
+                return (False, f"banned_phrase: {phrase!r}")
+        if voice_relationship == "third_party":
+            for rx in THIRD_PARTY_VOICE_VIOLATIONS:
+                m = rx.search(bridge)
+                if m:
+                    return (False, f"third_party_voice_violation: {m.group(0)!r}")
+        if len(bridge) > MAX_BRIDGE_CHARS:
+            return (False, f"bridge_too_long:{len(bridge)}>{MAX_BRIDGE_CHARS}")
+        return (True, "")
+
+    # url mode (mention == link_url) — behavior unchanged.
+    if mention not in bridge:
         return (False, "no_url")
     # Trailing-URL check (nothing meaningful after URL, optional ./! is fine
     # to strip; but our prompt forbids trailing period — so just check no
     # alphanumeric content follows).
-    tail = bridge.split(link_url, 1)[1].strip()
+    tail = bridge.split(mention, 1)[1].strip()
     if tail and re.search(r"[A-Za-z0-9]", tail):
         return (False, f"content_after_url: {tail[:40]!r}")
     lower = bridge.lower()
@@ -519,12 +673,26 @@ def mechanical_fallback(reply_text: str, link_url: str) -> str:
     return f"{reply_text} {link_url}".strip() if link_url else reply_text
 
 
+def mechanical_fallback_name(reply_text: str, product_name: str) -> str:
+    """Name-arm analogue of mechanical_fallback: append the plain product name
+    (no URL) when the model call is skipped or fails."""
+    return f"{reply_text} {product_name}".strip() if product_name else reply_text
+
+
 def main() -> int:
     ap = argparse.ArgumentParser()
     ap.add_argument("--reply-text", required=True,
                     help="The reply we already drafted (no link).")
-    ap.add_argument("--link-url", required=True,
-                    help="The landing page URL to fold in.")
+    ap.add_argument("--link-url", default="",
+                    help="The landing page URL to fold in (url mode).")
+    ap.add_argument("--cta-mode", default="url", choices=["url", "name"],
+                    help="How the bridge ends: 'url' (tracked landing-page "
+                         "link, default) or 'name' (plain product name, no "
+                         "URL — twitter-tail-cta experiment).")
+    ap.add_argument("--product-name", default=None,
+                    help="Override the product name used in the 'name' CTA "
+                         "arm. Defaults to config.json product_name/name for "
+                         "--project, else a title-cased --project slug.")
     ap.add_argument("--thread-text", default="",
                     help="The original thread / tweet we are replying to.")
     ap.add_argument("--project", required=True,
@@ -542,19 +710,51 @@ def main() -> int:
                     help="Skip run_claude.sh; call claude directly. For testing.")
     args = ap.parse_args()
 
+    cta_mode = args.cta_mode
     reply_text = (args.reply_text or "").strip()
     link_url = (args.link_url or "").strip()
-    if not reply_text or not link_url:
-        # Garbage in → mechanical concat (which respects empty link_url).
-        out = {
+    project_entry = _load_project_entry(args.project)
+    product_name = ""
+    if cta_mode == "name":
+        product_name = resolve_product_name(
+            project_entry, args.product_name, args.project)
+    # `mention` is the CTA target the bridge must end with, threaded through
+    # every output/fallback path: the URL in url mode, the product name in
+    # name mode.
+    mention = product_name if cta_mode == "name" else link_url
+
+    def _mech() -> str:
+        return (mechanical_fallback_name(reply_text, product_name)
+                if cta_mode == "name"
+                else mechanical_fallback(reply_text, link_url))
+
+    def _enforce(text: str, lim: int) -> tuple[str, bool]:
+        if cta_mode == "name":
+            return enforce_budget_name(text, product_name, lim)
+        return enforce_budget(text, link_url, lim)
+
+    def _emit(out: dict) -> None:
+        # Stamp the CTA mode on every object; name mode also carries the
+        # product name under "mention" for downstream logging.
+        out["cta_mode"] = cta_mode
+        if cta_mode == "name":
+            out["mention"] = product_name
+        print(json.dumps(out), flush=True)
+
+    # url mode requires reply_text + link_url; name mode requires
+    # reply_text + product_name.
+    missing = (not reply_text) or (
+        (not product_name) if cta_mode == "name" else (not link_url))
+    if missing:
+        # Garbage in → mechanical concat (respects an empty CTA target).
+        _emit({
             "ok": True,
-            "text": mechanical_fallback(reply_text, link_url),
-            "tail": link_url,
+            "text": _mech(),
+            "tail": mention,
             "model_call_ok": False,
             "fallback_used": True,
             "error": "missing_input",
-        }
-        print(json.dumps(out), flush=True)
+        })
         return 0
 
     # Plugin (MCP approve_drafts) flow sets S4L_SKIP_LINK_TAIL=1. The bridge only
@@ -567,50 +767,50 @@ def main() -> int:
     # the bridge sentence.
     if os.environ.get("S4L_SKIP_LINK_TAIL") == "1":
         limit = TWEET_LIMIT if args.platform == "twitter" else None
-        fb_text, fb_trim = enforce_budget(
-            mechanical_fallback(reply_text, link_url), link_url,
-            limit if limit is not None else TWEET_LIMIT * 100)
-        out = {
+        fb_text, fb_trim = _enforce(
+            _mech(), limit if limit is not None else TWEET_LIMIT * 100)
+        _emit({
             "ok": True,
             "text": fb_text,
-            "tail": link_url,
+            "tail": mention,
             "model_call_ok": False,
             "fallback_used": True,
             "budget_trimmed": fb_trim,
             "error": "skipped_plugin_flow",
             "elapsed_sec": 0.0,
-        }
-        print(json.dumps(out), flush=True)
+        })
         return 0
 
-    project_entry = _load_project_entry(args.project)
     voice_relationship = args.voice_relationship or resolve_voice_relationship(project_entry)
     learned_prefs_block = resolve_learned_preferences_block(project_entry)
     # Length cap is X-specific; reddit/linkedin pass None (no tail trim).
     limit = TWEET_LIMIT if args.platform == "twitter" else None
 
     # Deterministic no-room guard: if the already-drafted reply alone leaves
-    # no meaningful space for a bridge sentence before the (flat-weighted)
-    # URL, skip the Claude call outright — a squeezed-in fragment is worse
-    # than no bridge — and fall back to the mechanical concat like any other
-    # failure path.
+    # no meaningful space for a bridge sentence before the CTA target, skip
+    # the Claude call outright — a squeezed-in fragment is worse than no
+    # bridge — and fall back to the mechanical concat like any other failure
+    # path. url mode reserves the flat 23-char URL weight; name mode reserves
+    # the product name's real length.
     bridge_budget = None
     if limit is not None:
-        bridge_budget = limit - URL_WEIGHT - 1 - x_weighted_len(reply_text)
+        if cta_mode == "name":
+            bridge_budget = (limit - x_weighted_len(product_name) - 1
+                             - x_weighted_len(reply_text))
+        else:
+            bridge_budget = limit - URL_WEIGHT - 1 - x_weighted_len(reply_text)
         if bridge_budget < MIN_BRIDGE_CHARS:
-            fb_text, fb_trim = enforce_budget(
-                mechanical_fallback(reply_text, link_url), link_url, limit)
-            out = {
+            fb_text, fb_trim = _enforce(_mech(), limit)
+            _emit({
                 "ok": True,
                 "text": fb_text,
-                "tail": link_url,
+                "tail": mention,
                 "model_call_ok": False,
                 "fallback_used": True,
                 "budget_trimmed": fb_trim,
                 "error": f"no_room_for_bridge:{bridge_budget}",
                 "elapsed_sec": 0.0,
-            }
-            print(json.dumps(out), flush=True)
+            })
             return 0
 
     prompt = build_prompt(
@@ -620,6 +820,7 @@ def main() -> int:
         voice_relationship=voice_relationship,
         learned_prefs_block=learned_prefs_block,
         bridge_budget=bridge_budget,
+        cta_mode=cta_mode, product_name=product_name,
     )
 
     started = time.time()
@@ -628,41 +829,38 @@ def main() -> int:
     elapsed = round(time.time() - started, 2)
 
     if not ok:
-        fb_text, fb_trim = enforce_budget(
-            mechanical_fallback(reply_text, link_url), link_url,
-            limit if limit is not None else TWEET_LIMIT * 100)
-        out = {
+        fb_text, fb_trim = _enforce(
+            _mech(), limit if limit is not None else TWEET_LIMIT * 100)
+        _emit({
             "ok": True,
             "text": fb_text,
-            "tail": link_url,
+            "tail": mention,
             "model_call_ok": False,
             "fallback_used": True,
             "budget_trimmed": fb_trim,
             "error": err or "model_call_failed",
             "elapsed_sec": elapsed,
-        }
-        print(json.dumps(out), flush=True)
+        })
         return 0
 
     bridge = clean_output(raw)
-    passes, reason = passes_quality_gate(bridge, link_url,
-                                         voice_relationship=voice_relationship)
+    passes, reason = passes_quality_gate(
+        bridge, mention, voice_relationship=voice_relationship,
+        cta_mode=cta_mode)
     if not passes:
-        fb_text, fb_trim = enforce_budget(
-            mechanical_fallback(reply_text, link_url), link_url,
-            limit if limit is not None else TWEET_LIMIT * 100)
-        out = {
+        fb_text, fb_trim = _enforce(
+            _mech(), limit if limit is not None else TWEET_LIMIT * 100)
+        _emit({
             "ok": True,
             "text": fb_text,
-            "tail": link_url,
+            "tail": mention,
             "model_call_ok": True,
             "fallback_used": True,
             "budget_trimmed": fb_trim,
             "error": f"quality_gate_failed:{reason}",
             "raw_model_output": raw[:500],
             "elapsed_sec": elapsed,
-        }
-        print(json.dumps(out), flush=True)
+        })
         return 0
 
     # Successful path: append the model-written bridge to the UNMODIFIED
@@ -674,12 +872,12 @@ def main() -> int:
     if limit is not None:
         # Belt-and-suspenders: should be a no-op given the bridge_budget
         # precheck above, unless the model ignored the length rule. Trims
-        # from the END of the pre-URL text (the model's own bridge, appended
+        # from the END of the pre-CTA text (the model's own bridge, appended
         # last), so a well-behaved reply_text is only touched in the
         # degenerate case where reply_text alone already exceeds the limit.
-        final_text, budget_trimmed = enforce_budget(final_text, link_url, limit)
+        final_text, budget_trimmed = _enforce(final_text, limit)
 
-    out = {
+    _emit({
         "ok": True,
         "text": final_text,
         "tail": bridge,
@@ -687,8 +885,7 @@ def main() -> int:
         "fallback_used": False,
         "budget_trimmed": budget_trimmed,
         "elapsed_sec": elapsed,
-    }
-    print(json.dumps(out), flush=True)
+    })
     return 0
 
 

package/scripts/release-mcpb.sh

@@ -386,20 +386,18 @@ console.log('  manifest tools ('+tools.length+'): '+tools.map(t=>t.name).join(',
 # dependency on Desktop's internal behavior entirely: manifest.json's command now
 # points at this vendored binary's absolute path, so every session type — main
 # chat, agent-mode, any future session type — spawns the SAME real binary.
-# macOS arm64 only for now (matches every deployed box); revisit if x64 support
-# is ever needed.
+# Both macOS arches since 1.7.9: arm64 (every deployed box) AND x64 (Intel Macs
+# still on Tahoe). mcp/launch.js picks the arch-matched binary at spawn time.
 NODE_RUNTIME_VERSION="v24.18.0"
-NODE_RUNTIME_PLATFORM="darwin-arm64"
-NODE_VENDOR_DIR="$MCP_DIR/vendor/node-$NODE_RUNTIME_PLATFORM"
-NODE_VENDOR_BIN="$NODE_VENDOR_DIR/bin/node"
+NODE_RUNTIME_PLATFORMS="darwin-arm64 darwin-x64"
 NODE_CACHE_DIR="$REPO_ROOT/.cache/node-runtime"
-# Can THIS build host execute the vendored target binary? The .mcpb always
-# vendors darwin-arm64 (that is where it runs), but the release itself is cut
-# from CI on linux-x64. Executing a darwin-arm64 node on a linux-x64 runner is
-# an `Exec format error` (exit 126) -- what broke every rc from 1.7.6-rc.11 on.
-# Run the exec-based `--version` sanity checks ONLY when the host os/arch matches
-# the vendored target; otherwise verify by presence + executable bit, which is
-# all a cross-build can honestly assert.
+# Can THIS build host execute a given vendored binary? The release may be cut
+# from CI on linux-x64, or from an arm64 Mac that cannot exec the x64 node
+# natively (Rosetta usually covers it, but do not depend on that). Executing a
+# foreign-arch node is an `Exec format error` (exit 126) -- what broke every rc
+# from 1.7.6-rc.11 on. Run the exec-based `--version` sanity checks ONLY when
+# the host os/arch matches the vendored target; otherwise verify by presence +
+# executable bit, which is all a cross-build can honestly assert.
 case "$(uname -s)" in
   Darwin) HOST_OS="darwin" ;;
   Linux)  HOST_OS="linux" ;;
@@ -410,40 +408,40 @@ case "$(uname -m)" in
   x86_64|amd64)  HOST_ARCH="x64" ;;
   *)             HOST_ARCH="unknown" ;;
 esac
-if [[ "$HOST_OS-$HOST_ARCH" == "$NODE_RUNTIME_PLATFORM" ]]; then
-  HOST_CAN_EXEC_VENDORED_NODE=1
-else
-  HOST_CAN_EXEC_VENDORED_NODE=0
-fi
-say "Vendoring Node $NODE_RUNTIME_VERSION ($NODE_RUNTIME_PLATFORM) for the .mcpb"
-if [[ ! -x "$NODE_VENDOR_BIN" ]]; then
-  NODE_TARBALL="node-$NODE_RUNTIME_VERSION-$NODE_RUNTIME_PLATFORM.tar.gz"
-  NODE_CACHED_TARBALL="$NODE_CACHE_DIR/$NODE_TARBALL"
-  mkdir -p "$NODE_CACHE_DIR"
-  if [[ ! -f "$NODE_CACHED_TARBALL" ]]; then
-    say "  downloading $NODE_TARBALL (not cached)"
-    curl -sL "https://nodejs.org/dist/$NODE_RUNTIME_VERSION/$NODE_TARBALL" -o "$NODE_CACHED_TARBALL.tmp" \
-      || die "Node download failed"
-    mv "$NODE_CACHED_TARBALL.tmp" "$NODE_CACHED_TARBALL"
+host_can_exec() { [[ "$HOST_OS-$HOST_ARCH" == "$1" ]]; }
+for NODE_RUNTIME_PLATFORM in $NODE_RUNTIME_PLATFORMS; do
+  NODE_VENDOR_DIR="$MCP_DIR/vendor/node-$NODE_RUNTIME_PLATFORM"
+  NODE_VENDOR_BIN="$NODE_VENDOR_DIR/bin/node"
+  say "Vendoring Node $NODE_RUNTIME_VERSION ($NODE_RUNTIME_PLATFORM) for the .mcpb"
+  if [[ ! -x "$NODE_VENDOR_BIN" ]]; then
+    NODE_TARBALL="node-$NODE_RUNTIME_VERSION-$NODE_RUNTIME_PLATFORM.tar.gz"
+    NODE_CACHED_TARBALL="$NODE_CACHE_DIR/$NODE_TARBALL"
+    mkdir -p "$NODE_CACHE_DIR"
+    if [[ ! -f "$NODE_CACHED_TARBALL" ]]; then
+      say "  downloading $NODE_TARBALL (not cached)"
+      curl -sL "https://nodejs.org/dist/$NODE_RUNTIME_VERSION/$NODE_TARBALL" -o "$NODE_CACHED_TARBALL.tmp" \
+        || die "Node download failed"
+      mv "$NODE_CACHED_TARBALL.tmp" "$NODE_CACHED_TARBALL"
+    else
+      say "  using cached $NODE_CACHED_TARBALL"
+    fi
+    rm -rf "$NODE_VENDOR_DIR"
+    mkdir -p "$NODE_VENDOR_DIR/bin"
+    # Extract ONLY the node binary itself (no npm/npx/corepack — the server is
+    # invoked directly as `node dist/index.js`, nothing here ever needs npm).
+    tar -xzf "$NODE_CACHED_TARBALL" -O "node-$NODE_RUNTIME_VERSION-$NODE_RUNTIME_PLATFORM/bin/node" > "$NODE_VENDOR_BIN" \
+      || die "failed to extract node binary from $NODE_CACHED_TARBALL"
+    chmod +x "$NODE_VENDOR_BIN"
+  fi
+  [[ -x "$NODE_VENDOR_BIN" ]] || die "vendored node binary missing/not executable at $NODE_VENDOR_BIN"
+  if host_can_exec "$NODE_RUNTIME_PLATFORM"; then
+    VENDORED_NODE_VER="$("$NODE_VENDOR_BIN" --version)"
+    [[ "$VENDORED_NODE_VER" == "$NODE_RUNTIME_VERSION" ]] || die "vendored node reports $VENDORED_NODE_VER, expected $NODE_RUNTIME_VERSION"
+    echo "  vendored node: $VENDORED_NODE_VER at mcp/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node ($(du -h "$NODE_VENDOR_BIN" | cut -f1))"
   else
-    say "  using cached $NODE_CACHED_TARBALL"
+    echo "  vendored node: present at mcp/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node ($(du -h "$NODE_VENDOR_BIN" | cut -f1)); --version self-check skipped (host $HOST_OS-$HOST_ARCH cannot exec $NODE_RUNTIME_PLATFORM)"
   fi
-  rm -rf "$NODE_VENDOR_DIR"
-  mkdir -p "$NODE_VENDOR_DIR/bin"
-  # Extract ONLY the node binary itself (no npm/npx/corepack — the server is
-  # invoked directly as `node dist/index.js`, nothing here ever needs npm).
-  tar -xzf "$NODE_CACHED_TARBALL" -O "node-$NODE_RUNTIME_VERSION-$NODE_RUNTIME_PLATFORM/bin/node" > "$NODE_VENDOR_BIN" \
-    || die "failed to extract node binary from $NODE_CACHED_TARBALL"
-  chmod +x "$NODE_VENDOR_BIN"
-fi
-[[ -x "$NODE_VENDOR_BIN" ]] || die "vendored node binary missing/not executable at $NODE_VENDOR_BIN"
-if [[ "$HOST_CAN_EXEC_VENDORED_NODE" == "1" ]]; then
-  VENDORED_NODE_VER="$("$NODE_VENDOR_BIN" --version)"
-  [[ "$VENDORED_NODE_VER" == "$NODE_RUNTIME_VERSION" ]] || die "vendored node reports $VENDORED_NODE_VER, expected $NODE_RUNTIME_VERSION"
-  echo "  vendored node: $VENDORED_NODE_VER at mcp/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node ($(du -h "$NODE_VENDOR_BIN" | cut -f1))"
-else
-  echo "  vendored node: present at mcp/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node ($(du -h "$NODE_VENDOR_BIN" | cut -f1)); --version self-check skipped (host $HOST_OS-$HOST_ARCH cannot exec $NODE_RUNTIME_PLATFORM)"
-fi
+done
 
 # ---- 4. Pack the .mcpb ------------------------------------------------------
 say "Packing $BUNDLE"
@@ -493,31 +491,55 @@ for sub in mcp/dist/version.json mcp/package.json; do
   echo "  pipeline.tgz $sub: $SUBV ok"
 done
 
-for f in "dist/index.js" "dist/runtime.js" "manifest.json" "vendor/node-$NODE_RUNTIME_PLATFORM/bin/node"; do
+REQUIRED_FILES="dist/index.js dist/runtime.js manifest.json launch.js"
+for p in $NODE_RUNTIME_PLATFORMS; do
+  REQUIRED_FILES="$REQUIRED_FILES vendor/node-$p/bin/node"
+done
+for f in $REQUIRED_FILES; do
   # grep -c reads all input (no SIGPIPE); anchor on the time column + 3-space
   # gutter so node_modules/.../dist/index.js does not false-match the top-level.
   n=$(printf '%s\n' "$LISTING" | grep -c "[0-9:]   $f\$" || true)
   [[ "$n" -ge 1 ]] || die "bundle missing $f"
 done
-echo "  runtime + server + manifest + vendored node: ok"
+echo "  runtime + server + manifest + launcher + vendored node (both arches): ok"
+
+# The compat gate inside Claude Desktop only recognizes a node-type extension
+# when mcp_config.command is the bare string "node" or a path ending in .js
+# (its fo() command-recognizer). Pointing at the vendored node BINARY shipped
+# "this extension is incompatible" to every Mac without a system Node.js
+# (first hit: new-user install, 2026-08-10). Guard the manifest shape so a
+# future edit cannot silently regress it.
+MANIFEST_CMD=$(unzip -p "$BUNDLE" manifest.json 2>/dev/null | node -p "JSON.parse(require('fs').readFileSync(0,'utf8')).server.mcp_config.command" 2>/dev/null || echo "?")
+case "$MANIFEST_CMD" in
+  node|node.exe|*.js) echo "  manifest command Desktop-recognizable ($MANIFEST_CMD): ok" ;;
+  *) die "manifest mcp_config.command '$MANIFEST_CMD' is not recognizable by Claude Desktop's node compat gate (must be 'node' or end in .js); Macs without system Node.js will see 'incompatible' at install" ;;
+esac
 
-# The vendored binary must survive the zip round-trip with its executable bit
-# intact (unzip -x extracts to a temp file and runs --version; a permissions
-# regression here would silently produce a Node that Desktop can spawn but that
-# refuses to execute, or vice versa).
+# The vendored binaries and the launcher must survive the zip round-trip with
+# their executable bits intact (extract to a temp dir and run --version where
+# the host arch allows; a permissions regression here would silently produce a
+# Node that Desktop can spawn but that refuses to execute, or a launch.js that
+# agent-mode cannot exec).
 VENDOR_CHECK_DIR="$(mktemp -d)"
-unzip -q -o "$BUNDLE" "vendor/node-$NODE_RUNTIME_PLATFORM/bin/node" -d "$VENDOR_CHECK_DIR"
-VENDOR_CHECK_BIN="$VENDOR_CHECK_DIR/vendor/node-$NODE_RUNTIME_PLATFORM/bin/node"
-[[ -x "$VENDOR_CHECK_BIN" ]] || die "vendored node in bundle lost its executable bit"
-if [[ "$HOST_CAN_EXEC_VENDORED_NODE" == "1" ]]; then
-  VENDOR_CHECK_VER="$("$VENDOR_CHECK_BIN" --version)"
-  [[ "$VENDOR_CHECK_VER" == "$NODE_RUNTIME_VERSION" ]] || die "vendored node in bundle reports $VENDOR_CHECK_VER, expected $NODE_RUNTIME_VERSION"
-  rm -rf "$VENDOR_CHECK_DIR"
-  echo "  vendored node runs from bundle: $VENDOR_CHECK_VER ok"
-else
-  rm -rf "$VENDOR_CHECK_DIR"
-  echo "  vendored node survives bundle round-trip with exec bit intact; --version run skipped (host $HOST_OS-$HOST_ARCH cannot exec $NODE_RUNTIME_PLATFORM)"
-fi
+for p in $NODE_RUNTIME_PLATFORMS; do
+  unzip -q -o "$BUNDLE" "vendor/node-$p/bin/node" -d "$VENDOR_CHECK_DIR"
+  VENDOR_CHECK_BIN="$VENDOR_CHECK_DIR/vendor/node-$p/bin/node"
+  [[ -x "$VENDOR_CHECK_BIN" ]] || die "vendored node ($p) in bundle lost its executable bit"
+  if host_can_exec "$p"; then
+    VENDOR_CHECK_VER="$("$VENDOR_CHECK_BIN" --version)"
+    [[ "$VENDOR_CHECK_VER" == "$NODE_RUNTIME_VERSION" ]] || die "vendored node ($p) in bundle reports $VENDOR_CHECK_VER, expected $NODE_RUNTIME_VERSION"
+    echo "  vendored node ($p) runs from bundle: $VENDOR_CHECK_VER ok"
+  else
+    echo "  vendored node ($p) survives bundle round-trip with exec bit intact; --version run skipped (host $HOST_OS-$HOST_ARCH cannot exec $p)"
+  fi
+done
+unzip -q -o "$BUNDLE" "launch.js" -d "$VENDOR_CHECK_DIR"
+LAUNCH_CHECK="$VENDOR_CHECK_DIR/launch.js"
+[[ -x "$LAUNCH_CHECK" ]] || die "launch.js in bundle lost its executable bit (agent-mode literal spawn would fail)"
+head -c 9 "$LAUNCH_CHECK" | grep -q '^#!/bin/sh' || die "launch.js in bundle is missing its #!/bin/sh shebang"
+node --check "$LAUNCH_CHECK" || die "launch.js in bundle is not valid JavaScript (Desktop built-in-node spawn would fail)"
+rm -rf "$VENDOR_CHECK_DIR"
+echo "  launch.js: exec bit + shebang + JS syntax ok"
 
 if [[ "$DO_RELEASE" == "0" ]]; then
   say "Done (--no-release). Bundle ready at: $BUNDLE"

package/scripts/twitter_gen_links.py

@@ -143,21 +143,64 @@ def parse_last_json_object(text):
 
 
 def _tail_link_rate() -> float:
+    # "Add a tail at all?" gate. Default 1.0 since 2026-08-08: the old
+    # link-vs-no_link A/B concluded that day (no_link won engagement but the
+    # link arm bought clicks), and its successor — twitter-tail-cta (link vs
+    # plain product name) — assumes EVERY promo post gets a tail, differing
+    # only in HOW it ends. So promo posts now always get a tail; the
+    # personal_brand lane still forces no tail via its own
+    # TWITTER_TAIL_LINK_RATE=0 export, and setting the var to 0.0 anywhere
+    # still disables tails entirely.
+    #
     # DRAFT_ONLY=1 candidates always go through a human-approval review card
     # (run-draft-and-publish.sh exports DRAFT_ONLY before invoking the cycle
     # that calls this script). Force rate=1.0 there so a hand-approved draft
-    # never drops the link the user already saw baked into the card text —
+    # never drops the tail the user already saw baked into the card text —
     # ported from the old post-time override in mcp/src/index.ts
     # (`TWITTER_TAIL_LINK_RATE: "1.0"` on the approve_drafts path), which no
     # longer fires now that the decision happens here, before the card is
-    # ever shown. The autonomous DRAFT_ONLY=0 lane keeps running the real A/B
-    # experiment at the configured rate.
+    # ever shown.
     if os.environ.get("DRAFT_ONLY") == "1":
         return 1.0
     try:
-        return float(os.environ.get("TWITTER_TAIL_LINK_RATE", "0.5"))
+        return float(os.environ.get("TWITTER_TAIL_LINK_RATE", "1.0"))
+    except ValueError:
+        return 1.0
+
+
+def _cta_link_share() -> float:
+    """P(link arm | a tail is added) for the twitter-tail-cta experiment
+    (link vs plain product name), launched 2026-08-08. The complementary share
+    goes to the 'name' arm. Read live from TWITTER_TAIL_CTA_LINK_SHARE so the
+    split can be swept without a code change; defaults to 0.5."""
+    try:
+        v = float(os.environ.get("TWITTER_TAIL_CTA_LINK_SHARE", "0.5"))
     except ValueError:
         return 0.5
+    if v < 0.0:
+        return 0.0
+    if v > 1.0:
+        return 1.0
+    return v
+
+
+def _resolve_product_name(project_name: str) -> str:
+    """Plain-text product name for the 'name' arm of twitter-tail-cta.
+    config.json entry's product_name, then its name, then a title-cased form
+    of the project slug (so we always have SOMETHING to plant). Mirrors
+    link_tail.resolve_product_name."""
+    try:
+        projects = load_projects()
+    except Exception:
+        projects = {}
+    entry = projects.get(project_name) or {}
+    pn = (entry.get("product_name") or "").strip()
+    if pn:
+        return pn
+    nm = (entry.get("name") or "").strip()
+    if nm:
+        return nm
+    return (project_name or "").replace("_", " ").replace("-", " ").strip().title()
 
 
 def apply_tail_link(candidate: dict, link_url: str) -> None:
@@ -181,39 +224,72 @@ def apply_tail_link(candidate: dict, link_url: str) -> None:
     twitter_post_plan.py can detect this candidate is already finalized and
     skip its own (now fallback-only) tail-link block.
 
+    2026-08-08 — twitter-tail-cta experiment. The old link-vs-no_link A/B
+    concluded; _tail_link_rate() now defaults to 1.0 (a tail is essentially
+    always added for promo posts). Once a tail is added, the arm is a coin
+    flip between BOTH tails carrying the AI-written bridge:
+      - 'link': the bridge ends with the tracked URL (historical behavior).
+      - 'name': the bridge ends with the PLAIN product name, no URL — passed
+        via --cta-mode name and NEVER appending link_url.
+    A rate below 1.0 (or personal_brand's TWITTER_TAIL_LINK_RATE=0) still
+    yields the 'no_link' arm, which stamps but doesn't feed the tail-cta card.
+
     Idempotent: a candidate that already carries tail_link_variant is a
     no-op. Guards against any re-run of this stage over the same candidate
     (retry, salvage, plan re-merge) re-rolling the decision and re-appending
-    link_url onto a reply_text that already has it baked in.
+    the tail onto a reply_text that already has it baked in.
     """
     if not link_url or candidate.get("tail_link_variant"):
         return
     rate = _tail_link_rate()
-    add_link = random.random() < rate
-    candidate["tail_link_variant"] = "link" if add_link else "no_link"
-    if not add_link:
+    if random.random() >= rate:
+        # Tail explicitly disabled (rate < 1.0 / personal_brand). Stamp the
+        # no_link arm; it does not feed the twitter-tail-cta card.
+        candidate["tail_link_variant"] = "no_link"
         print(f"[gen] candidate_id={candidate.get('candidate_id')} "
               f"tail_link: ab_no_link (rate={rate})", flush=True)
         return
     reply_text = (candidate.get("reply_text") or "").strip()
-    cmd = [
-        "python3", LINK_TAIL,
-        "--reply-text", reply_text,
-        "--link-url", link_url,
-        "--thread-text", candidate.get("thread_text") or "",
-        "--project", candidate.get("matched_project") or "",
-        "--platform", "twitter",
-        "--timeout", str(LINK_TAIL_TIMEOUT_SEC),
-    ]
+    project = candidate.get("matched_project") or ""
+    use_link = random.random() < _cta_link_share()
+    candidate["tail_link_variant"] = "link" if use_link else "name"
+    if use_link:
+        product_name = ""
+        mech = f"{reply_text} {link_url}".strip()
+        cmd = [
+            "python3", LINK_TAIL,
+            "--reply-text", reply_text,
+            "--link-url", link_url,
+            "--thread-text", candidate.get("thread_text") or "",
+            "--project", project,
+            "--platform", "twitter",
+            "--cta-mode", "url",
+            "--timeout", str(LINK_TAIL_TIMEOUT_SEC),
+        ]
+    else:
+        # Name arm: end with the plain product name, NO URL in the reply.
+        product_name = _resolve_product_name(project)
+        mech = f"{reply_text} {product_name}".strip()
+        cmd = [
+            "python3", LINK_TAIL,
+            "--reply-text", reply_text,
+            "--product-name", product_name,
+            "--thread-text", candidate.get("thread_text") or "",
+            "--project", project,
+            "--platform", "twitter",
+            "--cta-mode", "name",
+            "--timeout", str(LINK_TAIL_TIMEOUT_SEC),
+        ]
     try:
         r = subprocess.run(cmd, capture_output=True, text=True,
                            timeout=LINK_TAIL_TIMEOUT_SEC + 30)
         rc, out = r.returncode, r.stdout
     except subprocess.TimeoutExpired:
-        candidate["reply_text"] = f"{reply_text} {link_url}".strip()
+        candidate["reply_text"] = mech
         candidate["link_tail_outcome"] = "hard_timeout"
         print(f"[gen] candidate_id={candidate.get('candidate_id')} "
-              f"link_tail: hard_timeout; keeping mechanical concat", flush=True)
+              f"link_tail[{candidate['tail_link_variant']}]: hard_timeout; "
+              f"keeping mechanical concat", flush=True)
         return
     obj = parse_last_json_object(out) or {}
     if obj.get("text"):
@@ -225,12 +301,13 @@ def apply_tail_link(candidate: dict, link_url: str) -> None:
     else:
         # link_tail.py is supposed to ALWAYS return JSON; if we got nothing,
         # hard-fall-back to the mechanical concat so the card still shows a
-        # complete draft (link still present) instead of a bare reply.
-        candidate["reply_text"] = f"{reply_text} {link_url}".strip()
+        # complete draft (tail still present) instead of a bare reply.
+        candidate["reply_text"] = mech
         outcome = f"hard_fallback_no_json:rc={rc}"
     candidate["link_tail_outcome"] = outcome
     print(f"[gen] candidate_id={candidate.get('candidate_id')} "
-          f"link_tail: {outcome} (elapsed={obj.get('elapsed_sec')}s)", flush=True)
+          f"link_tail[{candidate['tail_link_variant']}]: {outcome} "
+          f"(elapsed={obj.get('elapsed_sec')}s)", flush=True)
 
 
 def run_generate(product: str, keyword: str, slug: str) -> tuple[str, str]:

package/scripts/twitter_post_plan.py

@@ -119,6 +119,29 @@ LOG_POST = os.path.join(REPO_DIR, "scripts", "log_post.py")
 CAMPAIGN_BUMP = os.path.join(REPO_DIR, "scripts", "campaign_bump.py")
 LINK_TAIL = os.path.join(REPO_DIR, "scripts", "link_tail.py")
 
+
+def _resolve_product_name(project: str) -> str:
+    """Plain-text product name for the 'name' arm of the twitter-tail-cta
+    fallback below (mirrors twitter_gen_links._resolve_product_name /
+    link_tail.resolve_product_name): config.json entry's product_name, then
+    its name, then a title-cased form of the project slug."""
+    try:
+        with open(os.path.join(REPO_DIR, "config.json")) as f:
+            cfg = json.load(f)
+    except Exception:
+        cfg = {}
+    name_lc = (project or "").lower()
+    for p in cfg.get("projects", []):
+        if (p.get("name") or "").lower() == name_lc:
+            pn = (p.get("product_name") or "").strip()
+            if pn:
+                return pn
+            nm = (p.get("name") or "").strip()
+            if nm:
+                return nm
+            break
+    return (project or "").replace("_", " ").replace("-", " ").strip().title()
+
 # Interpreter every child subprocess (twitter_browser.py reply, log_post.py,
 # campaign_bump.py, link_tail.py) must run under. The reply path is the only
 # Playwright importer in the pipeline, so a bare "python3" here silently
@@ -632,28 +655,60 @@ def post_one(c: dict, picker_assignment: dict | None = None) -> tuple[str, str]:
               f"(already finalized at draft time, tail_link_variant={tail_link_variant})",
               flush=True)
     else:
-        # AB TEST — tail link on/off:
-        # TWITTER_TAIL_LINK_RATE (float 0..1, default 0.5) controls the fraction
-        # of posts that receive a tail link. Setting it to 1.0 restores old
-        # behavior (always add link). Setting it to 0.0 disables links entirely.
-        # tail_link_variant is logged to posts.tail_link_variant so the dashboard
-        # can compare engagement across arms.
-        _tail_link_rate = float(os.environ.get("TWITTER_TAIL_LINK_RATE", "0.5"))
-        _add_tail_link = link_url and (random.random() < _tail_link_rate)
-        if link_url:
-            tail_link_variant = "link" if _add_tail_link else "no_link"
+        # FALLBACK ONLY (candidate reached post time unstamped). Mirrors
+        # twitter_gen_links.apply_tail_link. AB TEST — twitter-tail-cta
+        # (link vs plain product name), launched 2026-08-08. The prior
+        # link-vs-no_link A/B concluded that day (no_link won engagement but the
+        # link arm bought clicks); both arms now append the AI-written bridge,
+        # differing only in whether it ends with the tracked URL ('link') or the
+        # plain product name ('name', no URL).
+        # TWITTER_TAIL_LINK_RATE (float 0..1, default 1.0) still gates whether
+        # ANY tail is added (0.0 disables tails; personal_brand exports 0);
+        # TWITTER_TAIL_CTA_LINK_SHARE (float 0..1, default 0.5) splits link vs
+        # name once a tail is added. tail_link_variant is logged to
+        # posts.tail_link_variant so the dashboard can compare arms.
+        try:
+            _tail_link_rate = float(os.environ.get("TWITTER_TAIL_LINK_RATE", "1.0"))
+        except ValueError:
+            _tail_link_rate = 1.0
+        _add_tail = link_url and (random.random() < _tail_link_rate)
         link_tail_outcome = "skipped_no_link"
-        if _add_tail_link:
-            rc, out, err = run_subprocess(
-                [PYTHON, LINK_TAIL,
-                 "--reply-text", reply_text,
-                 "--link-url", link_url,
-                 "--thread-text", thread_text or "",
-                 "--project", project,
-                 "--platform", "twitter",
-                 "--timeout", "120"],
-                timeout_sec=180,
-            )
+        if not _add_tail:
+            if link_url:
+                # Tail disabled: post the reply as-is (no bridge, no URL).
+                tail_link_variant = "no_link"
+                link_tail_outcome = "ab_no_link"
+                print(f"[post] candidate {cid} link_tail: {link_tail_outcome} "
+                      f"(tail_link_variant=no_link, rate={_tail_link_rate})", flush=True)
+        else:
+            try:
+                _cta_link_share = float(os.environ.get("TWITTER_TAIL_CTA_LINK_SHARE", "0.5"))
+            except ValueError:
+                _cta_link_share = 0.5
+            _use_link = random.random() < _cta_link_share
+            tail_link_variant = "link" if _use_link else "name"
+            if _use_link:
+                _tail_cmd = [PYTHON, LINK_TAIL,
+                             "--reply-text", reply_text,
+                             "--link-url", link_url,
+                             "--thread-text", thread_text or "",
+                             "--project", project,
+                             "--platform", "twitter",
+                             "--cta-mode", "url",
+                             "--timeout", "120"]
+                _mech = f"{reply_text} {link_url}".strip()
+            else:
+                _product_name = _resolve_product_name(project)
+                _tail_cmd = [PYTHON, LINK_TAIL,
+                             "--reply-text", reply_text,
+                             "--product-name", _product_name,
+                             "--thread-text", thread_text or "",
+                             "--project", project,
+                             "--platform", "twitter",
+                             "--cta-mode", "name",
+                             "--timeout", "120"]
+                _mech = f"{reply_text} {_product_name}".strip()
+            rc, out, err = run_subprocess(_tail_cmd, timeout_sec=180)
             tail_obj = parse_last_json_object(out) or {}
             if tail_obj.get("text"):
                 full_text = tail_obj["text"]
@@ -664,17 +719,11 @@ def post_one(c: dict, picker_assignment: dict | None = None) -> tuple[str, str]:
             else:
                 # link_tail.py is supposed to ALWAYS return JSON; if we got
                 # nothing, hard-fall-back to the mechanical concat to preserve
-                # prior behavior (post still ships, link still on the wire).
-                full_text = f"{reply_text} {link_url}".strip()
+                # prior behavior (post still ships, tail still on the wire).
+                full_text = _mech
                 link_tail_outcome = f"hard_fallback_no_json:rc={rc}"
-            print(f"[post] candidate {cid} link_tail: {link_tail_outcome} "
-                  f"(elapsed={tail_obj.get('elapsed_sec')}s)", flush=True)
-        elif link_url and not _add_tail_link:
-            # No-link arm of the AB test: post the reply text as-is (no CTA bridge,
-            # no URL). Log the outcome so the dashboard can tally the arm.
-            link_tail_outcome = "ab_no_link"
-            print(f"[post] candidate {cid} link_tail: {link_tail_outcome} "
-                  f"(tail_link_variant=no_link, rate={_tail_link_rate})", flush=True)
+            print(f"[post] candidate {cid} link_tail[{tail_link_variant}]: "
+                  f"{link_tail_outcome} (elapsed={tail_obj.get('elapsed_sec')}s)", flush=True)
 
     # URL-wrap the text BEFORE handing it to twitter_browser. The browser
     # script appends the campaign suffix internally; suffixes are plain