@@ -171,8 +171,8 @@ _Avoid_: "callback" or "middleware" — neither captures the phase-specific, cha
 What a bundled agent judges, written as verbs rather than as phases: `intake`, `select_tools`,
 `advise`, `system_addendum`, `review`, `salvage`, `judge`, `outbound`, `archive`. Each is asked
 about one step of a Turn, answered against a read-only `StepView` whose `phase` says which of
-the six moments is asking, and answered in plain data -- a string, a list of names, a mapping
-built by `Intake`, `Accept`, `Resample` or `End` -- never a write into the loop's own state and
+the six moments is asking, and answered in plain data -- a string, a narrower list of tool
+definitions, a mapping built by `Intake`, `Accept`, `Resample` or `End` -- never a write into the loop's own state and
 never an instance of a host class, so a judgement compiled from a dispatch's own source can
 answer the same verbs a plugin does. Three invariants hold for every participant whatever its
 origin: it is shown facts it cannot write, it answers with data the host interprets, and an
 
@@ -606,6 +606,19 @@ type = "forbidden"
 # provider registry and pricing table reads) moved out to raven/observability
 # and RAVEN_HOME resolution moved in to raven/home.py, so an ignore_imports
 # entry here would be new debt, not a carry-over.
+#
+# One type-only edge exists and is deliberate, so it is written here rather
+# than left for a reader to discover: contracts/harness.py names
+# raven.agent.harness.participants under TYPE_CHECKING, for the Verdict and
+# Intake the asking half of the role protocol returns. Those are the shapes the
+# shell reads a participant's answer into, and commit-by-commit they were moved
+# off the paper on purpose -- a participant answers with a plain mapping, and a
+# host class on the paper is exactly what a generated judgement cannot build.
+# The price is that the papers name a symbol a papers-only wheel would not
+# contain. It costs nothing at import time, which is what this contract is
+# about, and lint-imports does not see it because exclude_type_checking_imports
+# is on below. If the papers are ever built as their own wheel with type stubs,
+# this is the one edge to resolve.
 source_modules = ["raven.contracts", "raven.home", "raven.spine", "raven.tracing"]
 forbidden_modules = [
     "raven.acp", "raven.acp_client", "raven.agent", "raven.auth", "raven.browser",
 
@@ -45,7 +45,9 @@ def ask_judge(
 
         The dispatch's own judgements are one participant among them, asked
         after whatever the caller passes, so a product's own rules speak first
-        and their wording is what the model reads.
+        and their wording is what the model reads. There is one caller,
+        ``ToolRegistry._verifier_refusals``, and it passes nothing: the order
+        is real and tested, but nothing arrives in ``participants`` today.
 
         Imported in the call, not for style: ``raven.agent.subagent`` pulls its
         manager and every backend on package import, so naming the charter at
 
@@ -172,6 +172,14 @@ def compose_judge(
     """
     for participant in participants:
         refusals = participant.judge(name, params, prior)
+        # A bare ``str`` satisfies ``Sequence[str]`` structurally, so neither
+        # the annotation nor a type checker objects -- and iterating it turns
+        # one sentence into one refusal per character, which is the opposite of
+        # the invariant this module opens with. ``charter_code.run_judge``
+        # coerced it where the composition used to live; moving the
+        # composition out a layer has to bring the handling with it.
+        if isinstance(refusals, str):
+            refusals = [refusals] if refusals.strip() else []
         said = [line for line in refusals if isinstance(line, str) and line] if refusals else []
         if said:
             return said
 
@@ -46,6 +46,12 @@
 from typing import TYPE_CHECKING, Any, Protocol, runtime_checkable
 
 if TYPE_CHECKING:
+    # The one name a paper takes from outside the kernel, and type-only: the
+    # shapes the shell reads a participant's answer into live in the harness
+    # because a participant answers with a plain mapping and a host class on a
+    # paper is what a generated judgement cannot build. Import-time closure is
+    # unaffected, which is what "the kernel stands alone" is about; the edge is
+    # written down beside that contract in pyproject.toml.
     from raven.agent.harness.participants import Intake, Verdict
     from raven.contracts.assembled import AssembledContext, TokenBudget
     from raven.contracts.context import TurnContext
@@ -350,6 +356,14 @@ def ask_judge(
         than something this role reads for itself, which is what lets a judgement
         generated for one dispatch join the same list.
 
+        They are also, today, the only participant in it. The party that asks
+        this verb is ``ToolRegistry.execute``, which is not the hook chain: a
+        turn's participants live in its hook context and a registry holds no
+        handle on them, so ``participants`` arrives empty on every production
+        call and the composition above describes an order nothing yet fills.
+        A plugin refuses a call from ``review`` instead. Stated here because a
+        reader of this protocol has no reason to open the participant paper.
+
         Sentences, not exceptions: a refusal reaches the model as the call's
         own result, so its next attempt can be right. Synchronous and cheap by
         contract -- this runs before every dispatch and ahead of the permission
 
@@ -140,11 +140,14 @@
 first bump gave.
 
 3,200 -> 3,410 (2026-09-18), and this is that review. The change is a whole
-paper: contracts/participant.py, 191 lines, the nine verbs a sub-agent
-implements instead of the six hook phases (``AgentParticipant``, its ``StepView``
+paper: contracts/agent_conduct.py, 191 lines, the nine verbs a sub-agent
+implements instead of the six hook phases (``AgentConduct``, its ``StepView``
 of fourteen read-only fields, the ``Intake`` and ``Verdict`` it answers with,
-the per-turn ``ParticipantFactory``, and a diagnostic trail so a gate's one-line
-findings still reach the loop's notes). It sits beside ``loop_hooks`` rather
+the per-turn ``ConductFactory``, and a diagnostic trail so a gate's one-line
+findings still reach the loop's notes). Left in the names and the count it was
+written with: an entry here is a dated record of one bump, not a description of
+the file today, and the paper has since been renamed to contracts/participant.py
+and grown past 191 lines -- both under their own entries below. It sits beside ``loop_hooks`` rather
 than replacing it: the phases remain the loop's timing contract, this is the
 judgement contract, and an adapter seats one in the other. Surveyed before it
 was written -- 42 real hook implementations across five plugins read fourteen
@@ -221,6 +224,21 @@
 
 Measured at 3,528.
 
+
+And once more, 3,550 -> 3,570 (2026-09-18), for review. Prose again, and again
+about what the papers do not do. The ``judge`` disclosure had landed in two of
+its four homes; ``ActionModule.ask_judge`` on this paper was a third, and it is
+the one a reader of the role protocol meets first, phrased without naming
+anything the earlier fix touched -- which is why grepping the claim rather than
+the symbol is what found it. The other addition is the type-only edge from this
+paper to ``raven.agent.harness.participants``: the first the kernel has, taken
+knowingly when ``Verdict`` and ``Intake`` moved off the paper so a generated
+judgement could build what a participant answers with. It costs nothing at
+import time and lint-imports does not see it, so it is written down here and
+beside the contract it bends rather than left for the next reader to find.
+
+Measured at 3,542.
+
 """
 
 from __future__ import annotations
@@ -231,7 +249,7 @@
 from pathlib import Path
 
 LINE_CEILING = 2_000
-CONTRACTS_LINE_CEILING = 3_550
+CONTRACTS_LINE_CEILING = 3_570
 THIRD_PARTY_ALLOWED = frozenset({"loguru"})
 DEBT_MARKER = re.compile(r"\b(TODO|FIXME|HACK)\b")
 
 
@@ -315,30 +315,34 @@ async def archive(self, step, reply):
     ], f"a phase is mislabelled: {seen}"
 
 
-def test_a_seated_participant_is_not_asked_to_judge_a_tool_call():
-    """``judge`` has a role but no seat, and the contract says so. The party
-    that asks it is the tool registry, which is not the hook chain and holds no
-    handle on this turn's participants -- so today only a dispatch's own rules
-    answer it. Pinned rather than left implicit: whoever wires the seat through
-    should have to come here and say the prose has changed."""
+def test_the_registry_asks_judge_with_no_participants_at_all():
+    """``judge`` has a role but no seat, and three docstrings now say so. What
+    makes those sentences true is this: the one party that asks the verb is the
+    tool registry, and it passes nothing, so the list the role composes holds
+    only the dispatch's own rules.
+
+    Asserted on the argument rather than on the refusal that comes back. A test
+    that only checked "the Charter still refuses" would stay green after someone
+    plumbed the seat's participants through -- which is the change these
+    docstrings would silently outlive. Here that change makes ``handed``
+    non-empty and turns this red, which is the point."""
     from raven.agent.harness import DefaultAction
     from raven.agent.subagent.charter import Charter, CheckRule, charter_scope
     from raven.agent.tools.registry import ToolRegistry
 
-    asked: list[str] = []
+    handed: list[tuple] = []
 
-    class ProductRules(AgentParticipant):
-        def judge(self, name, params, prior):
-            asked.append(name)
-            return ["the product refuses this one"]
+    class Spy(DefaultAction):
+        def ask_judge(self, name, params, prior, participants=()):
+            handed.append(tuple(participants))
+            return super().ask_judge(name, params, prior, participants)
 
-    ParticipantHook("product", ProductRules)  # seated is not enough; nothing carries it across
-    registry = ToolRegistry(verifier_provider=lambda: DefaultAction())
+    registry = ToolRegistry(verifier_provider=Spy)
     with charter_scope(Charter(checks=(CheckRule(tool="write_file", path_prefix="out/"),))):
         refusals = registry._verifier_refusals("write_file", {"path": "/etc/passwd"})
 
+    assert handed == [()], f"the registry handed the role participants: {handed}"
     assert refusals, "the dispatch's own rules must still be asked"
-    assert asked == [], "a seated participant is not on the registry's list -- see AgentParticipant.judge"
 
 
 @pytest.mark.asyncio
 
@@ -448,6 +448,29 @@ def judge(self, name, params, prior):
         ]
 
 
+def test_one_sentence_of_refusal_stays_one_sentence() -> None:
+    """A bare ``str`` satisfies ``Sequence[str]`` structurally, so a participant
+    that refuses with one sentence passes every annotation and every type check
+    -- and iterating it yields one refusal per character. Eighteen refusals for
+    a malformed answer is the opposite of "a malformed answer is silence", and
+    this seam exists to carry judgements that are generated rather than written,
+    where a bare string is a plausible thing to answer."""
+    from raven.agent.harness.participants import compose_judge
+
+    class Sentence:
+        def judge(self, name, params, prior):
+            return "write under ./out/"
+
+    class Blank:
+        def judge(self, name, params, prior):
+            return "   "
+
+    assert compose_judge("write_file", {}, [], [Sentence()]) == ["write under ./out/"]
+    assert compose_judge("write_file", {}, [], [Blank(), Sentence()]) == ["write under ./out/"], (
+        "whitespace is not a refusal, and must not stop the next participant"
+    )
+
+
 def test_a_participant_that_says_nothing_lets_the_next_one_speak() -> None:
     """A veto stops at the first refusal, not at the first participant."""
     from raven.agent.harness.action import DefaultAction