feat(rules)!: retire rulebook subscriptions and per-project suppressions (#4052)

A rule's home is its scope now: a rule in a rulebook topic is global, a rule on
a project applies to that project, and retrieval reads that directly (#4074).
A subscription had stopped changing anything a session received; a suppression
muted rules from a subscription. Operator, 2026-09-15: "we have global and
project scoped rules, we don't need the subscriptions now."

What goes, whole (rule 22):
- Migration 0101 drops project_rulebook_subscriptions, project_rule_suppressions
  and project_topic_suppressions, and strips subscribe_rulebooks (and 394's
  leftover exclude_always_on_rulebooks) from stored inception choices.
- Service, MCP and REST: subscribe/unsubscribe and the four suppress/unsuppress
  operations. The Subscribers checklist, the subscribe chips, the skip buttons
  and the Suppressed section in the rules UI.
- Inception asks two questions (design system, seed Systems). create_project and
  decide_project_inception lose subscribe_rulebooks.
- Backup v15 stops exporting the three sections; older archives still restore,
  the keys simply unread. Trash no longer hard-deletes suppression rows.

What changes meaning:
- get_applicable_rules is a project's LISTING: its own rules, plus the global
  rules tagged to an area it works in. Untagged global rules apply everywhere
  and arrive by retrieval, so they are not listed. A co_surfaces partner on a
  different project is not dragged in.
- list_rules(project_id) lists that project's own rules.
- rules_payload drops subscribed_rulebooks and suppressed_*; the handshake's
  brief form is project_rules alone.
- using-scribe's "Where a new rule goes" and inception sections, tool
  docstrings and docs say global vs project. Plugin 2026.09.15.1620.

Milestone 414 step 2.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01821k5B3Ysecp9fNYs92Kuy

src/scribe/services/inception.py

@@ -7,7 +7,6 @@ A project's inheritance is a decision, not a default. The record lives on
       "decided_at": "<iso>", "decided_by": <user id> | null,
       "via": "mcp" | "ui" | "legacy",
       "choices": {
-        "subscribe_rulebooks": [rulebook ids],
         "design_system_id": <id> | null,
         "seed_systems": bool
       }
@@ -17,14 +16,15 @@ NULL = undecided → enter_project asks. ``legacy`` is the migration's stamp on
 projects that existed before the step did (inherit-all / no design system /
 no seed), so the ask fires only for projects created after this shipped.
 
-``exclude_always_on_rulebooks`` was a fourth choice until milestone 394. It
-let a project decline to inherit an always-on rulebook, and with no always-on
-tier there is nothing to decline — a rulebook now reaches a project by
-subscription, which is opt-IN, so declining is expressed by not subscribing.
+Rules are not a choice any more. ``exclude_always_on_rulebooks`` went with the
+always-on tier (milestone 394), and ``subscribe_rulebooks`` went with
+subscriptions (milestone 414): a rule in a rulebook is global and applies to
+every project, and a project's own rules are written on it directly. Migration
+0101 strips both keys from stored records.
 
 The shape and its validator are pure; ``decide`` composes the existing
-services — subscriptions, set_project_design_system, the standard Systems
-seed — checks every target BEFORE touching anything,
+services — set_project_design_system and the standard Systems seed — checks
+every target BEFORE touching anything,
 applies the effects (each idempotent), and writes the record LAST, so a
 half-applied decision is re-runnable rather than recorded as done.
 ``current_defaults`` is what the enter_project ask shows: what binds today
@@ -34,20 +34,11 @@ from __future__ import annotations
 
 from datetime import datetime, timezone
 
-from sqlalchemy import select
-
 from scribe.models import async_session
 from scribe.models.project import Project
-from scribe.models.rulebook import Rulebook
 
 INCEPTION_VIAS = ("mcp", "ui", "legacy")
-CHOICE_KEYS = ("subscribe_rulebooks", "design_system_id", "seed_systems")
-
-
-def _is_id_list(value) -> bool:
-    return isinstance(value, list) and all(
-        isinstance(v, int) and not isinstance(v, bool) and v > 0 for v in value
-    )
+CHOICE_KEYS = ("design_system_id", "seed_systems")
 
 
 def validate_inception(choices) -> str | None:
@@ -55,18 +46,14 @@ def validate_inception(choices) -> str | None:
     None. Pure and checked BEFORE any effect is applied: a decision either
     applies whole or errors whole (the StrictArgs lesson, #2709).
 
-    Accepts the four keys, each optional: two id lists (positive ints, no
-    duplicates between exclude and subscribe), ``design_system_id`` an int
-    or None, ``seed_systems`` a bool. Unknown keys are an error — a typo
-    must not become a silently ignored choice."""
+    Accepts two keys, each optional: ``design_system_id`` an int or None,
+    ``seed_systems`` a bool. Unknown keys are an error — a typo, or a choice
+    the product no longer offers, must not become a silently ignored one."""
     if not isinstance(choices, dict):
         return "choices must be an object"
     unknown = sorted(set(choices) - set(CHOICE_KEYS))
     if unknown:
         return f"unknown inception choice(s): {', '.join(unknown)} (one of: {', '.join(CHOICE_KEYS)})"
-    subs = choices.get("subscribe_rulebooks") or []
-    if not _is_id_list(subs):
-        return "subscribe_rulebooks must be a list of rulebook ids"
     ds = choices.get("design_system_id")
     if ds is not None and (isinstance(ds, bool) or not isinstance(ds, int) or ds <= 0):
         return "design_system_id must be a positive id or null"
@@ -77,11 +64,10 @@ def validate_inception(choices) -> str | None:
 
 
 def normalize_choices(choices: dict | None) -> dict:
-    """The three keys, always present, in canonical form — what gets stored
+    """Both keys, always present, in canonical form — what gets stored
     and what the UI/agent reads back. Call after validate_inception."""
     choices = choices or {}
     return {
-        "subscribe_rulebooks": sorted(set(choices.get("subscribe_rulebooks") or [])),
         "design_system_id": choices.get("design_system_id"),
         "seed_systems": bool(choices.get("seed_systems", False)),
     }
@@ -95,37 +81,20 @@ def is_decided(project) -> bool:
 async def current_defaults(user_id: int, project_id: int) -> dict:
     """What the project inherits if nobody decides — the ask's payload.
 
-    {rulebooks: [{id,title}], subscribed_rulebooks: [...],
-     design_system_id, design_systems: [{id,title}], systems: <count>}.
-    Instance-agnostic: an install with no rulebooks / design systems shows
-    empty lists, and the ask says so rather than inventing a default.
+    {design_system_id, design_systems: [{id,title}], systems: <count>}.
+    Instance-agnostic: an install with no design systems shows an empty list,
+    and the ask says so rather than inventing a default.
     """
     from scribe.services import design_systems as design_systems_svc
     from scribe.services import projects as projects_svc
-    from scribe.services import rulebooks as rulebooks_svc
     from scribe.services import systems as systems_svc
 
     project = await projects_svc.get_project(user_id, project_id)
     if project is None:
         raise ValueError(f"project {project_id} not found")
-    async with async_session() as session:
-        rows = (
-            await session.execute(
-                select(Rulebook.id, Rulebook.title)
-                .where(Rulebook.owner_user_id == user_id, Rulebook.deleted_at.is_(None))
-                .order_by(Rulebook.title)
-            )
-        ).all()
-    applicable = await rulebooks_svc.get_applicable_rules(project_id, user_id, limit=1)
     designs = await design_systems_svc.list_design_systems(user_id)
     systems = await systems_svc.list_systems(user_id, project_id, include_archived=True)
     return {
-        # ONE list since milestone 394. This was split into always-on and
-        # "other" because the first bound the project whether it asked or not;
-        # with the tier gone every rulebook is opt-in, so the split named a
-        # difference that no longer exists.
-        "rulebooks": [{"id": i, "title": t} for i, t in rows],
-        "subscribed_rulebooks": applicable.get("subscribed_rulebooks", []),
         "design_system_id": project.design_system_id,
         "design_systems": [{"id": d.id, "title": d.title} for d in designs],
         "systems": len(systems),
@@ -137,22 +106,6 @@ async def _check_targets(user_id: int, choices: dict) -> None:
     effect lands — a decision applies whole or errors whole."""
     from scribe.services import access
 
-    wanted = set(choices["subscribe_rulebooks"])
-    if wanted:
-        async with async_session() as session:
-            rows = (
-                await session.execute(
-                    select(Rulebook.id).where(
-                        Rulebook.id.in_(wanted),
-                        Rulebook.owner_user_id == user_id,
-                        Rulebook.deleted_at.is_(None),
-                    )
-                )
-            ).all()
-        found = {rid for (rid,) in rows}
-        missing = sorted(wanted - found)
-        if missing:
-            raise ValueError(f"rulebook(s) {missing} not found (or not yours)")
     ds = choices["design_system_id"]
     if ds is not None and not await access.can_read_design_system(user_id, ds):
         raise ValueError(f"design system {ds} not found (or not readable)")
@@ -167,20 +120,17 @@ async def decide(
 ) -> dict:
     """Record a project's inception decision and apply it (milestone 297).
 
-    Owner-only. Validates the choices (pure) and every target (owned /
-    readable) first; then, each idempotent: subscribe the named rulebooks,
-    point the project at the design system (None = explicitly none), seed the
-    standard Systems if asked and the project has none; then write
-    ``projects.inception`` LAST. Re-deciding is additive for subscriptions
-    (nothing is silently dropped — unsubscribe is an explicit call), replaces
-    the design system, and re-seeds nothing a project already has.
+    Owner-only. Validates the choices (pure) and every target (readable)
+    first; then, each idempotent: point the project at the design system
+    (None = explicitly none), seed the standard Systems if asked and the
+    project has none; then write ``projects.inception`` LAST. Re-deciding
+    replaces the design system and re-seeds nothing a project already has.
 
-    Returns {"inception": <record>, "effects": {excluded, subscribed,
-    design_system_id, systems_seeded}}.
+    Returns {"inception": <record>, "effects": {design_system_id,
+    systems_seeded}}.
     """
     from scribe.services import design_systems as design_systems_svc
     from scribe.services import projects as projects_svc
-    from scribe.services import rulebooks as rulebooks_svc
     from scribe.services import systems as systems_svc
 
     if via not in INCEPTION_VIAS or via == "legacy":
@@ -194,8 +144,6 @@ async def decide(
         raise ValueError(f"project {project_id} not found (or not yours)")
     await _check_targets(user_id, choices)
 
-    for rb in choices["subscribe_rulebooks"]:
-        await rulebooks_svc.subscribe_project(project_id, rb, user_id)
     if not await design_systems_svc.set_project_design_system(
         user_id, project_id, choices["design_system_id"]
     ):
@@ -219,7 +167,6 @@ async def decide(
     return {
         "inception": record,
         "effects": {
-            "subscribed": choices["subscribe_rulebooks"],
             "design_system_id": choices["design_system_id"],
             "systems_seeded": [sy.name for sy in seeded],
         },
@@ -235,24 +182,20 @@ async def inception_ask(user_id: int, project_id: int) -> dict:
         defaults = await current_defaults(user_id, project_id)
     except Exception:
         return {}
-    books = ", ".join(f"{r['title']} (#{r['id']})" for r in defaults["rulebooks"]) or "none"
     designs = ", ".join(f"{d['title']} (#{d['id']})" for d in defaults["design_systems"]) or "none"
     return {
         "defaults": defaults,
         "ask": (
             "This project has no inception decision: nobody has said what it "
-            f"inherits. Rulebooks it could subscribe to — {books}; design system — "
+            "inherits. Design system — "
             f"{'#' + str(defaults['design_system_id']) if defaults['design_system_id'] else 'none'} "
             f"(available: {designs}); Systems — {defaults['systems']}. Ask the operator, "
-            "once: which rulebooks to subscribe (default: none — a rulebook binds "
-            "a project only when it opts in), which design system (or none), and "
-            "whether to seed "
+            "once: which design system (or none), and whether to seed "
             "the standard starter Systems — then record the answers. This ask repeats on "
             "every enter_project until a decision is recorded."
         ),
         "call": (
             f"decide_project_inception(project_id={project_id}, "
-            "subscribe_rulebooks=[...], "
             "design_system_id=<id | -1 for none>, seed_systems=<true|false>)"
         ),
     }