fix(plugin): the sweep missed the arm that fires most — two ledger directories (#4101)

CI caught two things in c61f730, and the second is the one that mattered.

1. `scribe_autoinject.sh` keeps its note ledger in `${TMPDIR}/scribe-autoinject`,
   not `scribe-priorart`. Every ledger NAMED in the hooks was in the one
   directory the sweep visited, so it read as complete — and the arm that fires
   most (598 calls in five days) was the only one still carrying the bug. The
   clear ran, found nothing to remove, and exited 0. `SCRIBE_LEDGER_DIRS` in
   `scribe_defs.sh` is now the roster, and the guard reads that string rather
   than a copy of it, so a test can no longer agree with itself forever.

2. The convention guard over-reached: it flagged `<sid>.snap` and
   `<sid>.blocked`, which live in `scribe-afterwrite` and `scribe-reportcheck`
   and can never be touched by the sweep. It is now two tests keyed on the
   directory, because the two assumptions fail differently — one lets a ledger
   sit where nothing sweeps, the other lets it sit in the right place under a
   name the sweep does not match.

`test_only_the_rule_ledger_is_cleared_and_the_note_ledgers_are_left` also went
red, correctly: the note arms' exemption was a real decision, recorded in a
test, and my commit message said nothing about it had been decided. That was
wrong and the test was right to stop me. The decision is reversed rather than
ignored, and the reasoning is that #4101 removed its premise: it rested on a
note repeat being WITHHELD, so clearing the ledger meant re-injecting whole
menu lines the session already had. Now a repeat is rendered with a `seen`
marker, so the ledger only decides whether that marker is true — and across a
compaction it is false, telling a freshly-summarised session it has already
seen a record that is nowhere in its context. The test keeps its name and
records the reversal with the reason, rather than being deleted.

Verified by running the hook directly: all six ledgers across both directories
gone on `compact`, `<sid>.unreached` left standing.

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

tests/test_session_context_ledger.py

@@ -108,14 +108,29 @@ def test_the_rules_ledger_survives_exactly_when_the_context_does(tmp_path):
     )
 
 
-def test_only_the_rule_ledger_is_cleared_and_the_note_ledgers_are_left(tmp_path):
-    """Scope, asserted rather than described.
+def test_the_note_ledgers_are_cleared_too_now_that_a_repeat_is_shown(tmp_path):
+    """The decision this test used to pin, reversed — and why it could be.
 
-    The same directory holds `.ids`, `.sync.ids` and `.derive.ids` for the note
-    arms. Whether a surfaced NOTE should come back after a compaction is a
-    different question with a different answer, and it is not being answered.
-    A `rm` glob over `<sid>.*` would pass every assertion in the test above
-    while silently deciding it.
+    It read: the note arms were deliberately left out of #3749, whether a
+    surfaced NOTE should come back after a compaction is a different question,
+    and a glob over `<sid>.*` would decide it by accident. That was right when
+    it was written, and the reason was the note arms' behaviour rather than the
+    note arms' nature: a note repeat was WITHHELD, so clearing their ledger
+    meant re-injecting whole menu lines the session had already been given.
+    Against that, leaving them was the cheaper mistake.
+
+    #4101 removed the premise. A note repeat is now rendered again with a
+    `seen` marker instead of dropped from the search, so the ledger no longer
+    decides whether a record is reachable — only whether its line says the
+    session has met it before. Across a compaction that marker becomes a false
+    statement: it tells a freshly-summarised session it has already seen a
+    record that is nowhere in its context. Keeping the ledger buys nothing and
+    asserts something untrue.
+
+    Kept as a named test rather than deleted, because the roster it guards
+    moved to tests/test_session_ledger_clear.py and what is worth keeping HERE
+    is the record that the answer changed, with the reason attached — a
+    deleted test takes the old decision's reasoning with it.
     """
     env = _env(tmp_path)
     sid = "sess-scope"
@@ -127,10 +142,9 @@ def test_only_the_rule_ledger_is_cleared_and_the_note_ledgers_are_left(tmp_path)
     _fire("compact", sid, env)
 
     assert not rules.exists(), "the rule ledger should have been cleared"
-    assert notes.exists() and sync.exists() and derive.exists(), (
-        "a note ledger was cleared too. The note arms were deliberately left "
-        "out of #3749 — clearing them is a decision about a different surface, "
-        "and a glob that takes them along makes it by accident."
+    assert not (notes.exists() or sync.exists() or derive.exists()), (
+        "a note ledger outlived the context it describes, so its records are "
+        "marked `seen` to a session that can no longer see them"
     )