mirror of
https://github.com/saymrwulf/crisis.git
synced 2026-05-14 20:37:54 +00:00
saymrwulf
0976239ebd
The previous driver imposed a synchronous turn-counted clock that the
Crisis paper explicitly forbids — Crisis is supposed to work in
asynchronous P2P networks, with any synchronicity being virtual and
derived inside the consensus algorithm from the DAG structure, not
imposed externally by a coordinator. This commit removes the wall clock.
What changed in the engine:
- `Mothership.run_crisis_phase(num_turns, gossip_rounds_per_turn)`
is replaced by `run_until_quiescent(max_steps=200)`. The loop
interleaves three concerns on each iteration — emissions, gossip,
and alarm emissions — until none make progress. Termination is by
quiescence, not by a fixed turn count. `max_steps` is a safety
bound (loop-iteration cap), not an exposed clock.
- `Mothership.run_closed_phase(num_turns)` becomes
`run_closed_phase(max_steps=50)`. Same quiescence model — the
closed-phase conversation runs until no agent has more to say.
- Agents grew `pending_alarm_claims()`: each agent checks its own
graph for un-alarmed mutations and produces AlarmClaims directly.
The driver loop calls this every iteration, so alarms emit and
propagate in the same loop as regular emissions and gossip — no
separate "alarm phase."
- `Mothership.emit_alarms_from_detectors()` and the explicit
`run_gossip_round()` step are no longer needed by callers; both
are subsumed by the async loop. `run_gossip_round()` stays as a
helper but tests no longer call it externally.
What changed in the agent interface:
- `CrisisAgent.next_turn(turn, received_claims)` becomes
`try_emit()` — no arguments. Agents in an async network don't see
a global tick. They decide based on their own internal state.
- `CrisisAgent.observe(claim)` is the new optional callback the
closed-phase loop uses to feed context into agents that care
(overridden by LiveClaudeAgent to populate its prompt buffer).
- `pending_alarm_claims()` is idempotent: an internal
`_already_alarmed` set tracks claims this agent has emitted, so
the loop calls it every step without flooding the network with
duplicate alarms.
What changed in the dataclass schema:
- `AlarmClaim.detected_at_turn` -> `emitted_at_step`. The word
"turn" implies a global clock; "step" is a per-agent sequence
number used only for log ordering — local, not networked.
- `ClosedPhaseEntry.turn` and `CrisisPhaseEntry.turn` -> `step`.
Same rename, same reasoning.
- `Scenario.closed_phase_turns` and `Scenario.crisis_phase_turns`
are gone. The scenario no longer prescribes how many turns; it
just provides agents and lets the async loop run them out.
What changed in the CLI:
- Phase 3 reports "drove to quiescence in N step(s)" with a
breakdown of regular emissions / gossip transfers / alarm
emissions, instead of "ran N turns".
- `QuiescenceReport` (new dataclass) carries the run statistics
back from `run_until_quiescent`/`run_closed_phase` — steps taken,
emissions made, gossip transfers, alarm claims emitted, plus
whether termination was via quiescence or max-step cap.
New regression tests (`test_async_quiescence.py`):
- `test_run_until_quiescent_terminates`: the loop must exit.
- `test_two_runs_produce_identical_final_state`: determinism check —
if anything in the loop depended on real wall time, this would
fail.
- `test_max_steps_bound_caps_runtime`: setting max_steps=1 exits
immediately and `QuiescenceReport.reached_quiescence` reflects
reality.
- `test_no_turn_argument_exposed_to_agents`: introspects
`CrisisAgent.try_emit` signature; fails if anyone re-adds a
`turn` parameter.
- `test_no_turn_field_on_alarmclaim`: introspects the dataclass
fields; fails if `detected_at_turn` reappears.
- `test_alarms_propagate_through_async_loop_alone`: the loop alone
(no manual emit_alarms / run_gossip_round) ratifies an alarm.
- `test_quiescence_report_counts_match_logs`: sanity check that
the report's emission count equals the crisis log length.
Suite: 163 -> 170 tests, all green in 0.79s.
Behavioral end-state is identical to the previous (synchronous)
version: same fact-check scenario, same byzantine equivocation, same
proof JSON shape, same three signers, same quorum-met outcome. The
difference is structural: the protocol now matches the paper's async
shape, and a future port to actual TCP gossip + concurrent agents
needs no change to this engine.
CrisisViz: still untouched. The `crisis_data.json` pipeline that
drives the visualizer is orthogonal.
Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
114 lines
4.5 KiB
Python
114 lines
4.5 KiB
Python
"""Async-quiescence properties — the new tests that protect the no-clock invariant.
|
|
|
|
If you accidentally bake a synchronous tick back into the driver, one of these
|
|
tests should fail.
|
|
"""
|
|
|
|
from crisis_agents.agent import MockAgent, MockByzantineAgent
|
|
from crisis_agents.claim import Claim
|
|
from crisis_agents.mothership import Mothership
|
|
from crisis_agents.vote import quorum_for
|
|
|
|
|
|
def _claim(sid: str, verdict: str = "true", evidence: str = "ok") -> Claim:
|
|
return Claim(statement_id=sid, verdict=verdict, confidence=0.9, # type: ignore[arg-type]
|
|
evidence=evidence, timestamp_logical=0)
|
|
|
|
|
|
def _intro(name: str = "delta") -> Claim:
|
|
return Claim(statement_id=f"intro:{name}", verdict="unknown", confidence=1.0,
|
|
evidence=f"{name} joining the team", timestamp_logical=0)
|
|
|
|
|
|
def _build_fresh_team() -> Mothership:
|
|
m = Mothership()
|
|
m.add_agent(MockAgent("a", [[]]))
|
|
m.add_agent(MockAgent("b", [[]]))
|
|
m.add_agent(MockAgent("c", [[]]))
|
|
byz = MockByzantineAgent(
|
|
"d", _intro(),
|
|
scripted_pairs=[(
|
|
_claim("s03", verdict="true", evidence="to_ac"),
|
|
_claim("s03", verdict="false", evidence="to_b"),
|
|
)],
|
|
split_a={"a", "c"},
|
|
split_b={"b"},
|
|
)
|
|
m.open_boundary(byz)
|
|
return m
|
|
|
|
|
|
class TestAsyncQuiescence:
|
|
|
|
def test_run_until_quiescent_terminates(self):
|
|
"""The loop must terminate. If it doesn't, there's a logic bug
|
|
in the quiescence detection."""
|
|
m = _build_fresh_team()
|
|
report = m.run_until_quiescent(max_steps=200)
|
|
assert report.reached_quiescence
|
|
assert report.steps < 200
|
|
|
|
def test_two_runs_produce_identical_final_state(self):
|
|
"""Running the same scenario twice must produce the same ratified-set,
|
|
confirming there's no hidden non-deterministic ordering in the loop.
|
|
"""
|
|
m1 = _build_fresh_team()
|
|
m1.run_until_quiescent()
|
|
|
|
m2 = _build_fresh_team()
|
|
m2.run_until_quiescent()
|
|
|
|
for name in ("a", "b", "c"):
|
|
assert m1.ratified_alarms_from(name) == m2.ratified_alarms_from(name)
|
|
|
|
def test_max_steps_bound_caps_runtime(self):
|
|
"""If we set max_steps to 1, the loop must exit even though
|
|
quiescence wasn't reached. The QuiescenceReport must accurately
|
|
say so."""
|
|
m = _build_fresh_team()
|
|
report = m.run_until_quiescent(max_steps=1)
|
|
# With one step we won't have propagated alarms through gossip
|
|
assert report.steps == 1
|
|
# reached_quiescence might be False because we capped out
|
|
# (the byzantine has more emissions pending)
|
|
# The important property: the loop exited and reported honestly.
|
|
assert isinstance(report.reached_quiescence, bool)
|
|
|
|
def test_no_turn_argument_exposed_to_agents(self):
|
|
"""Regression guard: CrisisAgent.try_emit() takes no arguments.
|
|
If anyone re-adds a `turn` parameter, this fails at the type-check
|
|
level when MockAgent.try_emit is called."""
|
|
import inspect
|
|
from crisis_agents.agent import CrisisAgent
|
|
sig = inspect.signature(CrisisAgent.try_emit)
|
|
# self plus no other parameters
|
|
params = list(sig.parameters)
|
|
assert params == ["self"], f"try_emit grew arguments: {params}"
|
|
|
|
def test_no_turn_field_on_alarmclaim(self):
|
|
"""Regression guard: AlarmClaim no longer has a `detected_at_turn`
|
|
field. It has `emitted_at_step` — a sequence number, not a clock tick."""
|
|
from crisis_agents.vote import AlarmClaim
|
|
fields = AlarmClaim.__dataclass_fields__
|
|
assert "detected_at_turn" not in fields
|
|
assert "emitted_at_step" in fields
|
|
|
|
def test_alarms_propagate_through_async_loop_alone(self):
|
|
"""The async loop should detect, emit alarms, and ratify — all without
|
|
the caller having to invoke separate emit_alarms_from_detectors() or
|
|
run_gossip_round() steps.
|
|
"""
|
|
m = _build_fresh_team()
|
|
m.run_until_quiescent()
|
|
threshold = quorum_for(m.boundary.size())
|
|
for name in ("a", "b", "c"):
|
|
ratified = m.ratified_alarms_from(name)
|
|
assert len(ratified) == 1
|
|
r = ratified[0]
|
|
assert r.signer_count >= threshold
|
|
|
|
def test_quiescence_report_counts_match_logs(self):
|
|
"""Sanity: the report's emission count must equal the crisis log length."""
|
|
m = _build_fresh_team()
|
|
report = m.run_until_quiescent()
|
|
assert report.emissions == len(m.run_result.crisis_log)
|