feat(commentator): update cadence logic to use a fixed count instead of per-speaker quorum

config/agents/rafters-critic.yaml

@@ -10,10 +10,11 @@ persona: >
   to what just happened, and nothing else.
 # Never event-woken (subscribes_to: []) so it can never re-trigger on its own remark;
 # instead it is POLLED every turn (schedule.tick_every: 1) and the `commentator` handler
-# decides whether to speak — it holds its tongue until each active cast member has spoken
-# a few times since its last remark (a per-speaker quorum, tunable via MAL_COMMENTATOR_EVERY),
-# then drops one funny, illustrated, spoken-aloud beat. Remove this name from a scenario's
-# cast and the engine never knows it existed (ADR-0011).
+# decides whether to speak — it holds its tongue until a few public speech beats have
+# landed since its last remark (a simple count, default 4, tunable via MAL_COMMENTATOR_EVERY),
+# then drops one funny, illustrated, spoken-aloud beat. A plain count (not a per-speaker
+# quorum) means a stalled speaker can never wedge it, so the media beat always fires.
+# Remove this name from a scenario's cast and the engine never knows it existed (ADR-0011).
 subscribes_to: []
 may_emit:
   - commentary.posted

src/agents/base.py

@@ -51,6 +51,17 @@ _ctx = ContextBuilder()
 # domain `may_emit` grant — reflection compacts memory, it is not a world action.
 _REFLECTION_KIND = "agent.reflected"
 
+# Anti-loop corrective re-ask: when the whole cast shares one backend, every agent
+# samples the same model and they drift toward the same line. Rather than silently
+# DROP a near-duplicate turn (which sidelines that agent from the round — one model
+# repeating made it look like a single agent monopolised the show), we nudge once for
+# something new and only skip if it still repeats. Keeps the round collaborative.
+_ANTI_REPEAT_NUDGE = (
+    "\n\nIMPORTANT: another voice just said something almost identical to your draft. "
+    "Say something DIFFERENT this turn — a fresh image, a new beat, your own angle. "
+    "Do not echo or paraphrase a line that was already spoken."
+)
+
 # Live fallback when structured output fails: ask for a plain spoken line, NOT JSON.
 # Weak/reasoning models echo a JSON schema (and its example) and leak their reasoning;
 # asking for prose gives a clean line we can strip and ship.
@@ -170,8 +181,11 @@ class ManifestAgent(Agent):
 
         parsed = self._resolve_payload(self.manifest.name, base_prompt, allowed, extra_fields)
 
-        # Don't echo the table: if this line near-duplicates a recent spoken one, skip
-        # the turn (the conductor records it and moves on) so the conversation advances.
+        # Don't echo the table: if this line near-duplicates a recent spoken one, give the
+        # agent ONE corrective re-ask for something new before skipping. A shared backend
+        # makes the whole cast drift toward the same line, so dropping every duplicate
+        # silently sidelines agents from the round; the nudge keeps each one talking. Only
+        # if the re-ask still repeats do we skip the turn so the conversation advances.
         # Live only — the offline stub's curated catalogue is reproducible by design, and
         # de-duplicating its small set of lines would starve demos and tests of events.
         if (
@@ -179,8 +193,11 @@ class ManifestAgent(Agent):
             and parsed.get("kind") in _SPEECH_KINDS
             and self._is_repeat(parsed.get("text", ""), recent_events)
         ):
