2 Commits

Include renames

Author	SHA1	Message	Date
HomerandClaude Opus 5	8503c6c775	A crowd that does not agree with whoever spoke last ... Three fixes to how a round behaves, found by reading one real round on the live instance rather than by testing it. A member asked "what would you have done differently" answered the person's original question again instead of critiquing what was already there. Fine on a question with one answer; on a request to *make* something it is an invitation. `crowd.turn` now says to respond to what is above and not to re-answer. The model that opened the round, told to write the final answer and take what the others got right, abandoned its own good answer and adopted the newcomer's position with no argument anywhere for why. Both closing fragments now say that an answer is not the worse one for having been written first, and that agreement with no argument behind it is not a reason to change. That second one is not cosmetic: all three answers from the observed round were compiled. The original and the critic's alternative both build; the merged answer that was actually delivered does not. A crowd's failure mode is not looping -- the caps handle that -- it is converging on the last thing said. Third, the reply that opens a round now carries a chip like every other one. It is the single contribution the crowd does not start, so there was nothing to stamp it with until the round began, and a two-model round rendered as an unmarked reply followed by one saying "2 of 2". The stamp is display state and never scheduling state: `crowd.scheduling_state` hides it from everything that decides what happens next, because fed to the scheduler it would inherit the round's clock -- regenerating the opening an hour later would end the round with "out of time" before anybody spoke -- and would hand that reply a member's tools and a member's instruction. And the chip was never translated. It is now, with the count as placeholders rather than three t() calls around one sentence. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-26 21:10:25 +00:00
HomerandClaude Opus 5	da0797ccad	A crowd in one chat ... The chat's own model answers, then each other member in order, then the order runs backwards asking each whether it disagrees, ending at the main model, which either closes or sends them round again. Design and reasoning: LLeMbas.wiki/Crowd-chats. THE SPEAKER SEAM, WHICH IS ALSO A BUG FIX `chat_service.speaker_for` makes the *message* name the answering model and the chat only the default. That closes a live half-wired feature -- `wake_chat` takes a model override and `schedule/runner` passes one, and it reached the row and never the request, so a schedule naming another model got the chat's model wearing the other one's name. The seam is wider than `build_request`: `{{model_name}}`, the authored prompt's model layer, `vision` (where a wrong answer makes the endpoint reject the whole request), the effort vocabulary (which raises inside the model's own chat template, and whose refusal narrows every Model row sharing the id), `resolve_tools`, `context_length` -> `_too_big`, and `ToolContext.model_id`. `resolve_endpoint` may now only write back `chat.connection_id` when the speaker *is* the chat's model. WHY N CHAINED REPLIES `Generation` is one reply's state and `_follow` streams per message, so one generation cannot stream into nine bubbles and `ensure` would not know which of the nine it was after a restart. A subagent per speaker cannot work either: its answer comes back as a tool result and tool results are never replayed, so speaker 3 could not see speaker 2 -- which is the whole point. Chained, exactly one incomplete row exists at a time, and `tests/test_crowd_chain.py` asserts that at every observation. The round lives on `Message.crowd_json`, not on the chat: the row is the authority, and chat-level state would describe turns a rewind or a restart had removed. `crowd.next_turn` is pure, so all eight refusals are tested with no endpoint. THREE RULES, EACH A BUG WRITTEN THE OTHER WAY ROUND - `if not _advance_crowd(g): _drain(g)` -- advancing must *suppress* draining, or a queued human turn puts a second incomplete row beside the next speaker's. - `_advance_crowd` refuses unless the finishing row is the newest, or regenerating member 2 creates a second member 3 and two chains race down one turn. - an error skips one speaker and two in a row end the round: the usual failure is a small member's window overflowing, and `_drain`'s stop-on-error would kill every crowd at whichever member is smallest. Each other speaker's turn is relabelled as attributed user content, which is both how a model can disagree with words it did not write and how the history keeps alternating. The per-speaker instruction is payload-only -- as a row it could be dropped from the request by a `created_at` tie, and every later speaker would answer it. Compaction, titling and the notification are gated to once per turn; `_inject` is off during a round; the way back gets no tools and a member is treated as unattended. Membership stores the model as text with no foreign key: "Test & refresh" deletes and recreates Model rows, and a cascade would empty the crowd out of every chat. Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>	2026-09-26 13:38:52 +00:00