feat(rules)!: retire the always-on tier — every rule arrives by retrieval (#394)

Milestone 394, steps 5-8. Operator: "remove the always on rule functionality
as the goal was to not have it at all since it didn't seem to work as
expected."

Unconditional preload had three failures the retrieval arms do not. It could
not be MEASURED — a resident rule is in the context whether or not it
mattered, so nothing distinguished "this governed the act" from "this was
scenery", and it was the one surface structurally exempt from the scoreboard
judging every other. It was SUMMARISED AWAY by compaction while the session
went on believing it held the rules. And it CROWDED OUT the few rules that
applied with the thirty that did not.

WHAT GOES

Schema (0100): rules.tier + ck_rules_tier, rule_versions.tier,
rulebooks.always_on, and project_rulebook_exclusions — a table recording a
project's opt-out of something that no longer binds it unasked.

Tools: list_always_on_rules, exclude_always_on_rulebook,
include_always_on_rulebook. Service: the same three plus rules_etag_for,
_valid_tier and the whole etag family. The SessionStart preload and the
write-path staleness arm go with them: nothing is resident, so nothing can
have drifted since a session loaded it.

THREE CALLS WORTH REVIEWING

enter_project got NARROWER, not wider. Its filter was `always_on OR
area-tagged`; dropping the tier arm leaves the deterministic half, so a
project with no canonical-tagged Systems gets no bulk rules and reaches them
by retrieval instead. Dropping the whole clause would have made that payload
bigger than the preload this milestone deletes.

Backups import tolerantly. A pre-394 archive carries tier, always_on and the
retired inception choice; none is read, and the exclusion key is DROPPED
rather than remapped, because restoring it would write data that
validate_inception now rejects as unknown.

The migration is irreversible in the way that matters and says so: downgrade
recreates the columns at their defaults and cannot restore which rules were
always-on. A value invented to fill a hole is not a measurement.

THE INSTRUCTION SURFACES SAY THE HARDER THING

Deleting "call list_always_on_rules()" is easy; replacing it is not, because
the new model asks a session to trust something it cannot see. All three
surfaces now say a session holds nothing, that rules arrive when work matches
them, and — the half that got dangerous — that "no rule arrived" means
"nothing matched", never "there is no rule". Under residency an empty session
was rare and suspicious; it is now the ordinary state of most turns, so
reading it as permission is wrong on nearly every turn rather than
occasionally. That is #3720's defect at session scale.

test_instruction_surfaces_agree is repointed rather than retired: its two
halves collapsed into one instruction, and it gains a guard that every
surface states what absence means. _INSTRUCTIONS is back at 1999/2000 —
the inception clause paid for the longer HOW line.

UI (rule 27, and the opportunity step 8 named)

The tier selector is gone, and what replaces it is the point: `when_to_apply`
is now the field that decides whether a rule is ever seen, so the editor
marks it required, warns while it is empty, and both rule lists badge a
trigger-less rule "never surfaces". A rule without one is not quiet, it is
unreachable.

TESTS

Two files deleted outright — test_rules_etag.py and test_inception_rules.py
tested subsystems that no longer exist. Elsewhere obsolete cases were removed
and the rest repointed. One deserves naming: the wiring test asserted the act
arms pass no `tier`, which had become an assertion that could not fail. It is
repointed onto `kind`, which does still exist and where the same claim is
live — a preference must reach a write exactly as a rule does.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_011cPyzNnegXHr5iRMzzy5KJ

tests/test_instruction_surfaces_agree.py

@@ -1,4 +1,4 @@
-"""The instruction surfaces must agree that the agent pulls the rules itself.
+"""The instruction surfaces must agree on how a rule reaches a session.
 
 WHY THIS EXISTS
 
@@ -17,16 +17,23 @@ an extended period, and nothing announced it. An agent trusting the push would
 have run with no binding rules and no signal — while those rules govern branch,
 commit, push and other hard-to-reverse actions.
 
-The asymmetry is the whole argument, and it is what these tests pin: pulling
-when a push also arrived costs one redundant call; not pulling when the push
-never came costs the operator's rules entirely.
+The asymmetry is the whole argument, and it is what these tests pin: asking
+when a rule had already arrived costs one redundant call; not asking when
+nothing arrived costs the operator's rules entirely.
+
+MILESTONE 394 SHARPENED IT RATHER THAN RETIRING IT. There is no longer a
+resident set to pull, so "no rule in front of me" went from a rare and
+suspicious state to the ordinary state of most turns. The instruction that
+used to be supplementary — go and ask — is now the only route a rule has, and
+the surfaces must additionally say what an EMPTY session means, or a session
+reads silence as permission on nearly every turn.
 
 WHAT THIS DOES NOT DO
 
 It cannot tell whether two surfaces contradict each other in prose generally —
-that needs a reader. It pins the one instruction whose absence is known to be
+that needs a reader. It pins the instructions whose absence is known to be
 load-bearing, and the specific shape the #2497 defect took: naming the push
-without also stating the pull.
+without also stating how to ask.
 """
 from __future__ import annotations
 
@@ -34,8 +41,33 @@ import pathlib
 
 ROOT = pathlib.Path(__file__).resolve().parents[1]
 
-# The pull instruction, however a surface phrases the surrounding prose.
-PULL = "list_always_on_rules"
+# THE PULL IS NOW THE ASK (milestone 394). This was `list_always_on_rules`,
+# the call that fetched the resident set. There is no resident set and no such
+# call: a rule reaches a session by retrieval, and the only thing a session can
+# DO about a rule it has not been handed is go looking for one.
+#
+# So the two halves this file used to pin separately — "pull the resident set"
+# and "and retrieve the conditional ones too" — have collapsed into one
+# instruction, and it is the load-bearing one rather than the supplementary
+# one it used to be.
+ASK = 'content_type="rule"'
+
+# A surface must also say what an EMPTY session means, which is the half that
+# is newly dangerous. Under residency, "no rule in front of me" was rare and
+# suspicious. Under retrieval it is the ordinary state of most turns, so a
+# session that reads it as "there is no rule" is wrong on nearly every turn
+# rather than occasionally — the #3720 defect at session scale.
+#
+# Claim phrases, not a single word, for the reason BINDING_CLAIMS gives below:
+# a bare "matched" or "silence" appears in prose that is not making this claim
+# at all. A surface passes by asserting the distinction however it words it.
+ABSENCE_CLAIMS = (
+    "nothing matched",
+    "is not the same as \"there is no rule",
+    "never \"there is no rule",
+    "silence is not absence",
+    "not evidence there is none",
+)
 
 # Surfaces a session loads before substantive work. Hand-written because
 # "is this a session-start surface?" is an editorial fact, not a derivable one —
@@ -67,21 +99,51 @@ def _all_surfaces() -> list[tuple[str, str]]:
     return found
 
 
-def test_every_session_start_surface_states_the_pull():
+def test_every_session_start_surface_states_the_ask():
+    """Retrieval is the only delivery, so asking is the only recourse."""
     missing = []
     for path in SESSION_START_SURFACES:
         assert path.exists(), (
             f"{path.relative_to(ROOT)} is gone — it was one of the surfaces "
-            f"carrying the load-the-rules instruction. If it moved, update "
+            f"carrying the rules instruction. If it moved, update "
             f"SESSION_START_SURFACES; if it was retired, check the instruction "
             f"still lives somewhere a fresh session reads."
         )
-        if PULL not in path.read_text():
+        if ASK not in path.read_text():
             missing.append(str(path.relative_to(ROOT)))
     assert not missing, (
-        f"these surfaces no longer tell the agent to call {PULL}(): {missing}. "
-        f"The rules are pull-only and the push is best-effort, so a surface "
-        f"that omits this leaves a session bound by nothing (#2198, #2497)."
+        f"these surfaces never tell the agent how to ask for a rule "
+        f"({ASK}): {missing}. Nothing is pushed and nothing is resident, so a "
+        f"surface that omits this leaves a session with no way to reach a rule "
+        f"it was not handed — bound by nothing (#2198, #2497, milestone 394)."
+    )
+
+
+def test_every_session_start_surface_says_an_empty_session_is_not_an_empty_rulebook():
+    """The half that got dangerous when residency went away.
+
+    Under the old model a session opened holding every applicable rule, so
+    "nothing is in front of me" was a rare state and a suspicious one. Under
+    retrieval it is the NORMAL state of most turns. A surface that describes
+    where rules come from, without also saying what their absence means, leaves
+    a session reading silence as permission — on nearly every turn rather than
+    occasionally.
+
+    That is #3720's defect ("absence reads as non-existence") moved from a
+    readout to the session itself, and this milestone is what makes every
+    session start in the absent state.
+    """
+    missing = []
+    for path in SESSION_START_SURFACES:
+        text = path.read_text().lower()
+        if not any(c.lower() in text for c in ABSENCE_CLAIMS):
+            missing.append(str(path.relative_to(ROOT)))
+    assert not missing, (
+        f"these surfaces say how a rule arrives but never what it means when "
+        f"none does: {missing}. 'No rule arrived' means 'nothing matched', "
+        f"never 'there is no rule' — and only one of those has been checked. "
+        f"Say it however you like; one of {ABSENCE_CLAIMS} is what this looks "
+        f"for."
     )
 
 
@@ -195,47 +257,7 @@ def test_displaced_topics_live_on_a_delivered_surface():
     )
 
 
-# The SECOND pull (milestone 333 step 3). `list_always_on_rules()` fetches the
-# resident tier; this one says that tier is not all of them, and that a
-# conditional rule has to be gone looking for. However a surface words the
-# surrounding prose, it names the call.
-RETRIEVE = 'content_type="rule"'
-
-
-def test_every_session_start_surface_states_the_conditional_retrieval():
-    """The push/pull asymmetry, one level in.
-
-    The tests above pin that a session PULLS the resident rules rather than
-    trusting the SessionStart push. This pins the same shape between the two
-    TIERS: an always-on rule is delivered, a conditional one is retrieved, and
-    a surface that states only the first leaves a session reading its loaded
-    set as the whole rulebook.
-
-    That reading is wrong in the direction that costs something. "Nothing was
-    pushed" and "no rule applies" are different claims, and only one of them
-    has been checked — the same asymmetry as #2198, now between tiers instead
-    of between channels.
-
-    It is also what made the always-on tier the only one that worked, on any
-    install rather than this one (rule 115). A rule nothing retrieves has to be
-    resident to bind at all, so every rule worth keeping becomes resident; and
-    a resident rule costs tokens in every session forever, so a rulebook that
-    only delivers cannot grow past what one session can hold. Retrieval is what
-    lifts that ceiling — and it only fires if something asks.
-    """
-    missing = []
-    for path in SESSION_START_SURFACES:
-        if RETRIEVE not in path.read_text():
-            missing.append(str(path.relative_to(ROOT)))
-    assert not missing, (
-        f"these surfaces state the always-on pull but never tell the agent to "
-        f"retrieve a conditional rule ({RETRIEVE}): {missing}. A session that "
-        f"reads its loaded set as the whole rulebook will act on \"I was not "
-        f"told\" as if it meant \"there is no rule\" (milestone 333 step 3)."
-    )
-
-
-def test_no_surface_names_the_push_without_stating_the_pull():
+def test_no_surface_names_the_push_without_stating_the_ask():
     """The exact shape #2497 took.
 
     Mentioning the SessionStart hook is fine and often useful. Mentioning it
@@ -244,13 +266,14 @@ def test_no_surface_names_the_push_without_stating_the_pull():
     """
     offenders = [
         label for label, text in _all_surfaces()
-        if "SessionStart" in text and PULL not in text
+        if "SessionStart" in text and ASK not in text
     ]
     assert not offenders, (
-        f"these surfaces describe the SessionStart push but never state the "
-        f"explicit pull: {offenders}. The push is a delivery optimisation, not "
-        f"the bridge — it can be absent without saying so. Name it if it helps, "
-        f"but say to call {PULL}() regardless."
+        f"these surfaces describe the SessionStart push but never state how to "
+        f"ask: {offenders}. The push is a delivery optimisation, not the "
+        f"bridge — it can be absent without saying so, and since milestone 394 "
+        f"it carries no rules at all. Name it if it helps, but say how to ask "
+        f"({ASK}) regardless."
     )