-            obs.log("agent.repeat_skip", agent=self.manifest.name, text=str(parsed.get("text", ""))[:120])
-            raise AgentOutputError(f"{self.manifest.name}: repeated a recent line — skipped to keep it moving")
+            obs.log("agent.repeat_retry", agent=self.manifest.name, text=str(parsed.get("text", ""))[:120])
+            parsed = self._resolve_payload(self.manifest.name, base_prompt + _ANTI_REPEAT_NUDGE, allowed, extra_fields)
+            if parsed.get("kind") in _SPEECH_KINDS and self._is_repeat(parsed.get("text", ""), recent_events):
+                obs.log("agent.repeat_skip", agent=self.manifest.name, text=str(parsed.get("text", ""))[:120])
+                raise AgentOutputError(f"{self.manifest.name}: repeated a recent line — skipped to keep it moving")
 
         obs.log("agent.acted", agent=self.manifest.name, kind=parsed["kind"], text=str(parsed.get("text", ""))[:160])
         return Event(

src/agents/commentator.py

@@ -3,10 +3,12 @@
 Most agents are pure declarative config; the commentator needs a handler for two
 things the generic turn cannot express:
 
-  1. **Cadence.** It holds its tongue until *each* active cast member has spoken a
-     few times since its last remark — a per-speaker quorum, not a fixed turn count.
-     It is polled every turn (``schedule.tick_every: 1``) and ABSTAINS (returns
-     ``None``) until the quorum is met, then delivers exactly one beat.
+  1. **Cadence.** It holds its tongue until a few public speech beats have landed
+     since its last remark — a simple count (``MAL_COMMENTATOR_EVERY``, default 4),
+     not a per-speaker quorum. It is polled every turn (``schedule.tick_every: 1``)
+     and ABSTAINS (returns ``None``) until that many beats accrue, then delivers
+     exactly one beat. A plain count means a stalled or errored speaker can never
+     wedge the cadence (so the illustrated/spoken media beat always eventually fires).
 
   2. **Media.** When it does speak it draws an image of the beat and says the line
      aloud, folding both onto its event — the :class:`FortuneTeller` tool pattern,
@@ -36,53 +38,50 @@ from src.core.registry import register_handler
 _SPEECH_KINDS = frozenset({"agent.spoke", "agent.thought", "oracle.spoke", "world.observed"})
 
 _COMMENTARY_KIND = "commentary.posted"
-_DEFAULT_PER_AGENT = 3
+_DEFAULT_EVERY = 1
 
 
 @register_handler("commentator")
 class Commentator(ManifestAgent):
-    """Color commentary on a quorum cadence, with an illustrated, spoken beat."""
+    """Color commentary on a fixed-cadence beat counter, with an illustrated, spoken beat."""
 
     # ── cadence ───────────────────────────────────────────────────────────────
 
-    def _per_agent(self) -> int:
-        """How many times each active speaker must speak before the next remark.
+    def _every(self) -> int:
+        """How many public speech beats must land before the next remark (default 4).
 
-        A handler constant with a ``MAL_COMMENTATOR_EVERY`` env override — the manifest
-        is ``extra='forbid'`` so this cannot be a YAML field yet (a typed CommentaryConfig
-        sub-schema is the clean follow-up). Floored at 1 so a bad value can't wedge it."""
+        A simple count, not a per-speaker quorum: a stalled or errored speaker can never
+        wedge the cadence (the old quorum required *every* speaker who ever spoke to keep
+        speaking, so one silent agent blocked commentary forever — and starved the media
+        beat with it). A handler constant with a ``MAL_COMMENTATOR_EVERY`` env override —
+        the manifest is ``extra='forbid'`` so this cannot be a YAML field yet (a typed
+        CommentaryConfig sub-schema is the clean follow-up). Floored at 1 so a bad value
+        can't wedge it."""
         try:
-            return max(1, int(os.getenv("MAL_COMMENTATOR_EVERY", str(_DEFAULT_PER_AGENT))))
+            return max(1, int(os.getenv("MAL_COMMENTATOR_EVERY", str(_DEFAULT_EVERY))))
         except ValueError:
-            return _DEFAULT_PER_AGENT
+            return _DEFAULT_EVERY
 
     def _window_since_last(self, events: tuple[Event, ...]) -> tuple[Event, ...]:
-        """Events after this agent's most recent remark — its quorum resets each beat."""
+        """Events after this agent's most recent remark — its counter resets each beat."""
         last = -1
         for i, event in enumerate(events):
             if event.kind == _COMMENTARY_KIND and event.actor == self.name:
                 last = i
         return events[last + 1 :]
 
-    def _active_speakers(self, events: tuple[Event, ...]) -> set[str]:
-        """Cast members (never self) who have spoken at least once this run.
-
-        Judges — whose verdicts are not speech kinds — and the commentator itself fall
-        out naturally, so the quorum tracks only the talking cast."""
+    def _beats_since_last(self, events: tuple[Event, ...]) -> int:
+        """Count cast speech beats (never self) since this critic's last remark."""
         cast = set(self.cast_names)
-        return {e.actor for e in events if e.kind in _SPEECH_KINDS and e.actor in cast and e.actor != self.name}
-
-    def _quorum_met(self, events: tuple[Event, ...]) -> bool:
-        """True once every active speaker has spoken ``_per_agent`` times since the last beat."""
-        speakers = self._active_speakers(events)
-        if not speakers:
-            return False
-        need = self._per_agent()
-        counts = dict.fromkeys(speakers, 0)
-        for event in self._window_since_last(events):
-            if event.kind in _SPEECH_KINDS and event.actor in counts:
-                counts[event.actor] += 1
-        return all(counts[name] >= need for name in speakers)
+        return sum(
+            1
+            for e in self._window_since_last(events)
+            if e.kind in _SPEECH_KINDS and e.actor in cast and e.actor != self.name
+        )
+
+    def _ready(self, events: tuple[Event, ...]) -> bool:
+        """True once enough fresh speech has landed since the last beat to chime in."""
+        return self._beats_since_last(events) >= self._every()
 
     # ── prompt steering ─────────────────────────────────────────────────────────
 
@@ -104,8 +103,8 @@ class Commentator(ManifestAgent):
         projection: StageProjection,
         recent_events: tuple[Event, ...],
     ) -> Event | None:
