feat(rules): both doors carry the trigger, the tier, the areas and the edges (#3029, milestone 307 step 3, surfaces)

MCP and REST both gain when_to_apply / tier / system_ids / arose_from_id on
create and update, plus relate_rules / unrelate_rules for the typed edges, and
get_rule now returns a rule's areas and relations alongside it.

rule_detail() is a SERVICE function, not one per door. It started as a copy in
each — identical, and the prior-art hook flagged it immediately, which is the
same lesson rules_payload (#2858) already recorded: a second copy drifts. Both
doors call the one seam, so create, update and get cannot disagree about what a
rule looks like coming back.

The authoring guidance lands in create_rule's docstring rather than in a rule,
per rule 119 as the operator described it: this is behaviour every instance
should inherit, not one operator's preference. It states the test —

  ONE RULE = ONE THING YOU COULD VIOLATE. Rules that FAIL TOGETHER get linked
  with relate_rules(kind="co_surfaces"), never merged into one row.

— and names why merging loses: a merged rule cannot be cited, surfaced or
suppressed a clause at a time, and it grows without limit because adding to it
is always cheaper than adding a rule. create_project_rule says the same about
"overrides", which is what FabledCurator's 85/86 should have been instead of
near-copies that drift from their parent.

The tier arg carries the test itself: can you name the trigger WITHOUT naming a
system, an artifact type or a moment? If the honest answer is "whenever you are
working", it is always_on.

Tests: the applicable-rules cases fabricated raw tuples matching the old column
lists, so they move to the entity shape via fake_rule; new cases pin rule_brief
(a DATE not a stamp, the depth left to get_rule, no null keys) and that an
unknown tier falls back to BINDING. fake_rule gains when_to_apply / tier /
arose_from_id for the note-2109 reason the helper exists: unnamed, they would
be truthy MagicMocks. The tool tests stub the new rule_detail seam — they are
about argument forwarding and have no database.

The module header's "Sixteen tools" had been wrong for two milestones; the
registration count test is what actually catches that, so the header now says
so instead of carrying a number.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

tests/helpers.py

@@ -153,8 +153,12 @@ def fake_topic(**attrs) -> MagicMock:
 
 def fake_rule(**attrs) -> MagicMock:
     return _with_defaults({
-        "id": 1, "topic_id": 10, "title": "dev is home",
+        "id": 1, "topic_id": 10, "project_id": None, "title": "dev is home",
         "statement": "Work directly on dev", "why": "", "how_to_apply": "",
+        # Named for the note-2109 reason the whole helper exists: unnamed,
+        # `when_to_apply` and `arose_from_id` would be truthy MagicMocks and
+        # rule_brief would attach both keys on every stand-in.
+        "when_to_apply": None, "tier": "always_on", "arose_from_id": None,
         "order_index": 0, "created_at": _now(), "updated_at": _now(),
     }, attrs)
 

tests/test_mcp_tool_rulebooks.py

@@ -1,5 +1,5 @@
 """Tests for MCP rulebook tools — patches the service layer."""
-from unittest.mock import AsyncMock, patch
+from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
 from tests.helpers import FakeMCP, fake_rule, fake_rulebook, fake_topic
@@ -48,11 +48,25 @@ async def test_get_rulebook_raises_when_not_found():
             await get_rulebook(rulebook_id=999)
 
 
+def _plain_detail():
+    """Stub the rule_detail seam these tool tests are not about.
+
+    create/update/get_rule now return through services.rulebooks.rule_detail,
+    which reads the rule's areas and edges from the database. These are unit
+    tests with no database, and what they assert is that the TOOL forwards the
+    right arguments — so the seam is stubbed to the plain record, the same way
+    they already stub the create/update calls themselves.
+    """
+    async def _detail(_uid, rule, _system_ids=None):
+        return rule.to_dict()
+    return patch("scribe.mcp.tools.rulebooks.rulebooks_svc.rule_detail", _detail)
+
+
 @pytest.mark.asyncio
 async def test_create_rule_passes_required_fields():
     rule = fake_rule(id=100, title="r", statement="s", topic_id=10)
     mock = AsyncMock(return_value=rule)
-    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_rule", mock):
+    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_rule", mock), _plain_detail():
         from scribe.mcp.tools.rulebooks import create_rule
         await create_rule(
             topic_id=10, title="dev is home", statement="Work directly on dev",
@@ -84,7 +98,8 @@ async def test_create_rule_force_bypasses_duplicate_gate():
     find_mock = AsyncMock()
     with patch("scribe.mcp.tools.rulebooks.dedup_svc.find_duplicate_rule", find_mock), \
          patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_rule",
-               AsyncMock(return_value=fake_rule(id=5, title="r", statement="s", topic_id=10))):
+               AsyncMock(return_value=fake_rule(id=5, title="r", statement="s", topic_id=10))), \
+         _plain_detail():
         from scribe.mcp.tools.rulebooks import create_rule
         out = await create_rule(topic_id=10, title="dev is home", statement="x", force=True)
     assert out["id"] == 5
@@ -95,7 +110,7 @@ async def test_create_rule_force_bypasses_duplicate_gate():
 async def test_update_rule_only_sends_non_default_fields():
     rule = fake_rule(id=100, title="r", statement="s", topic_id=10)
     mock = AsyncMock(return_value=rule)
-    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.update_rule", mock):
+    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.update_rule", mock), _plain_detail():
         from scribe.mcp.tools.rulebooks import update_rule
         await update_rule(rule_id=1, statement="new statement")
     args, kwargs = mock.call_args
@@ -169,7 +184,7 @@ def test_register_attaches_all_sixteen_tools():
     mcp = FakeMCP()
 
     register(mcp)
-    assert len(mcp.names) == 24   # +exclude/include_always_on_rulebook (milestone 297)
+    assert len(mcp.names) == 26   # +relate_rules/unrelate_rules (milestone 307)
     # spot-check a few names
     assert "list_rulebooks" in mcp.names
     assert "create_rule" in mcp.names
@@ -239,7 +254,7 @@ async def test_update_rulebook_omits_always_on_when_none():
 async def test_create_project_rule_passes_required_fields():
     rule = fake_rule(id=100, title="r", statement="s", topic_id=10)
     mock = AsyncMock(return_value=rule)
-    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_project_rule", mock):
+    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_project_rule", mock), _plain_detail():
         from scribe.mcp.tools.rulebooks import create_project_rule
         await create_project_rule(
             project_id=42,
@@ -257,7 +272,7 @@ async def test_create_project_rule_passes_required_fields():
 async def test_create_project_rule_derives_title_from_statement():
     rule = fake_rule(id=100, title="r", statement="s", topic_id=10)
     mock = AsyncMock(return_value=rule)
-    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_project_rule", mock):
+    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_project_rule", mock), _plain_detail():
         from scribe.mcp.tools.rulebooks import create_project_rule
         await create_project_rule(
             project_id=42,
@@ -272,7 +287,7 @@ async def test_create_project_rule_derives_title_from_statement():
 async def test_create_project_rule_uses_explicit_title_when_given():
     rule = fake_rule(id=100, title="r", statement="s", topic_id=10)
     mock = AsyncMock(return_value=rule)
-    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_project_rule", mock):
+    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.create_project_rule", mock), _plain_detail():
         from scribe.mcp.tools.rulebooks import create_project_rule
         await create_project_rule(
             project_id=42,
@@ -325,3 +340,47 @@ async def test_unsuppress_topic_for_project_passes_through():
     kwargs = mock.call_args.kwargs
     assert kwargs == {"project_id": 3, "topic_id": 22, "user_id": 7}
     assert out == {"project_id": 3, "topic_id": 22, "suppressed": False}
+
+
+# ── Typed edges between rules (milestone 307) ───────────────────────────
+
+@pytest.mark.asyncio
+async def test_relate_rules_forwards_the_kind_and_the_why():
+    """The edge exists so a shape stops being merged into one row. The `note`
+    travels with it for the same reason a rule carries `why`: whoever later
+    decides whether the edge still holds needs the reasoning."""
+    relation = MagicMock()
+    relation.to_dict.return_value = {"id": 9, "kind": "co_surfaces"}
+    mock = AsyncMock(return_value=relation)
+    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.add_rule_relation", mock):
+        from scribe.mcp.tools.rulebooks import relate_rules
+        out = await relate_rules(
+            from_rule_id=46, to_rule_id=144, kind="co_surfaces",
+            note="a stale channel tag and an unparseable version both read as "
+                 "no update available",
+        )
+    assert out["id"] == 9
+    args = mock.call_args.args
+    assert args[0] == 7 and args[1] == 46 and args[2] == 144
+    assert args[3] == "co_surfaces"
+    assert "no update available" in args[4]
+
+
+@pytest.mark.asyncio
+async def test_relate_rules_raises_when_either_end_is_not_yours():
+    """The service returns None when it cannot see both rules — a one-sided
+    edge would surface a rule the caller has no business reading."""
+    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.add_rule_relation",
+               AsyncMock(return_value=None)):
+        from scribe.mcp.tools.rulebooks import relate_rules
+        with pytest.raises(ValueError, match="not found"):
+            await relate_rules(from_rule_id=1, to_rule_id=2, kind="overrides")
+
+
+@pytest.mark.asyncio
+async def test_unrelate_rules_raises_when_the_edge_is_gone():
+    with patch("scribe.mcp.tools.rulebooks.rulebooks_svc.remove_rule_relation",
+               AsyncMock(return_value=False)):
+        from scribe.mcp.tools.rulebooks import unrelate_rules
+        with pytest.raises(ValueError, match="not found"):
+            await unrelate_rules(relation_id=99)

tests/test_routes_rulebooks.py

@@ -44,7 +44,8 @@ def test_service_signatures_require_user_id():
         "create_rulebook", "list_rulebooks", "get_rulebook",
         "update_rulebook", "delete_rulebook", "find_rulebook_by_title",
         "create_topic", "list_topics", "get_topic", "update_topic", "delete_topic",
-        "create_rule", "create_project_rule",
+        "create_rule", "create_project_rule", "rule_detail",
+        "set_rule_systems", "add_rule_relation", "remove_rule_relation",
         "list_rules", "list_always_on_rules",
         "get_rule", "update_rule", "delete_rule",
         "subscribe_project", "unsubscribe_project", "get_applicable_rules",
@@ -117,5 +118,7 @@ def test_rule_and_subscription_handlers_callable():
     for name in (
         "list_rules", "create_rule", "get_rule", "update_rule", "delete_rule",
         "subscribe_project", "unsubscribe_project", "get_project_rules",
+        # The typed edges — both doors carry them (rule 33).
+        "relate_rules", "unrelate_rules",
     ):
         assert callable(getattr(rb_routes, name))

tests/test_services_rulebooks.py

@@ -2,6 +2,7 @@
 
 Mirrors the pattern in tests/test_events_service.py.
 """
+from datetime import datetime, timezone
 from unittest.mock import AsyncMock, MagicMock, patch
 
 import pytest
@@ -206,8 +207,10 @@ async def test_get_applicable_rules_returns_shape():
     sub_result.all.return_value = [(1, "FabledSword family")]
     rules_result = MagicMock()
     rules_result.all.return_value = [
-        # (rule_id, title, statement, topic_id, topic_title, rulebook_id, rulebook_title)
-        (i, f"Rule {i}", f"Statement {i}", 2, "git-workflow", 1, "FabledSword family")
+        # The query selects the ENTITY plus three labels, so rule_brief stays
+        # the one place deciding what a surfaced rule carries (note 3026).
+        (fake_rule(id=i, title=f"Rule {i}", statement=f"Statement {i}", topic_id=2),
+         "git-workflow", 1, "FabledSword family")
         for i in range(50)
     ]
     # Execute order: sub_q, suppressed_rules_q, suppressed_topics_q, rules_q, proj_rules_q
@@ -244,7 +247,7 @@ async def test_get_applicable_rules_truncates_when_over_limit():
     sub_result.all.return_value = []
     rules_result = MagicMock()
     rules_result.all.return_value = [
-        (i, f"r{i}", "stmt", 2, "topic", 1, "rb") for i in range(51)
+        (fake_rule(id=i, title=f"r{i}"), "topic", 1, "rb") for i in range(51)
     ]
     mock_session.execute = AsyncMock(side_effect=[
         sub_result, _empty(), _empty(), rules_result, _empty(),
@@ -265,8 +268,10 @@ async def test_get_applicable_rules_includes_project_scoped_rules():
     mock_session = make_mock_session()
     proj_rules_result = MagicMock()
     proj_rules_result.all.return_value = [
-        (100, "Use alembic", "Always run migrations via alembic, never raw SQL."),
-        (101, "PR-bound", "Land schema changes in their own PR."),
+        (fake_rule(id=100, topic_id=None, project_id=3, title="Use alembic",
+                   statement="Always run migrations via alembic, never raw SQL."),),
+        (fake_rule(id=101, topic_id=None, project_id=3, title="PR-bound",
+                   statement="Land schema changes in their own PR."),),
     ]
     mock_session.execute = AsyncMock(side_effect=[
         _empty(), _empty(), _empty(), _empty(), proj_rules_result,
@@ -311,3 +316,52 @@ async def test_get_applicable_rules_surfaces_suppressed_with_context():
     assert result["suppressed_rules"][0]["rulebook_title"] == "FabledSword family"
     assert len(result["suppressed_topics"]) == 1
     assert result["suppressed_topics"][0]["title"] == "design-system"
+
+
+# ── rule_brief + tier (milestone 307) ───────────────────────────────────
+
+def test_rule_brief_carries_age_but_not_the_deep_fields():
+    """The shape a SURFACED rule takes, and the reason it exists.
+
+    There were three hand-written copies of this dict and they had already
+    diverged — none carried the timestamps the model has always held, which is
+    why a rule written before the capability it duplicates was
+    indistinguishable at read time from one still doing work (note 3026).
+    """
+    from scribe.services.rulebooks import rule_brief
+
+    out = rule_brief(fake_rule(
+        when_to_apply="before any git push",
+        updated_at=datetime(2026, 6, 1, 14, 30, tzinfo=timezone.utc),
+    ))
+    assert out["when_to_apply"] == "before any git push"
+    assert out["tier"] == "always_on"
+    # A DATE, not a stamp: the question is "how old is this", and a full ISO
+    # string across the always-on set is ~2k characters of payload.
+    assert out["updated_at"] == "2026-06-01"
+    # The depth stays with get_rule — putting it in every listing is the bloat
+    # this milestone is about.
+    assert "why" not in out and "how_to_apply" not in out
+
+
+def test_rule_brief_omits_keys_a_rule_has_no_value_for():
+    """#2483: a null key reads as a capability the record has and isn't using,
+    which is a different claim from not having one."""
+    from scribe.services.rulebooks import rule_brief
+
+    out = rule_brief(fake_rule())
+    assert "when_to_apply" not in out
+    assert "arose_from_id" not in out
+
+
+def test_an_unknown_tier_falls_back_to_binding():
+    """The asymmetry that decides the direction: a rule that preloads when it
+    needn't costs context; a rule that quietly stops preloading costs the
+    behaviour it was written for. So a typo binds."""
+    from scribe.services.rulebooks import _valid_tier
+
+    assert _valid_tier("conditional") == "conditional"
+    assert _valid_tier("always_on") == "always_on"
+    assert _valid_tier("Conditional") == "always_on"
+    assert _valid_tier("") == "always_on"
+    assert _valid_tier("occasionally") == "always_on"