feat(rules): the write path can notice a standing rule it was never given (#3031, milestone 307 step 5, hook arm)

A conditional rule is not resident, so a session can be about to violate one it
was never handed. This arm notices: when what is being written resembles a
rule's trigger, the hint names it and says to read it before deciding it does
not apply.

A SUGGESTION, and the plan was wrong about why it could be more. It claimed the
hook "already resolves a path to an area" — it does not, and nothing in Scribe
maps a path to a System or a canonical area (build_write_path_hint resolves
paths against snippet LOCATIONS, a different index; the learned-alias idea
belongs to another project). Correction logged on the task. Rather than invent
path→area inference to make a stale claim true, the arm does what D7 already
decided and what this surface already IS: tags bind at enter_project, meaning
suggests here. The header of the hook says NEVER BLOCKS; dressing a hint up as
binding would have been the actual mistake.

CONDITIONAL RULES ONLY. An always-on rule is already in the session, so
re-offering it is noise — and noise on a hint that fires on every write is how
a hint gets ignored.

Telemetry goes to retrieval_logs, NOT note_usage_events, and that is a
correctness call rather than a preference: note_usage ids are REMAPPED on a
backup restore, so a rule id written there would come back attached to whatever
note took that number — silently corrupting the evidence the next true-up is
supposed to read. retrieval_logs is never restored and `source` already
separates surfaces. record_retrieval's `results` type widened to match what it
actually needs (an `.id`), instead of passing a Rule to something annotated Note.

The rule dedup gets its OWN state file and query parameter, like the three
channels before it — #2708's lesson was that one shared channel lets a hint of
one class silence a different class that had never been shown. Plugin version
bumped: a hook change clients cannot see did not ship (#1040).

The stub is autouse in conftest rather than added to forty-odd call sites: the
arm loads an embedding model, and every existing test that stubs the NOTES
search would otherwise pull a real model in through the one arm it had no way
to know about.

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

tests/test_write_path_trigger.py

@@ -1435,3 +1435,20 @@ async def test_the_write_time_divergence_check_is_named_in_band():
         out = await pc.build_write_path_hint(1, "x.py", code=REAL_CODE, stamp_shapes=[("sym", "f")])
     check.assert_not_awaited()
     assert out["divergence"] == []
+
+
+def test_hook_keeps_the_rule_channel_apart_from_the_other_three():
+    """Milestone 307's arm, pinned the way #2708's was.
+
+    Standing rules dedup on their OWN file and their OWN query parameter. One
+    shared channel is the bug #2708 already fixed once: a hint of one class
+    silencing a different class that had never been shown. A rule named early
+    must not be re-offered on every later write, and must not silence — or be
+    silenced by — a snippet suggestion.
+    """
+    src = HOOK.read_text()
+    assert ".rules.ids" in src                      # its own state file
+    assert "exclude_rule_ids=" in src               # its own query channel
+    assert "(.rule_ids // [])[]?" in src            # its own write-back
+    # And it rides the same request as the rest, not a second round trip.
+    assert "${rule_exclude_q}" in src