feat(lessons): a lesson is readable, writable and browsable by a human (#3734)

Step 7's actual UI. Before this the frontend had zero lesson code — the kind
existed for agents only, which is rule 27 failing.

THE EDITOR ASKS FOR THE TRIGGER BY NAME, and leads with it. Three fields —
the trigger, the claim, the detail — never one markdown box. That is the
design step 1 settled, and the evidence is blunt: the snippet corpus carries
a trigger on every record with no guard anywhere, because a service composes
the title from a named parameter. What is at 100% is a named structured
field, not a writer remembering a convention. The trigger gets the most room,
its own explanation, and a save button that refuses without it and says why.

The form shows the composed title live, so the writer is agreeing to a
document they can read rather than one assembled out of sight. A 409 from the
duplicate gate is rendered as the record that already covers the moment, with
a link to improve it and an explicit override — not as a failure.

THE BROWSE VOCABULARY GAINS THE KIND, which #3161 warned this step not to get
wrong: a facet chip, a badge label, and routing to `/lessons/:id` rather than
the note editor, which cannot edit a trigger. The badge is neutral alongside
snippet and process — a hue would make the softest record in the corpus look
like the loudest, next to a rule that actually binds.

BOTH DIRECTIONS OF THE PROVENANCE. The detail page resolves `learned_from` to
titles rather than bare ids, because "#4181" tells a reader nothing about
whether it is worth opening. And `LessonsTaughtPanel` answers the reverse on
the record's own page — the direction the task body calls the one that gets
forgotten. It has no author to type it, which is exactly why it tends never
to get built. A component, not markup in the task editor, so the same panel
mounts on any record a lesson can cite instead of being written a second time
(#3207). Silent when empty: most records taught no lesson, and a panel that
says "None yet" everywhere is one people learn to skip.

GLOBAL-BY-DEFAULT IS MADE LEGIBLE. A lesson meeting you on a project it was
not written on reads as a bug unless the page says otherwise, so the origin
line says it as a property of the kind rather than as an apology.

Design system tokens throughout; no new raw hex. `--fs-error` rather than
`--fs-danger` — 31 uses against 1.

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

src/scribe/services/lessons.py

@@ -445,6 +445,50 @@ def lesson_to_dict(note) -> dict:
     }
 
 
+async def source_records(user_id: int, ids: list[int]) -> list[dict]:
+    """The records that taught a lesson, resolved to something linkable.
+
+    `learned_from` is a list of bare ids, which is right for storage and
+    useless on a page: "#4181" tells a reader nothing about whether it is
+    worth opening. This resolves each to its title and kind so the UI can
+    label the link, and so a source that has been deleted simply drops out
+    rather than rendering a link to nothing.
+
+    One query for the whole list, not one per id — a lesson with six sources
+    would otherwise be six round trips to draw one panel.
+
+    Share-aware (rule 78). Order follows `ids`, because that order is the
+    writer's: the first source is the one they reached for first.
+    """
+    from sqlalchemy import select
+
+    from scribe.services.access import readable_notes_clause
+
+    wanted = normalize_sources(ids)
+    if not wanted:
+        return []
+    async with async_session() as session:
+        result = await session.execute(
+            select(Note)
+            .where(Note.id.in_(wanted))
+            .where(Note.deleted_at.is_(None))
+            .where(readable_notes_clause(user_id))
+        )
+        found = {n.id: n for n in result.scalars().all()}
+    return [
+        {
+            "id": n.id,
+            "title": n.title,
+            "note_type": n.note_type,
+            "is_task": n.status is not None,
+            "task_kind": n.task_kind,
+            "status": n.status,
+        }
+        for i in wanted
+        if (n := found.get(i)) is not None
+    ]
+
+
 async def lessons_taught_by(user_id: int, record_id: int, limit: int = 20):
     """The lessons drawn FROM one record — the reverse of `learned_from`.