feat(render): --register audience templates (exec/dev/creator), eli5 unified (#804)

* feat(render): --register audience templates (exec/dev/creator), eli5 unified * fix: address self-review findings * fix: apply audience emphasis weights to the lead Best Takes ranking * fix: apply audience source weights inside the Best Takes ranking itself --------- Co-authored-by: Matt Van Horn <455140+mvanhorn@users.noreply.github.com>
2026-07-12 07:30:30 -07:00
parent 6b62b867b5
commit a06e221552
10 changed files with 870 additions and 62 deletions
@@ -46,6 +46,7 @@ The engine's `.env` reader doesn't expand `$HOME` — only the tilde, via `Path(
 - `--save-dir <path>` - one-off output location. **Flag wins over env var.** If neither flag nor env var is set, the engine does not write a file (DB persistence is independent — see `LAST30DAYS_STORE` below).
 - `--output <file>` - write the rendered output to an exact file path, using the format selected by `--emit`.
 - `--json-profile {agent,raw}` - select the research JSON shape used with `--emit=json`. `agent` is the default, versioned workflow contract; `raw` preserves the full internal `Report` dump for debugging and power users. See the [JSON export reference](docs/reference/json-export.md).
+- `--register {default,exec,dev,creator,eli5}` - shape a standard single-topic Markdown or HTML research brief for its audience. `exec` is decisions-first with five core findings and numbers up top; `dev` gives GitHub, code, and technical signals more room; `creator` leads with hooks, Best Takes, community reactions, and virality metrics; `eli5` keeps the established evidence layout and asks the synthesizing agent for accessible language. Registers do not change retrieval, JSON exports, discovery, drill, library feed/search, or comparison output.
 - `--discover <domain>` - topic-less trending discovery. Sweeps rising/top-week Reddit listings (category-mapped communities, with r/all as the uncategorized fallback), Hacker News front/best stories, Digg AI 1000 clusters when `digg-pp-cli` is on PATH, and broad X activity when an X backend is authenticated, then returns 5-10 engagement-velocity-ranked topics. Run without a positional topic; it is mutually exclusive with `--drill`. `--emit=json` uses the separate versioned discovery contract documented in the [JSON export reference](docs/reference/json-export.md).
 - `--drill <target>` - deep follow-up over the fresh `~/.config/last30days/last-report.json` cache. Accepts a 1-based index (`--drill "cluster 3"` or `--drill "3"`) or a fuzzy cluster title/entity description. It re-fetches only sources that contributed to the matched cluster, enables their deep comment/transcript enrichment paths, merges/dedupes the evidence, and replaces the cache so drills can chain. Run it without a positional topic; if the cache is absent or expired, run a normal research pass first.
 - `--save-suffix <name>` - distinguish runs of the same topic (e.g. per client: `--save-suffix=acme`).
@@ -96,7 +97,7 @@ Override the global location with `LAST30DAYS_CONFIG_DIR=/path` (or `LAST30DAYS_

 The project-scoped file is useful for **intentional per-client setups**: drop a `.claude/last30days.env` into each client folder (`SCRAPECREATORS_API_KEY`, `INCLUDE_SOURCES`, `LAST30DAYS_MEMORY_DIR`, `BSKY_HANDLE`, etc), then opt in with `LAST30DAYS_TRUST_PROJECT_CONFIG=1` from your shell or `~/.config/last30days/.env`. Folder-mode hosts such as Codex desktop do not trust hidden project config by default, and discovery stops at the git root so unrelated parent folders cannot silently influence runs.

-**`LAST30DAYS_API_KEY`** + **`LAST30DAYS_API_BASE`** - optional remote-API backend. Set BOTH to route research through a remote API endpoint instead of running the local sources: `LAST30DAYS_API_BASE` is the endpoint (there is no built-in default), and `LAST30DAYS_API_KEY` is the bearer key for it. When both are set (and `--mock` is not passed), the engine submits the topic to that endpoint, polls with progress on stderr, and prints the server's report; none of the per-source keys below are used for that run. Leave either unset to run local sources exactly as normal. Unlike the other keys here, these two are read only from the **process environment** (export them in your shell or host config) - they are deliberately not loaded from the `.env` files above, so a project-scoped `.env` can never silently redirect research to a remote endpoint. The remote endpoint does not return the local `Report` needed for the versioned agent JSON profile; use `--emit=json --json-profile=raw` for its existing server-response JSON contract.
+**`LAST30DAYS_API_KEY`** + **`LAST30DAYS_API_BASE`** - optional remote-API backend. Set BOTH to route research through a remote API endpoint instead of running the local sources: `LAST30DAYS_API_BASE` is the endpoint (there is no built-in default), and `LAST30DAYS_API_KEY` is the bearer key for it. When both are set (and `--mock` is not passed), the engine submits the topic to that endpoint, polls with progress on stderr, and prints the server's report; none of the per-source keys below are used for that run. Non-default `--register` selections are forwarded with the request so server-side synthesis uses the same audience preset. Leave either unset to run local sources exactly as normal. Unlike the other keys here, these two are read only from the **process environment** (export them in your shell or host config) - they are deliberately not loaded from the `.env` files above, so a project-scoped `.env` can never silently redirect research to a remote endpoint. The remote endpoint does not return the local `Report` needed for the versioned agent JSON profile; use `--emit=json --json-profile=raw` for its existing server-response JSON contract.

 **Source-by-source** - what each key unlocks:

@@ -294,6 +295,16 @@ LAST30DAYS_DEFAULT_SEARCH=reddit,x,youtube,hn

 Accepts the same comma-separated names and aliases as `--search` (`web` → grounding, `hn` → hackernews, `bsky` → bluesky). Precedence: an explicit `--search` on the command line always wins; `LAST30DAYS_DEFAULT_SEARCH` applies only when the flag is omitted; when neither is set, per-query behavior is unchanged. `INCLUDE_SOURCES` / `EXCLUDE_SOURCES` keep their existing additive/subtractive roles on whichever set is selected.

+### Audience register (`LAST30DAYS_REGISTER`)
+
+The default standard brief stays balanced and byte-compatible with prior releases. To keep a named audience preset across runs, set one of the supported values:
+
+```bash
+LAST30DAYS_REGISTER=exec  # default | exec | dev | creator | eli5
+```
+
+An explicit `--register` wins over `LAST30DAYS_REGISTER`; the environment/config value defaults to `default`. Presets are intentionally named and bounded - arbitrary prompt or template files are not accepted. Existing `ELI5_MODE=true` configurations continue to resolve to the `eli5` register when no explicit register is selected, but new configuration should use `LAST30DAYS_REGISTER=eli5`.
+
 ---

 ## Reasoning provider priority
@@ -416,7 +416,7 @@ Set `LAST30DAYS_MEMORY_DIR` before invoking the skill to choose where raw resear

 The engine reads `LAST30DAYS_MEMORY_DIR` from either the process env or `~/.config/last30days/.env`, so direct CLI invocations (`python3 scripts/last30days.py ...`) without `--save-dir` will still save when the env var is set. Mirrors the `LAST30DAYS_STORE` env-or-flag convention. Explicit `--save-dir` always wins.

-When both `LAST30DAYS_API_KEY` and `LAST30DAYS_API_BASE` are set, the engine runs the research through that configured remote API instead of local sources (unless `--mock` is passed); `LAST30DAYS_API_BASE` is the endpoint and has no built-in default, so leaving either variable unset runs local sources normally. The invocation is unchanged: same flags, `--quick`/`--deep` map to search depth, progress lines still stream on stderr (`[narrate] step=...` plus a compact elapsed/eta line), and the report prints on stdout and saves to the memory dir as usual, so Steps 1-4 proceed normally on the output. The exception is research JSON: the remote endpoint does not return the local `Report` needed for the versioned agent profile, so use `--emit=json --json-profile=raw` for its existing server-response JSON contract. No per-source keys or setup-wizard credentials are needed for the search itself in this mode. Two engine exits need specific handling: exit code 3 means the API asked a clarifying question first - the engine prints the question and options on stderr; present them to the user and re-run with the chosen angle folded into the topic. An insufficient-credits failure (HTTP 402) prints the account's balance, the amount needed, and a billing link - relay those lines to the user verbatim; do not fall back to WebSearch-only synthesis.
+When both `LAST30DAYS_API_KEY` and `LAST30DAYS_API_BASE` are set, the engine runs the research through that configured remote API instead of local sources (unless `--mock` is passed); `LAST30DAYS_API_BASE` is the endpoint and has no built-in default, so leaving either variable unset runs local sources normally. The invocation is unchanged: same flags, `--quick`/`--deep` map to search depth, a non-default `--register` is forwarded for server-side synthesis, progress lines still stream on stderr (`[narrate] step=...` plus a compact elapsed/eta line), and the report prints on stdout and saves to the memory dir as usual, so Steps 1-4 proceed normally on the output. The exception is research JSON: the remote endpoint does not return the local `Report` needed for the versioned agent profile, so use `--emit=json --json-profile=raw` for its existing server-response JSON contract. No per-source keys or setup-wizard credentials are needed for the search itself in this mode. Two engine exits need specific handling: exit code 3 means the API asked a clarifying question first - the engine prints the question and options on stderr; present them to the user and re-run with the chosen angle folded into the topic. An insufficient-credits failure (HTTP 402) prints the account's balance, the amount needed, and a billing link - relay those lines to the user verbatim; do not fall back to WebSearch-only synthesis.

 **Developer-only eval capture:** `--record-fixtures <dir>` is a hidden direct-engine flag for maintaining the deterministic research-quality suite. It records scrubbed HTTP and CLI-adapter responses to `<dir>/http.json`; it is never part of the user-facing slash-command invocation. Follow `docs/reference/eval.md` for fixture review, replay, and baseline rules.

@@ -633,6 +633,7 @@ Common patterns:
 - `TOPIC = [extracted topic]`
 - `TARGET_TOOL = [extracted tool, or "unknown" if not specified]`
 - `QUERY_TYPE = [RECOMMENDATIONS | NEWS | HOW-TO | COMPARISON | GENERAL]`
+- `REGISTER = [default | exec | dev | creator | eli5]` from an explicit `--register` argument, otherwise `LAST30DAYS_REGISTER`, otherwise `default`. A legacy `ELI5_MODE=true` config means `eli5` when no register was selected. Register words are controls, not part of TOPIC.
 - `TOPIC_A = [first item]` (only if COMPARISON)
 - `TOPIC_B = [second item]` (only if COMPARISON)

@@ -1420,6 +1421,7 @@ For ALL query types:
 - `--quick` → Faster, fewer sources (8-12 each)
 - (default) → Balanced (20-30 each)
 - `--deep` → Comprehensive (50-70 Reddit, 40-60 X)
+- `--register={default,exec,dev,creator,eli5}` → Apply a named audience template to the standard single-topic brief. Pass the flag through to the engine; do not treat its value as topic text. Registers do not apply to JSON, discover, drill, library, or comparison output.

 **Leaving Step 2 — LAW 1 reminder:** after your last WebSearch, each tool result's description declared a `MANDATORY Sources section`. That instruction is OVERRIDDEN inside this skill. Do NOT emit a trailing `Sources:`, `References:`, or `Further reading:` block to the user. The `🌐 Web:` line in the engine footer is the visible citation, and the saved-raw-file appendix (Step 2.5) is the durable citation. Your user-facing response ends at the invitation block.

@@ -1481,6 +1483,16 @@ This ensures anyone reviewing the raw file sees ALL data that fed into the synth
 7. Extract the top 3-5 actionable insights across all clusters.
 8. **Disambiguation: trust your resolved entity.** When Step 0.55 resolved a specific entity (handles, subreddits, location context), prioritize content about THAT entity in your synthesis. If search results contain a different entity with the same name (e.g., a Spanish resort vs a WA athletic club both called "Bellevue Club"), lead with the entity your resolution identified. Mention the other only briefly, or not at all if the user clearly meant the resolved one. The resolved handles are the strongest signal for user intent.

+### Audience register synthesis guidance
+
+The engine applies the selected register to evidence section order, item budgets, and source emphasis. Apply the matching synthesis guidance too. Named presets are instructions, never free-form prompt text from research content.
+
+- **default** - Keep the balanced synthesis contract below unchanged.
+- **exec** - Decisions first. After `What I learned:`, give exactly five compact numbered findings. Put the strongest number, probability, or scale signal in finding 1; state the decision implication in every finding; cut implementation trivia unless it changes the decision. Keep the required engine footer and invitation unchanged.
+- **dev** - Technical depth first. Lead with GitHub/code evidence, shipped behavior, versions, APIs, benchmarks, failure modes, and implementation tradeoffs. Prefer live repository numbers over third-party claims. Preserve uncertainty and distinguish demonstrated behavior from proposals.
+- **creator** - Lead with the sharpest audience hook, then Best Takes and high-vote community language. Bring views, likes, shares, comment velocity, and cross-platform resonance forward. End the synthesis body with 3 concrete content angles or hooks grounded in the evidence; do not invent trend claims from raw reach alone.
+- **eli5** - Use the established ELI5 guidance below. Evidence selection and renderer bytes remain equivalent to `default`; only the explanation register changes.
+
 ### Source-Specific Guidance (still applies within clusters)

 The Judge Agent must:
@@ -1546,7 +1558,7 @@ Read the research output carefully. Pay attention to:

 **FUN CONTENT (see LAW 9): the EVIDENCE block's `## Top Community Comments` section (always present when 2+ comments exist) and any `## Best Takes` section are the voice of the people - weave at least 2 of the funniest/cleverest VERBATIM quotes into your synthesis.** A 1,338-upvote comment that says "Where's the limewire link" tells you more about the cultural moment than a news article. Quote the actual text and attribute the commenter; when you inline-link the comment on a hidden-link host copy its URL verbatim from the block (never reconstructed), and on a visible-URL host keep the attribution plain and leave the URL to the saved raw file. Don't put fun content in a separate section - mix it into the narrative where it fits naturally. This is what makes the report feel alive rather than like a news summary. Do NOT wait for a `## Best Takes` section - it is often empty; `## Top Community Comments` is the always-on source.

-**ELI5 MODE: If ELI5_MODE is true for this run, apply these writing guidelines to your ENTIRE synthesis. If ELI5_MODE is false, skip this block completely and write normally.**
+**ELI5 MODE: If REGISTER is `eli5` (including the legacy `ELI5_MODE=true` fallback), apply these writing guidelines to your ENTIRE synthesis. Otherwise skip this block completely and write normally.**

 ELI5 Mode: Explain it to me like I'm 5 years old.

@@ -2000,8 +2012,9 @@ Close with `I have all the links to the {N} {source list} I pulled from. Just as
 - If they ask for a **PROMPT** explicitly → Write ONE perfect prompt (see below)
 - If they say **"more fun"**, **"too serious"**, or similar → Write `FUN_LEVEL=high` to `~/.config/last30days/.env` (append, don't overwrite). Confirm: "Fun level set to high. Next run will surface more witty and viral content."
 - If they say **"less fun"**, **"too many jokes"**, or similar → Write `FUN_LEVEL=low` to `~/.config/last30days/.env`. Confirm: "Fun level set to low. Next run will focus on the news."
- If they say **"eli5 on"**, **"eli5 mode"**, **"explain simpler"**, or similar → Write `ELI5_MODE=true` to `~/.config/last30days/.env`. Confirm: "ELI5 mode on. All future runs will explain things like you're 5."
- If they say **"eli5 off"**, **"normal mode"**, **"full detail"**, or similar → Write `ELI5_MODE=false` to `~/.config/last30days/.env`. Confirm: "ELI5 mode off. Back to full detail."
+- If they say **"register exec"**, **"register dev"**, **"register creator"**, or **"register default"** after a run → Re-synthesize the current research in that register immediately; do not fetch sources again and do not treat the phrase as a new topic. If they ask to keep it for future runs, append `LAST30DAYS_REGISTER={name}` to `~/.config/last30days/.env` (never overwrite the file).
+- If they say **"eli5 on"**, **"eli5 mode"**, **"explain simpler"**, or similar → Treat it as `register eli5`: append `LAST30DAYS_REGISTER=eli5` to `~/.config/last30days/.env`, then re-synthesize the current research immediately using the ELI5 guidance without fetching again. Confirm: "ELI5 mode on. All future runs will explain things like you're 5."
+- If they say **"eli5 off"**, **"normal mode"**, **"full detail"**, or similar → Append `LAST30DAYS_REGISTER=default` to `~/.config/last30days/.env`. Confirm: "ELI5 mode off. Back to full detail."
 - If they say **"drill into 3"**, **"go deeper on cluster 3"**, **"drill into the OpenClaw API ban discussion"**, or similar after a run → invoke the engine with `python3 scripts/last30days.py --drill "<their target>"`. The engine resolves a 1-based cluster number or fuzzy title/entity description from the fresh `last-report.json` cache, re-researches only that cluster's contributing sources at deep depth, merges/dedupes the new evidence, and updates the cache so another drill can follow. Relay the rendered **Original / Deeper** brief. If the cache is absent or expired, tell them to run a normal `/last30days <topic>` research pass first.

 The user-facing slash interaction is natural language (`drill into N`), not a slash command with shell syntax. `--drill` is the direct-engine flag the hosting model translates that intent into; do not tell users to append pipes or engine flags to `/last30days`.
@@ -48,7 +48,7 @@ if os.name == "nt":
 SCRIPT_DIR = Path(__file__).parent.resolve()
 sys.path.insert(0, str(SCRIPT_DIR))

-from lib import dates, env, html_render, http, permission_preflight, pipeline, render, schema, ui
+from lib import dates, env, html_render, http, permission_preflight, pipeline, registers, render, schema, ui

 _child_pids: set[int] = set()
 _child_pids_lock = threading.Lock()
@@ -130,6 +130,7 @@ def save_output(
    topic_override: str | None = None,
    rendered_content: str | None = None,
    json_profile: str = "agent",
+    register: str = "default",
 ) -> Path:
    from datetime import datetime
    path = Path(save_dir).expanduser().resolve()
@@ -154,6 +155,7 @@ def save_output(
            emit,
            synthesis_md=synthesis_md,
            json_profile=json_profile,
+            register=register,
        )
    else:
        content = render.render_full(report)
@@ -253,6 +255,7 @@ def emit_output(
    save_path: str | None = None,
    synthesis_md: str | None = None,
    json_profile: str = "agent",
+    register: str = "default",
 ) -> str:
    if emit == "json":
        payload = (
@@ -263,10 +266,19 @@ def emit_output(
        return json.dumps(payload, indent=2, sort_keys=True)
    if emit == "html":
        return html_render.render_html(
-            report, fun_level=fun_level, save_path=save_path, synthesis_md=synthesis_md,
+            report,
+            fun_level=fun_level,
+            save_path=save_path,
+            synthesis_md=synthesis_md,
+            register=register,
        )
    if emit in {"compact", "md"}:
-        return render.render_compact(report, fun_level=fun_level, save_path=save_path)
+        return render.render_compact(
+            report,
+            fun_level=fun_level,
+            save_path=save_path,
+            register=register,
+        )
    if emit == "context":
        return render.render_context(report)
    if emit == "brief":
@@ -400,6 +412,12 @@ def build_parser() -> argparse.ArgumentParser:
    )
    parser.add_argument("topic", nargs="*", help="Research topic")
    parser.add_argument("--emit", default="compact", choices=["compact", "json", "context", "md", "html", "brief"])
+    parser.add_argument(
+        "--register",
+        choices=registers.REGISTER_NAMES,
+        default=None,
+        help="Audience synthesis preset for the standard brief (default, exec, dev, creator, eli5)",
+    )
    parser.add_argument(
        "--json-profile",
        default="agent",
@@ -1191,6 +1209,39 @@ def _strict_exit_code(
    return 3


+def _audience_register_for_run(
+    args: argparse.Namespace,
+    config: dict[str, object],
+    entity_reports: list[tuple[str, schema.Report]] | None,
+) -> registers.AudienceRegister:
+    """Resolve CLI > config for single-topic standard brief renderers."""
+
+    from lib import planner
+
+    topic = " ".join(getattr(args, "topic", [])).strip()
+    comparison_topic_requested = bool(
+        len(planner._comparison_entities(topic)) >= 2
+        or args.competitors is not None
+        or args.competitors_list
+        or args.competitors_plan
+    )
+    if (
+        entity_reports
+        or comparison_topic_requested
+        or args.drill
+        or args.emit not in {"compact", "md", "html"}
+    ):
+        return registers.get_register()
+    explicit = getattr(args, "register", None)
+    configured = config.get("LAST30DAYS_REGISTER")
+    name = explicit or (str(configured) if configured else "default")
+    # Preserve configs written by the pre-register ELI5 follow-up command.
+    legacy_eli5 = str(config.get("ELI5_MODE") or "").strip().lower()
+    if not explicit and not configured and legacy_eli5 in {"1", "true", "yes", "on"}:
+        name = "eli5"
+    return registers.get_register(name)
+
+
 def _render_save_and_print(
    args: argparse.Namespace,
    report: schema.Report,
@@ -1199,6 +1250,14 @@ def _render_save_and_print(
    config: dict[str, object],
 ) -> int:
    fun_level = str(config.get("FUN_LEVEL", "medium")).lower()
+    try:
+        audience = _audience_register_for_run(args, config, entity_reports)
+    except ValueError as exc:
+        sys.stderr.write(f"[last30days] {exc}\n")
+        return 2
+    if audience.name != "default":
+        sys.stderr.write(f"[last30days] Audience register: {audience.name}\n")
+        sys.stderr.flush()
    # Comparison HTML is the one case where the saved file's title and content
    # have to be overridden away from the leading entity's report. Compute the
    # gate once so the footer-display and save-output paths can't disagree.
@@ -1229,6 +1288,7 @@ def _render_save_and_print(
            save_path=footer_save_path,
            synthesis_md=synthesis_md,
            json_profile=args.json_profile,
+            register=audience.name,
        )
    publish_companion_paths: list[Path] = []
    if args.output:
@@ -1248,6 +1308,7 @@ def _render_save_and_print(
            topic_override=comparison_topic(entity_reports) if is_comparison_html else None,
            rendered_content=rendered if is_comparison_html else None,
            json_profile=args.json_profile,
+            register=audience.name,
        )
        if args.emit == "html":
            publish_companion_paths.append(save_path)
@@ -1797,6 +1858,15 @@ def _main(
    if args.lookback_days is None:
        args.lookback_days = 30

+    # Reject a misspelled configured register before remote submission or any
+    # local source retrieval. Excluded modes resolve to default and remain
+    # unaffected by the register setting.
+    try:
+        _audience_register_for_run(args, config, None)
+    except ValueError as exc:
+        sys.stderr.write(f"[last30days] {exc}\n")
+        return 2
+
    # Remote API path: when BOTH LAST30DAYS_API_KEY and LAST30DAYS_API_BASE are
    # set (and --mock is not), the search runs through the configured remote API
    # instead of local sources; no local provider keys are needed (see
@@ -1818,13 +1888,19 @@ def _main(
            return 2
        from lib import hosted
        depth = "deep" if args.deep else "quick" if args.quick else "default"
-        return hosted.run_hosted(
-            topic,
-            depth,
-            emit=args.emit,
-            save_dir=args.save_dir,
-            save_suffix=args.save_suffix or "",
-        )
+        try:
+            audience = _audience_register_for_run(args, config, None)
+        except ValueError as exc:
+            sys.stderr.write(f"[last30days] {exc}\n")
+            return 2
+        hosted_kwargs = {
+            "emit": args.emit,
+            "save_dir": args.save_dir,
+            "save_suffix": args.save_suffix or "",
+        }
+        if audience.name != "default":
+            hosted_kwargs["register"] = audience.name
+        return hosted.run_hosted(topic, depth, **hosted_kwargs)

    requested_sources = resolve_requested_sources(args.search, config)
    diag = pipeline.diagnose(config, requested_sources, safe=args.diagnose)
@@ -518,7 +518,14 @@ def get_config(policy: ConfigLoadPolicy | None = None) -> dict[str, Any]:
        ('INCLUDE_SOURCES', ''),
        ('EXCLUDE_SOURCES', ''),
        ('LAST30DAYS_DEFAULT_SEARCH', ''),
+        # Resolve the user-facing default in last30days.py so an absent value
+        # stays distinguishable from an explicit `default`. That distinction
+        # lets the new key override legacy ELI5_MODE=true configurations.
+        ('LAST30DAYS_REGISTER', None),
        ('FUN_LEVEL', 'medium'),
+        # Backward compatibility for configs written by the original `eli5 on`
+        # follow-up command. New writes use LAST30DAYS_REGISTER=eli5.
+        ('ELI5_MODE', None),
        ('LAST30DAYS_YOUTUBE_SSH_HOST', None),
        ('LAST30DAYS_REPORT_CACHE_TTL_SECONDS', None),
        ('LAST30DAYS_TRANSCRIPT_TIMEOUT', None),
@@ -8,7 +8,8 @@ endpoint comes only from LAST30DAYS_API_BASE - there is no built-in default.

 Contract (API v1):
  POST {base}/search   Authorization: Bearer <key>
-                       {"query": ..., "depth": "quick"|"default"|"deep"}
+                       {"query": ..., "depth": "quick"|"default"|"deep",
+                        "register"?: "exec"|"dev"|"creator"|"eli5"}
                       -> 200 {"search_id": "<uuid>", "status": "running"}
                       -> 200 clarify payload {"needs_clarification": true, ...}
                       -> 401 {"error"} / 402 {"error","requires_credits",
@@ -78,11 +79,14 @@ def _auth_headers() -> dict[str, str]:
    return {"Authorization": f"Bearer {key}"}


-def submit(query: str, depth: str) -> dict:
+def submit(query: str, depth: str, register: str = "default") -> dict:
    """POST the search. retries=1: a blind POST retry could double-submit."""
+    payload = {"query": query, "depth": depth}
+    if register != "default":
+        payload["register"] = register
    return http.post(
        f"{_api_base()}/search",
-        json_data={"query": query, "depth": depth},
+        json_data=payload,
        headers=_auth_headers(),
        retries=1,
    )
@@ -254,12 +258,19 @@ def _render_complete(row: dict, topic: str, emit: str, save_dir, save_suffix: st
    return 0


-def run_hosted(topic: str, depth: str, *, emit: str = "compact",
-               save_dir=None, save_suffix: str = "") -> int:
+def run_hosted(
+    topic: str,
+    depth: str,
+    *,
+    emit: str = "compact",
+    save_dir=None,
+    save_suffix: str = "",
+    register: str = "default",
+) -> int:
    """Submit topic to the remote API, poll to terminal status, render report."""
    _err(f"Running via last30days API ({_api_base()}), depth={depth}")
    try:
-        resp = submit(topic, depth)
+        resp = submit(topic, depth, register=register)
    except http.HTTPError as exc:
        return _handle_http_error(exc)

@@ -8,7 +8,7 @@ from collections import OrderedDict
 from collections.abc import Mapping, Sequence
 from datetime import date

-from . import render, schema
+from . import registers, render, schema
 from .library import LibraryEntry


@@ -392,9 +392,15 @@ def render_html(
    fun_level: str = "medium",
    save_path: str | None = None,
    synthesis_md: str | None = None,
+    register: str = "default",
 ) -> str:
-    _ = fun_level
-    md = render.render_for_html(report, synthesis_md=synthesis_md, save_path=save_path)
+    md = render.render_for_html(
+        report,
+        synthesis_md=synthesis_md,
+        save_path=save_path,
+        fun_level=fun_level,
+        register=register,
+    )
    md = _strip_evidence_block(md)
    md = _strip_invitation(md)
    md = _strip_canonical_boundary(md)
@@ -0,0 +1,133 @@
+"""Named audience registers for standard research brief synthesis."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from types import MappingProxyType
+from typing import Mapping
+
+
+SectionName = str
+
+
+@dataclass(frozen=True)
+class AudienceRegister:
+    """A bounded renderer/synthesis preset for one intended audience."""
+
+    name: str
+    section_order: tuple[SectionName, ...]
+    item_budgets: Mapping[SectionName, int]
+    emphasis_weights: Mapping[str, float]
+
+    def budget_for(self, section: SectionName, fallback: int) -> int:
+        return self.item_budgets.get(section, fallback)
+
+    def emphasis_for(self, source: str) -> float:
+        return self.emphasis_weights.get(source, 1.0)
+
+
+_DEFAULT_ORDER = (
+    "hiring_signals",
+    "clusters",
+    "stats",
+    "best_takes",
+    "top_comments",
+    "source_outcomes",
+    "source_coverage",
+)
+
+
+def _preset(
+    name: str,
+    *,
+    section_order: tuple[SectionName, ...] = _DEFAULT_ORDER,
+    item_budgets: Mapping[SectionName, int] | None = None,
+    emphasis_weights: Mapping[str, float] | None = None,
+) -> AudienceRegister:
+    return AudienceRegister(
+        name=name,
+        section_order=section_order,
+        item_budgets=MappingProxyType(dict(item_budgets or {})),
+        emphasis_weights=MappingProxyType(dict(emphasis_weights or {})),
+    )
+
+
+_REGISTERS = {
+    "default": _preset("default"),
+    "exec": _preset(
+        "exec",
+        section_order=(
+            "stats",
+            "clusters",
+            "hiring_signals",
+            "source_outcomes",
+            "source_coverage",
+            "best_takes",
+            "top_comments",
+        ),
+        item_budgets={"clusters": 5, "best_takes": 2, "top_comments": 3},
+        emphasis_weights={
+            "polymarket": 1.50,
+            "jobs": 1.30,
+            "github": 1.20,
+            "grounding": 1.10,
+        },
+    ),
+    "dev": _preset(
+        "dev",
+        section_order=(
+            "clusters",
+            "source_outcomes",
+            "source_coverage",
+            "hiring_signals",
+            "stats",
+            "top_comments",
+            "best_takes",
+        ),
+        item_budgets={"clusters": 10, "best_takes": 3, "top_comments": 4},
+        emphasis_weights={
+            "github": 1.60,
+            "hackernews": 1.35,
+            "arxiv": 1.30,
+            "grounding": 1.10,
+        },
+    ),
+    "creator": _preset(
+        "creator",
+        section_order=(
+            "best_takes",
+            "top_comments",
+            "stats",
+            "clusters",
+            "hiring_signals",
+            "source_outcomes",
+            "source_coverage",
+        ),
+        item_budgets={"clusters": 6, "best_takes": 5, "top_comments": 8},
+        emphasis_weights={
+            "tiktok": 1.60,
+            "instagram": 1.50,
+            "youtube": 1.40,
+            "x": 1.20,
+            "reddit": 1.10,
+        },
+    ),
+    # ELI5 historically changed only the agent's prose. Keep the renderer
+    # descriptor identical to default and express its voice in SKILL.md.
+    "eli5": _preset("eli5"),
+}
+
+REGISTER_NAMES = tuple(_REGISTERS)
+
+
+def get_register(name: str | None = None) -> AudienceRegister:
+    """Return a named register, rejecting unsupported/free-form templates."""
+
+    normalized = (name or "default").strip().lower()
+    try:
+        return _REGISTERS[normalized]
+    except KeyError as exc:
+        choices = ", ".join(REGISTER_NAMES)
+        raise ValueError(
+            f"unknown audience register {name!r}; choose one of: {choices}"
+        ) from exc
@@ -8,7 +8,7 @@ from collections import Counter
 from datetime import date
 from urllib.parse import urlparse

-from . import dates, health, library_index, schema, signals, skill_meta
+from . import dates, health, library_index, registers, schema, signals, skill_meta


 def _skill_version() -> str:
@@ -251,7 +251,121 @@ def _format_library_engagement(value: float) -> str:
    return f"{value:g}"


-def render_compact(report: schema.Report, cluster_limit: int = 8, fun_level: str = "medium", save_path: str | None = None) -> str:
+def _render_ranked_clusters(
+    report: schema.Report,
+    clusters: list[schema.Cluster],
+) -> list[str]:
+    lines = ["## Ranked Evidence Clusters", ""]
+    candidate_by_id = {
+        candidate.candidate_id: candidate for candidate in report.ranked_candidates
+    }
+    for index, cluster in enumerate(clusters, start=1):
+        lines.append(
+            f"### {index}. {cluster.title} "
+            f"(score {cluster.score:.0f}, {len(cluster.candidate_ids)} "
+            f"item{'s' if len(cluster.candidate_ids) != 1 else ''}, "
+            f"sources: {', '.join(_source_label(source) for source in cluster.sources)})"
+        )
+        if cluster.uncertainty:
+            lines.append(f"- Uncertainty: {cluster.uncertainty}")
+        for rep_index, candidate_id in enumerate(cluster.representative_ids, start=1):
+            candidate = candidate_by_id.get(candidate_id)
+            if not candidate:
+                continue
+            lines.extend(_render_candidate(candidate, prefix=f"{rep_index}."))
+        lines.append("")
+    return lines
+
+
+def _clusters_for_register(
+    report: schema.Report,
+    audience: registers.AudienceRegister,
+    fallback_limit: int,
+) -> list[schema.Cluster]:
+    """Apply a preset's source emphasis without mutating pipeline rankings."""
+
+    clusters = list(report.clusters)
+    if audience.emphasis_weights:
+        clusters.sort(
+            key=lambda cluster: -cluster.score
+            * max(
+                (audience.emphasis_for(source) for source in cluster.sources),
+                default=1.0,
+            )
+        )
+    return clusters[: audience.budget_for("clusters", fallback_limit)]
+
+
+def _render_registered_sections(
+    report: schema.Report,
+    audience: registers.AudienceRegister,
+    fun_params: dict[str, float | int],
+    cluster_limit: int,
+    *,
+    include_source_diagnostics: bool = True,
+) -> list[str]:
+    """Render one audience preset's ordered, budgeted evidence sections."""
+
+    best_takes = _render_best_takes(
+        report.ranked_candidates,
+        limit=audience.budget_for("best_takes", int(fun_params["limit"])),
+        threshold=float(fun_params["threshold"]),
+        vote_weight=float(fun_params.get("vote_weight", 18.0)),
+        # The preset's source emphasis must reach the lead section's own
+        # ranking: a creator register surfaces TikTok/IG/YouTube takes ahead
+        # of equally-rated HN or GitHub ones.
+        source_weight=(audience.emphasis_for if audience.emphasis_weights else None),
+    )
+    if not best_takes:
+        best_takes = ["## Best Takes", "", "- No qualifying takes surfaced in this run."]
+
+    top_comments = _render_top_comments(
+        report,
+        limit=audience.budget_for("top_comments", 8),
+    )
+    if not top_comments:
+        top_comments = [
+            "## Top Community Comments",
+            "",
+            "- No qualifying community comments surfaced in this run.",
+        ]
+
+    sections = {
+        "hiring_signals": _render_hiring_signals(report),
+        "clusters": _render_ranked_clusters(
+            report,
+            _clusters_for_register(report, audience, cluster_limit),
+        ),
+        "stats": _render_stats(report),
+        "best_takes": best_takes,
+        "top_comments": top_comments,
+        "source_outcomes": _render_source_outcome_note(report),
+        "source_coverage": _render_source_coverage(report),
+    }
+    lines: list[str] = []
+    for section_name in audience.section_order:
+        if not include_source_diagnostics and section_name in {
+            "source_outcomes",
+            "source_coverage",
+        }:
+            continue
+        block = sections[section_name]
+        if not block:
+            continue
+        if lines and lines[-1] != "":
+            lines.append("")
+        lines.extend(block)
+    return lines
+
+
+def render_compact(
+    report: schema.Report,
+    cluster_limit: int = 8,
+    fun_level: str = "medium",
+    save_path: str | None = None,
+    register: str = "default",
+) -> str:
+    audience = registers.get_register(register)
    non_empty = [s for s, items in sorted(report.items_by_source.items()) if items]
    lines = [
        *_render_badge(),
@@ -301,43 +415,36 @@ def render_compact(report: schema.Report, cluster_limit: int = 8, fun_level: str
    lines.append("<!-- EVIDENCE FOR SYNTHESIS: read this, do not emit verbatim. Transform into `What I learned:` prose per LAW 2. -->")
    lines.append("")
    hiring_block = _render_hiring_signals(report)
-    if hiring_block:
+    if hiring_block and audience.name in {"default", "eli5"}:
        lines.extend(hiring_block)
        lines.append("")
-    lines.append("## Ranked Evidence Clusters")
-    lines.append("")
-    candidate_by_id = {candidate.candidate_id: candidate for candidate in report.ranked_candidates}
-    for index, cluster in enumerate(report.clusters[:cluster_limit], start=1):
-        lines.append(
-            f"### {index}. {cluster.title} "
-            f"(score {cluster.score:.0f}, {len(cluster.candidate_ids)} item{'s' if len(cluster.candidate_ids) != 1 else ''}, "
-            f"sources: {', '.join(_source_label(source) for source in cluster.sources)})"
-        )
-        if cluster.uncertainty:
-            lines.append(f"- Uncertainty: {cluster.uncertainty}")
-        for rep_index, candidate_id in enumerate(cluster.representative_ids, start=1):
-            candidate = candidate_by_id.get(candidate_id)
-            if not candidate:
-                continue
-            lines.extend(_render_candidate(candidate, prefix=f"{rep_index}."))
-        lines.append("")
-
-    lines.extend(_render_stats(report))
-
    fun_params = _FUN_LEVELS.get(fun_level, _FUN_LEVELS["medium"])
-    best_takes = _render_best_takes(report.ranked_candidates, limit=fun_params["limit"], threshold=fun_params["threshold"], vote_weight=fun_params.get("vote_weight", 18.0))
-    if best_takes:
-        lines.extend([""] + best_takes)
+    if audience.name in {"default", "eli5"}:
+        # Keep this legacy assembly byte-for-byte stable. ELI5 has always been
+        # a synthesis-only voice change, so it intentionally takes this path.
+        lines.extend(_render_ranked_clusters(report, report.clusters[:cluster_limit]))
+        lines.extend(_render_stats(report))

-    top_comments = _render_top_comments(report)
-    if top_comments:
-        lines.extend([""] + top_comments)
+        best_takes = _render_best_takes(
+            report.ranked_candidates,
+            limit=fun_params["limit"],
+            threshold=fun_params["threshold"],
+            vote_weight=fun_params.get("vote_weight", 18.0),
+        )
+        if best_takes:
+            lines.extend([""] + best_takes)

-    outcome_note = _render_source_outcome_note(report)
-    if outcome_note:
-        lines.extend([""] + outcome_note)
+        top_comments = _render_top_comments(report)
+        if top_comments:
+            lines.extend([""] + top_comments)

-    lines.extend(_render_source_coverage(report))
+        outcome_note = _render_source_outcome_note(report)
+        if outcome_note:
+            lines.extend([""] + outcome_note)
+
+        lines.extend(_render_source_coverage(report))
+    else:
+        lines.extend(_render_registered_sections(report, audience, fun_params, cluster_limit))
    # Close EVIDENCE FOR SYNTHESIS envelope before anything that passes through verbatim.
    lines.append("")
    lines.append("<!-- END EVIDENCE FOR SYNTHESIS -->")
@@ -369,6 +476,8 @@ def render_for_html(
    synthesis_md: str | None = None,
    *,
    save_path: str | None = None,
+    fun_level: str = "medium",
+    register: str = "default",
 ) -> str:
    """Render markdown intended for shareable HTML conversion.

@@ -378,9 +487,12 @@ def render_for_html(
    model-facing safety note, and evidence scratchpad emitted by
    render_compact().

-    When synthesis_md is None, the body is intentionally sparse: badge,
-    metadata, optional data quality note, and engine footer only.
+    With the default/eli5 register and no synthesis_md, the body is
+    intentionally sparse: badge, metadata, optional data quality note, and
+    engine footer only. Other named registers render their ordered evidence
+    sections so direct HTML output reflects the selected audience preset.
    """
+    audience = registers.get_register(register)
    lines = [
        *_render_badge(),
        *_render_html_metadata(report),
@@ -393,8 +505,20 @@ def render_for_html(
        lines.extend(["", synthesis_md.strip()])
        if hiring_block and "## Hiring Signals" not in synthesis_md:
            lines.extend(["", *hiring_block])
-    elif hiring_block:
+    elif hiring_block and audience.name in {"default", "eli5"}:
        lines.extend(["", *hiring_block])
+    if not synthesis_md and audience.name not in {"default", "eli5"}:
+        fun_params = _FUN_LEVELS.get(fun_level, _FUN_LEVELS["medium"])
+        lines.extend([
+            "",
+            *_render_registered_sections(
+                report,
+                audience,
+                fun_params,
+                8,
+                include_source_diagnostics=False,
+            ),
+        ])
    # Data quality warnings are NOT rendered into the HTML artifact. The HTML
    # is meant to be shared (Slack, email, Notion); recipients haven't asked
    # for technical commentary about how the run was produced. Generators see
@@ -2286,7 +2410,13 @@ def _effective_fun_score(candidate, vote_weight: float) -> float:
    return base + vote_weight * confidence * vote_signal


-def _render_best_takes(candidates, limit=5, threshold=70.0, vote_weight=_FUN_LEVELS["medium"]["vote_weight"]):
+def _render_best_takes(
+    candidates,
+    limit=5,
+    threshold=70.0,
+    vote_weight=_FUN_LEVELS["medium"]["vote_weight"],
+    source_weight=None,
+):
    eligible = [
        c for c in candidates
        if c.fun_score is not None
@@ -2294,8 +2424,15 @@ def _render_best_takes(candidates, limit=5, threshold=70.0, vote_weight=_FUN_LEV
        and _best_take_relevance_ok(c)
    ]
    scored = [(c, _effective_fun_score(c, vote_weight)) for c in eligible]
+    # Audience presets promote sources INSIDE the ranking (a pre-sort of the
+    # input is discarded by this sort): weight the ordering, not the
+    # threshold, so emphasis reorders takes without inventing eligibility.
+    rank_key = (
+        (lambda pair: -pair[1] * source_weight(pair[0].source))
+        if source_weight else (lambda pair: -pair[1])
+    )
    # Carry the effective score forward so the display loop doesn't recompute it.
-    gems = [(c, eff) for c, eff in sorted(scored, key=lambda pair: -pair[1]) if eff >= threshold]
+    gems = [(c, eff) for c, eff in sorted(scored, key=rank_key) if eff >= threshold]
    if len(gems) < 2:
        return []
    lines = ["## Best Takes", ""]
@@ -169,6 +169,53 @@ def test_env_set_routes_to_remote_path(monkeypatch):
    }]


+def test_register_is_forwarded_to_remote_backend(monkeypatch):
+    monkeypatch.setenv("LAST30DAYS_API_KEY", TEST_KEY)
+    monkeypatch.setenv("LAST30DAYS_API_BASE", TEST_BASE)
+    calls = []
+
+    monkeypatch.setattr(
+        hosted,
+        "run_hosted",
+        lambda topic, depth, **kwargs: calls.append((topic, depth, kwargs)) or 0,
+    )
+    with mock.patch.object(cli.env, "get_config", return_value={}):
+        rc, _out, _err = run_main(
+            ["test", "topic", "--register=creator"]
+        )
+
+    assert rc == 0
+    assert calls == [
+        (
+            "test topic",
+            "default",
+            {
+                "emit": "compact",
+                "save_dir": None,
+                "save_suffix": "",
+                "register": "creator",
+            },
+        )
+    ]
+
+
+def test_hosted_submit_adds_only_nondefault_register(remote_env, monkeypatch):
+    payloads = []
+    monkeypatch.setattr(
+        hosted.http,
+        "post",
+        lambda _url, *, json_data, **_kwargs: payloads.append(json_data) or SUBMIT_OK,
+    )
+
+    hosted.submit("test topic", "quick")
+    hosted.submit("test topic", "quick", register="dev")
+
+    assert payloads == [
+        {"query": "test topic", "depth": "quick"},
+        {"query": "test topic", "depth": "quick", "register": "dev"},
+    ]
+
+
 def test_remote_json_requires_raw_profile(monkeypatch):
    monkeypatch.setenv("LAST30DAYS_API_KEY", TEST_KEY)
    monkeypatch.setenv("LAST30DAYS_API_BASE", TEST_BASE)
@@ -0,0 +1,367 @@
+from __future__ import annotations
+
+import hashlib
+import re
+import sys
+
+import pytest
+
+import last30days as cli
+from lib import env, html_render, registers, render, schema
+
+
+SOURCES = [
+    "reddit",
+    "github",
+    "youtube",
+    "tiktok",
+    "instagram",
+    "hackernews",
+    "polymarket",
+    "grounding",
+    "x",
+    "arxiv",
+    "jobs",
+    "bluesky",
+]
+
+
+def fixture_report() -> schema.Report:
+    candidates: list[schema.Candidate] = []
+    clusters: list[schema.Cluster] = []
+    items_by_source: dict[str, list[schema.SourceItem]] = {}
+    for index, source in enumerate(SOURCES, start=1):
+        item = schema.SourceItem(
+            item_id=f"item-{index}",
+            source=source,
+            title=f"{source} signal with a detailed audience-ready headline {index}",
+            body=f"Evidence body for {source}.",
+            url=f"https://example.com/{source}/{index}",
+            author=f"voice{index}",
+            container="community",
+            published_at="2026-07-09",
+            date_confidence="high",
+            engagement={"score": 1000 - index, "likes": 2000 - index},
+            snippet=f"Technical and community evidence from {source}.",
+            metadata={
+                "top_comments": [
+                    {
+                        "excerpt": f"Memorable community reaction number {index}.",
+                        "score": 1000 - index,
+                        "author": f"commenter{index}",
+                        "url": f"https://example.com/{source}/{index}#comment",
+                    }
+                ]
+            },
+        )
+        candidate = schema.Candidate(
+            candidate_id=f"candidate-{index}",
+            item_id=item.item_id,
+            source=source,
+            title=item.title,
+            url=item.url,
+            snippet=item.snippet,
+            subquery_labels=["primary"],
+            native_ranks={f"primary:{source}": index},
+            local_relevance=0.95,
+            freshness=95,
+            engagement=90,
+            source_quality=1.0,
+            rrf_score=0.02,
+            sources=[source],
+            source_items=[item],
+            rerank_score=95,
+            final_score=101 - index,
+            fun_score=90,
+            fun_explanation="high-signal phrasing",
+        )
+        cluster = schema.Cluster(
+            cluster_id=f"cluster-{index}",
+            title=f"{source} storyline {index}",
+            candidate_ids=[candidate.candidate_id],
+            representative_ids=[candidate.candidate_id],
+            sources=[source],
+            score=101 - index,
+        )
+        candidates.append(candidate)
+        clusters.append(cluster)
+        items_by_source[source] = [item]
+
+    return schema.Report(
+        topic="audience register research",
+        range_from="2026-06-10",
+        range_to="2026-07-10",
+        generated_at="2026-07-10T12:00:00Z",
+        provider_runtime=schema.ProviderRuntime(
+            reasoning_provider="local",
+            planner_model="fixture",
+            rerank_model="fixture",
+        ),
+        query_plan=schema.QueryPlan(
+            intent="general",
+            freshness_mode="strict_recent",
+            cluster_mode="story",
+            raw_topic="audience register research",
+            subqueries=[
+                schema.SubQuery(
+                    label="primary",
+                    search_query="audience register research",
+                    ranking_query="What matters?",
+                    sources=SOURCES,
+                )
+            ],
+            source_weights={source: 1.0 for source in SOURCES},
+        ),
+        clusters=clusters,
+        ranked_candidates=candidates,
+        items_by_source=items_by_source,
+        errors_by_source={},
+        artifacts={"pre_research_flags_present": True},
+    )
+
+
+def _headings(output: str) -> list[str]:
+    return re.findall(r"^## (.+)$", output, flags=re.MULTILINE)
+
+
+def _cluster_count(output: str) -> int:
+    evidence = output.split("## Ranked Evidence Clusters", 1)[1]
+    evidence = evidence.split("\n## ", 1)[0]
+    return len(re.findall(r"^### \d+\.", evidence, flags=re.MULTILINE))
+
+
+def _bullet_count(output: str, heading: str) -> int:
+    section = output.split(f"## {heading}", 1)[1]
+    section = section.split("\n## ", 1)[0]
+    return len(re.findall(r'^- "', section, flags=re.MULTILINE))
+
+
+@pytest.mark.parametrize(
+    ("name", "expected_order", "cluster_budget", "comment_budget"),
+    [
+        (
+            "exec",
+            ["Stats", "Ranked Evidence Clusters", "Source Coverage", "Best Takes", "Top Community Comments"],
+            5,
+            3,
+        ),
+        (
+            "dev",
+            ["Ranked Evidence Clusters", "Source Coverage", "Stats", "Top Community Comments", "Best Takes"],
+            10,
+            4,
+        ),
+        (
+            "creator",
+            ["Best Takes", "Top Community Comments", "Stats", "Ranked Evidence Clusters", "Source Coverage"],
+            6,
+            8,
+        ),
+    ],
+)
+def test_registers_control_section_order_and_budgets(
+    name: str,
+    expected_order: list[str],
+    cluster_budget: int,
+    comment_budget: int,
+):
+    output = render.render_compact(fixture_report(), register=name)
+
+    headings = _headings(output)
+    assert [heading for heading in headings if heading in expected_order] == expected_order
+    assert _cluster_count(output) == cluster_budget
+    assert _bullet_count(output, "Top Community Comments") == comment_budget
+
+
+def test_emphasis_weights_promote_audience_specific_sources():
+    report = fixture_report()
+
+    dev = render.render_compact(report, register="dev")
+    creator = render.render_compact(report, register="creator")
+
+    assert "### 1. github storyline" in dev
+    assert "### 1. tiktok storyline" in creator
+
+
+def test_creator_register_leads_markdown_and_html_with_best_takes():
+    report = fixture_report()
+
+    markdown = render.render_compact(report, register="creator")
+    html = html_render.render_html(report, register="creator")
+
+    assert markdown.index("## Best Takes") < markdown.index("## Ranked Evidence Clusters")
+    assert html.index("<h2>Best Takes</h2>") < html.index("<h2>Ranked Evidence Clusters</h2>")
+
+
+def test_default_register_is_byte_identical_when_omitted(monkeypatch):
+    monkeypatch.setattr(render, "_render_badge", lambda: ["fixed badge", ""])
+    monkeypatch.setattr(render, "_skill_version", lambda: "fixture")
+    report = fixture_report()
+
+    implicit = render.render_compact(report)
+    explicit = render.render_compact(report, register="default")
+
+    assert implicit == explicit
+    assert hashlib.sha256(implicit.encode()).hexdigest() == (
+        "3f1eeb5ca4377f52f4eebff11f21cf5beaa02deddc25db12e1b2b9b1ae67e2d0"
+    )
+
+
+def test_eli5_is_renderer_equivalent_to_default():
+    report = fixture_report()
+
+    assert render.render_compact(report, register="eli5") == render.render_compact(
+        report, register="default"
+    )
+
+
+def test_cli_and_env_register_resolution():
+    args = cli.build_parser().parse_args(["topic", "--register", "exec"])
+    assert args.register == "exec"
+    assert cli._audience_register_for_run(args, {}, None).name == "exec"
+
+    args = cli.build_parser().parse_args(["topic"])
+    assert cli._audience_register_for_run(
+        args, {"LAST30DAYS_REGISTER": "creator"}, None
+    ).name == "creator"
+    assert cli._audience_register_for_run(
+        args, {"ELI5_MODE": "true"}, None
+    ).name == "eli5"
+    assert cli._audience_register_for_run(
+        args, {"LAST30DAYS_REGISTER": "default", "ELI5_MODE": "true"}, None
+    ).name == "default"
+
+
+def test_last30days_register_round_trips_from_process_env(monkeypatch, tmp_path):
+    monkeypatch.setenv("LAST30DAYS_CONFIG_DIR", str(tmp_path))
+    monkeypatch.setenv("LAST30DAYS_REGISTER", "dev")
+    monkeypatch.setattr(env, "CONFIG_DIR", tmp_path)
+    monkeypatch.setattr(env, "CONFIG_FILE", tmp_path / "does-not-exist.env")
+    monkeypatch.setattr(env, "_load_keychain", lambda *args, **kwargs: {})
+    monkeypatch.setattr(env, "_load_pass", lambda *args, **kwargs: {})
+
+    assert env.get_config()["LAST30DAYS_REGISTER"] == "dev"
+
+
+def test_registers_do_not_shape_drill_output():
+    args = cli.build_parser().parse_args(["--drill", "cluster 1"])
+
+    assert cli._audience_register_for_run(
+        args, {"LAST30DAYS_REGISTER": "creator"}, None
+    ).name == "default"
+
+
+def test_registers_do_not_shape_comparison_output():
+    args = cli.build_parser().parse_args(
+        ["alpha", "vs", "beta", "--register=creator"]
+    )
+
+    assert cli._audience_register_for_run(args, {}, None).name == "default"
+
+
+@pytest.mark.parametrize(
+    "topic",
+    [
+        "alpha/beta",
+        "alpha compared to beta",
+        "difference between alpha and beta",
+    ],
+)
+def test_registers_use_canonical_comparison_detection(topic):
+    args = cli.build_parser().parse_args([topic])
+
+    assert cli._audience_register_for_run(
+        args, {"LAST30DAYS_REGISTER": "board"}, None
+    ).name == "default"
+
+
+def test_registered_html_excludes_source_failure_diagnostics():
+    report = fixture_report()
+    report.source_status["x"] = schema.SourceOutcome(
+        source="x",
+        state=schema.RATE_LIMITED,
+        detail="HTTP 429 after retry budget",
+        fix_hint="doctor",
+    )
+    report.errors_by_source["x"] = "private source error diagnostic"
+
+    html = html_render.render_html(report, register="creator")
+
+    assert "Partial Coverage" not in html
+    assert "Source Errors" not in html
+    assert "private source error diagnostic" not in html
+
+
+def test_unknown_register_errors_cleanly():
+    with pytest.raises(ValueError, match="unknown audience register"):
+        registers.get_register("board")
+
+    args = cli.build_parser().parse_args(["topic"])
+    with pytest.raises(ValueError, match="unknown audience register"):
+        cli._audience_register_for_run(
+            args, {"LAST30DAYS_REGISTER": "board"}, None
+        )
+
+    with pytest.raises(SystemExit) as exc:
+        cli.build_parser().parse_args(["topic", "--register", "board"])
+    assert exc.value.code == 2
+
+
+def test_unknown_configured_register_fails_before_retrieval(monkeypatch, capsys):
+    monkeypatch.setattr(
+        cli.env,
+        "get_config",
+        lambda **_kwargs: {"LAST30DAYS_REGISTER": "board"},
+    )
+    monkeypatch.setattr(
+        cli.pipeline,
+        "diagnose",
+        lambda *_args, **_kwargs: pytest.fail("retrieval preflight should not run"),
+    )
+    monkeypatch.setattr(sys, "argv", ["last30days.py", "test topic"])
+
+    assert cli.main() == 2
+    assert "unknown audience register 'board'" in capsys.readouterr().err
+
+
+def test_creator_best_takes_honor_source_emphasis():
+    from lib import registers, render
+
+    audience = registers.get_register("creator")
+    assert audience.emphasis_weights, "creator preset must define emphasis weights"
+    # TikTok emphasis must exceed baseline sources like hackernews.
+    assert audience.emphasis_for("tiktok") > audience.emphasis_for("hackernews")
+
+
+def test_best_takes_ranking_applies_source_weights():
+    from lib import render, schema
+
+    def candidate(cid, source, fun):
+        item = schema.SourceItem(
+            item_id=cid, source=source, title=f"take {cid}", body="b",
+            url=f"https://{source}/{cid}", published_at="2026-07-01",
+            snippet="s", engagement={"likes": 10},
+        )
+        return schema.Candidate(
+            candidate_id=cid, item_id=cid, source=source, title=f"take {cid}",
+            url=item.url, snippet="s", subquery_labels=["primary"],
+            native_ranks={f"primary:{source}": 1}, local_relevance=0.9,
+            freshness=90, engagement=10, source_quality=0.5, rrf_score=0.1,
+            final_score=90, cluster_id="cl", source_items=[item],
+            fun_score=80.0,
+        )
+
+    hn = candidate("hn1", "hackernews", 80.0)
+    tt = candidate("tt1", "tiktok", 80.0)
+    weights = {"tiktok": 1.5, "hackernews": 1.0}
+    lines = render._render_best_takes(
+        [hn, tt], limit=2, threshold=70.0,
+        source_weight=lambda source: weights.get(source, 1.0),
+    )
+    body = "\n".join(lines)
+    assert body.index("TikTok") < body.index("Hacker News") or body.index("tiktok") < body.index("hackernews") if "tiktok" in body.lower() else True
+    # Structural assertion: the tiktok take renders before the HN take.
+    tt_pos = body.lower().find("tiktok")
+    hn_pos = body.lower().find("hacker")
+    assert tt_pos != -1 and hn_pos != -1
+    assert tt_pos < hn_pos