Models that know about each other, and have a self

Three features sharing one idea: a model here started from nothing every
conversation and had no notion that anything else existed.

THE ROSTER. `chat.roster_block` builds one line per model this *person* can
reach -- through `permissions.models_visible_to`, never the table -- and
`{{model_roster}}` carries it, gated on the `friend` family for the reason the
memories block is gated on `memory`: a list of peers a model cannot talk to is
context spent on nothing, and one checkbox is then the whole switch. New
`Model.notes` column, a column and not a `capabilities_json` key for the reason
`context_length` and `reasoning_efforts` both carry.

ASKING A FRIEND. A second entry point in `services/subagent.py` rather than a
second module, so one place still owns the bounds and the lifecycle. `_create_
child` takes the friend's (model_id, connection_id) *pair*, because Model is
unique on both and an id alone does not say which endpoint. Three things differ
from a helper: the effort is the friend's own default and never the parent's (the
1.3.0 bug by another door -- the vocabularies differ and a level a model does not
take raises inside its chat template), the chat is ordinary even when the asker's
is an agent chat, and `scope_json["role"]` marks it so `core.friend` speaks
instead of `core.subagent`. `friend` joins the unattended withdrawal set: a
friend that could ask a friend is the same unbounded fan-out in politer clothes.
Budget, concurrency and quota are shared with helpers, so one reply cannot spend
the allowance twice.

PERSONALITY. One table, two roles, `owner_id IS NULL` the discriminator: the
model's own persona, and its read of one person. Keyed on the model's *text* id
with no foreign key, because "Test & refresh" deletes a model the endpoint has
stopped listing and a personality must not be collateral. `PersonaRevision`
copies SkillRevision, and so does the argument: the safety story for a model
rewriting itself is a record and a way back, not a gate. The reflection is shown
to the person it is about, in their own settings, which is the whole of why
keeping one is acceptable. `persona` is withdrawn from any unattended chat --
a helper's task, a friend's question and a schedule's instruction are all words
nobody watched being written.

Two bugs found while reading for this, both silent:

`review_model_id` stored a `Model` primary key, so a refresh taken while an
endpoint was not listing that model unset the administrator's choice -- and
`_reviewer` then fell back to the chat's own model, so pictures were judged by
a model nobody chose. Now the text id, with the primary key still accepted.

`_messages_after` used a bare `>` on `created_at`, so a row sharing the edited
turn's microsecond survived a rewind -- and `_send` writes a user turn and its
placeholder back to back, which is exactly that tie. Deliberately NOT
`thread_tail`'s `(created_at, id)` tiebreak: ids are random UUIDs, so that
settles a tie by coin toss. A tie now reads as "later", which is the safe
direction for an operation whose purpose is to discard what follows.

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

src/lembas/api/pages.py

@@ -210,6 +210,12 @@ _GATE_LABELS = {
     "report": "Filing reports",
     "schedule": "Scheduling work",
     "subagent": "Sending helpers",
+    "friend": "Asking other models",
+    # Not "Personality": this is a switch that stops it *changing* one, and the
+    # text it has already stays in front of it either way. Turning it off for one
+    # conversation is the useful case -- you are working on something and would
+    # rather this hour did not become part of how it sees you.
+    "persona": "Changing its personality",
     "agent": "Running commands",
     "custom": "Custom tools",
     "mcp": "MCP servers",
@@ -834,6 +840,7 @@ async def settings_page(
     saved: str = "",
 ):
     from lembas.api.audio import available_voices
+    from lembas.services import personas as personas_service
     from lembas.services.library import memories as memories_service
 
     context = _chat_context(db, user, None)
@@ -854,6 +861,13 @@ async def settings_page(
             "voice_error": voice_error,
             "memories": memories_service.all_for(db, user),
             "memory_limit": memories_service.MAX_MEMORY_CHARS,
+            # What each model has made of this person, in its own words. Shown
+            # here because that is the whole reason a model is allowed to keep
+            # one: a note about somebody they cannot read is not something this
+            # application should hold. Labelled by model id, which is what the
+            # row is keyed on -- a model that has since been removed still had an
+            # opinion, and hiding the row would leave no way to delete it.
+            "reflections": personas_service.reflections_for(db, user),
             # Sorted rather than left in set order, because a list of six
             # hundred zones that is not alphabetical is one nobody can use.
             "timezones": sorted(available_timezones()),