feat(lessons): judged when written — a new lesson is offered its rules, and "no rule fits" is an answer (milestone 440 step 2, #4631)

"Which rule is this lesson an instance of?" now has three recorded answers:
a rule named (a confirmed link, #4630), no rule fits (new), or unjudged.

- Model + migration 0112: lesson_no_rule (lesson_id PK, CASCADE from the
  note; why; judged_at). A table rather than a key in notes.data, because
  that mirror is re-composed from the body on every edit and would erase it.
- Service (lesson_rules): set_no_rule rejects any confirmed link with the
  reason; a confirmation (set_lesson_rules or judge_link) deletes the answer;
  require_one_answer refuses both answers in one call before any write;
  judgments_for_lessons + attach_lesson_rules add rule_judgment (and no_rule)
  to every lesson payload; list_unjudged lists the open ones; rule_candidates
  searches rules with the lesson's claim + trigger at the explicit-search bar,
  None when the search could not run.
- MCP: create_lesson/update_lesson take no_rule; an unanswered create returns
  rule_candidates, rule_judgment and a rule_hint; list_lessons(unjudged=true).
- REST: the same on POST/PATCH /api/lessons and GET ?unjudged=1; create
  returns rule_candidates.
- Backup v19: a lesson_no_rule section, export (full and per-user) and import.
- Guidance: create_lesson docstring, writing-records.md in using-scribe (owner,
  pinned in test_guidance_ownership), create_rule docstring on linking the
  lessons a new rule governs. Plugin version minted.
- Tests: door units, integration for the three states, the rejection reason,
  scoping, cascade; backup registries.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

tests/test_lesson_rule_link_doors.py

@@ -143,3 +143,123 @@ def test_backup_keeps_an_unjudged_link_unjudged():
     )
     assert (built.lesson_id, built.rule_id, built.state) == (110, 120, "suggested")
     assert built.judged_at is None
+
+
+# ── #4631: judged when written ───────────────────────────────────────────────
+
+
+@pytest.mark.asyncio
+async def test_an_unanswered_lesson_comes_back_with_rules_to_judge_against():
+    """Neither answer given: the create offers the rules the lesson resembles,
+    searched with its claim and trigger and scoped to its project."""
+    _user_id_ctx.set(7)
+    offered = [{"id": 5, "title": "Read the log", "kind": "rule",
+                "when_to_apply": "a run overran", "score": 0.61}]
+    search = AsyncMock(return_value=offered)
+    p1, p2, p3 = _create_patches(AsyncMock(return_value=_stub_note()))
+    with p1, p2, p3, patch.object(links_svc, "rule_candidates", search):
+        out = await lesson_tools.create_lesson(what="x", when_to_apply=TRIGGER, project_id=2)
+    assert search.await_args.args == (7, "x", TRIGGER, 2)
+    assert out["rule_candidates"] == offered
+    assert out["rule_judgment"] == links_svc.UNJUDGED
+    assert "no_rule" in out["rule_hint"] and "rule_ids" in out["rule_hint"]
+
+
+@pytest.mark.asyncio
+async def test_a_search_that_could_not_run_offers_no_list_rather_than_an_empty_one():
+    """None means unavailable; an empty list would claim nothing resembles it."""
+    _user_id_ctx.set(7)
+    p1, p2, p3 = _create_patches(AsyncMock(return_value=_stub_note()))
+    with p1, p2, p3, patch.object(links_svc, "rule_candidates", AsyncMock(return_value=None)):
+        out = await lesson_tools.create_lesson(what="x", when_to_apply=TRIGGER)
+    assert "rule_candidates" not in out
+    assert out["rule_judgment"] == links_svc.UNJUDGED
+
+
+@pytest.mark.asyncio
+async def test_no_rule_on_create_records_the_answer_and_offers_nothing():
+    _user_id_ctx.set(7)
+    answered = AsyncMock()
+    search = AsyncMock(return_value=[])
+    p1, p2, p3 = _create_patches(AsyncMock(return_value=_stub_note(id=41)))
+    with p1, p2, p3, patch.object(links_svc, "set_no_rule", answered), \
+         patch.object(links_svc, "rule_candidates", search):
+        out = await lesson_tools.create_lesson(
+            what="x", when_to_apply=TRIGGER, no_rule="a one-off of this CI host",
+        )
+    assert answered.await_args.args[1:] == (41, "a one-off of this CI host")
+    search.assert_not_awaited()
+    assert "rule_candidates" not in out
+
+
+@pytest.mark.asyncio
+async def test_rules_and_no_rule_together_write_nothing():
+    _user_id_ctx.set(7)
+    created = AsyncMock(return_value=_stub_note())
+    p1, p2, p3 = _create_patches(created)
+    with p1, p2, p3, patch.object(links_svc, "require_rules", AsyncMock(return_value=[5])):
+        with pytest.raises(ValueError, match="no_rule"):
+            await lesson_tools.create_lesson(
+                what="x", when_to_apply=TRIGGER, rule_ids=[5], no_rule="none fits",
+            )
+    created.assert_not_awaited()
+
+
+@pytest.mark.asyncio
+async def test_update_records_no_rule_and_refuses_it_beside_named_rules():
+    _user_id_ctx.set(7)
+    answered = AsyncMock()
+    updated = AsyncMock(return_value=_stub_note())
+    with patch.object(lessons_svc, "update_lesson", updated), \
+         patch.object(links_svc, "set_no_rule", answered):
+        await lesson_tools.update_lesson(lesson_id=41, no_rule="stands alone")
+    assert answered.await_args.args[1:] == (41, "stands alone")
+
+    updated.reset_mock()
+    with patch.object(lessons_svc, "update_lesson", updated), \
+         patch.object(links_svc, "require_rules", AsyncMock(return_value=[5])):
+        with pytest.raises(ValueError):
+            await lesson_tools.update_lesson(lesson_id=41, rule_ids=[5], no_rule="none")
+    updated.assert_not_awaited()
+
+
+def test_an_empty_rule_list_beside_no_rule_is_one_answer_not_two():
+    """`rule_ids=[]` clears; it does not name a rule, so it cannot contradict."""
+    links_svc.require_one_answer([], "none fits")
+    links_svc.require_one_answer(None, "none fits")
+    links_svc.require_one_answer([5], "")
+    with pytest.raises(ValueError):
+        links_svc.require_one_answer([5], "none fits")
+
+
+@pytest.mark.asyncio
+async def test_list_unjudged_is_a_listing_and_routes_to_its_own_query():
+    _user_id_ctx.set(7)
+    listed = AsyncMock(return_value=([], 0))
+    with patch.object(links_svc, "list_unjudged", listed), \
+         patch("scribe.mcp.tools.lessons.access_svc.label_shared_items", AsyncMock(return_value=[])), \
+         patch("scribe.mcp.tools.lessons.attach_usage", AsyncMock()):
+        out = await lesson_tools.list_lessons(unjudged=True, tag="ci", project_id=2)
+    assert out == {"lessons": [], "total": 0}
+    assert listed.await_args.kwargs["tag"] == "ci"
+    assert listed.await_args.kwargs["project_id"] == 2
+    with pytest.raises(ValueError):
+        await lesson_tools.list_lessons(unjudged=True, q="log")
+
+
+def test_backup_skips_a_no_rule_answer_whose_lesson_did_not_restore():
+    maps = backup._Maps()
+    assert backup._build_lesson_no_rule({"lesson_id": 10, "why": "alone"}, maps) is None
+    maps.notes[10] = 110
+    built = backup._build_lesson_no_rule({"lesson_id": 10, "why": "alone"}, maps)
+    assert (built.lesson_id, built.why) == (110, "alone")
+    # An answer with no reason is not an answer; it restores as unjudged.
+    assert backup._build_lesson_no_rule({"lesson_id": 10, "why": " "}, maps) is None
+
+
+def test_the_no_rule_migration_follows_the_link_migration():
+    path = Path(__file__).resolve().parents[1] / "alembic" / "versions" / "0112_lesson_no_rule.py"
+    spec = importlib.util.spec_from_file_location("m0112", path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+    assert (module.revision, module.down_revision) == ("0112", "0111")