-        # Hold until each active speaker has spoken enough since the last remark.
-        if not self._quorum_met(recent_events):
+        # Hold until enough fresh speech beats have landed since the last remark.
+        if not self._ready(recent_events):
             return None
         # The generic turn writes the funny line (offline → the curated stub keyed on
         # this agent's name); kind is constrained to ``commentary.posted`` by may_emit.

tests/test_commentator.py

@@ -37,19 +37,20 @@ def _critic(cast_names: list[str]):
 
 
 class TestCadence:
-    def test_abstains_below_quorum(self, monkeypatch):
-        monkeypatch.setenv("MAL_COMMENTATOR_EVERY", "2")
+    def test_abstains_below_count(self, monkeypatch):
+        monkeypatch.setenv("MAL_COMMENTATOR_EVERY", "4")
         critic = _critic(["scene-whisperer", "pocket-actor", "rafters-critic"])
-        # One message from each speaker → the quorum (2 apiece) is not met yet.
+        # Only 2 speech beats so far → the cadence (4) is not met yet.
         events = (
             _ev("world.observed", "scene-whisperer", text="the wood hums"),
             _ev("agent.spoke", "pocket-actor", text="I want the moon"),
         )
         assert critic.act("r", 1, _projection(), events) is None
 
-    def test_emits_one_beat_at_quorum(self, monkeypatch):
-        monkeypatch.setenv("MAL_COMMENTATOR_EVERY", "2")
+    def test_emits_one_beat_at_count(self, monkeypatch):
+        monkeypatch.setenv("MAL_COMMENTATOR_EVERY", "4")
         critic = _critic(["scene-whisperer", "pocket-actor", "rafters-critic"])
+        # 4 speech beats since the last remark → chime in exactly once.
         events = (
             _ev("world.observed", "scene-whisperer", text="a"),
             _ev("agent.spoke", "pocket-actor", text="b"),
@@ -61,7 +62,22 @@ class TestCadence:
         assert event.kind == "commentary.posted"
         assert event.payload.get("text")
 
-    def test_no_active_speakers_means_silence(self, monkeypatch):
+    def test_one_silent_speaker_does_not_wedge_cadence(self, monkeypatch):
+        """A stalled speaker can't block the beat — the old per-speaker quorum bug."""
+        monkeypatch.setenv("MAL_COMMENTATOR_EVERY", "4")
+        critic = _critic(["scene-whisperer", "pocket-actor", "rafters-critic"])
+        # pocket-actor spoke once then went silent (errored out); scene-whisperer carries
+        # the show. A count-based cadence still fires; a per-speaker quorum never would.
+        events = (
+            _ev("agent.spoke", "pocket-actor", text="I want the moon"),
+            _ev("world.observed", "scene-whisperer", text="a"),
+            _ev("world.observed", "scene-whisperer", text="b"),
+            _ev("world.observed", "scene-whisperer", text="c"),
+        )
+        event = critic.act("r", 5, _projection(), events)
+        assert event is not None and event.kind == "commentary.posted"
+
+    def test_no_speakers_means_silence(self, monkeypatch):
         monkeypatch.setenv("MAL_COMMENTATOR_EVERY", "1")
         critic = _critic(["scene-whisperer", "pocket-actor", "rafters-critic"])
         # Only the critic's own / non-speech events exist → nobody to comment on.
@@ -69,8 +85,8 @@ class TestCadence:
         assert critic.act("r", 1, _projection(), events) is None
 
     def test_window_resets_after_a_remark(self, monkeypatch):
-        """The self-trigger guard: a posted beat resets the quorum window."""
-        monkeypatch.setenv("MAL_COMMENTATOR_EVERY", "2")
+        """The self-trigger guard: a posted beat resets the cadence window."""
+        monkeypatch.setenv("MAL_COMMENTATOR_EVERY", "4")
         critic = _critic(["scene-whisperer", "pocket-actor", "rafters-critic"])
         events = (
             _ev("world.observed", "scene-whisperer", text="a"),
@@ -101,7 +117,7 @@ class TestModularity:
         scenario = reg.build_scenario("thousand-token-wood", tools=default_tool_registry())
         conductor = Conductor(scenario, governor=reg.governor_for("thousand-token-wood"), ledger=Ledger())
         conductor.reset("a village of stage props wakes up")
-        conductor.step(8)  # default quorum (3) trips by ~turn 3
+        conductor.step(8)  # default cadence (4 beats, ~2 turns) trips early in the run
         kinds = [e.kind for e in conductor.ledger.events_for_run(conductor.run_id)]
         assert "commentary.posted" in kinds