M5: survivorship, the market taxonomy, and a review that kills

The company now overturns its own confirmed result, and nobody intervenes.

    HYP-0001  CONFIRMED -> REFUTED
      claimed           max_drawdown < 0.20, measured 0.1236
      objection         SURVIVORSHIP, critical
      re-run universe   3 names -> 6 names
      restored          LUNC/USDT, FTT/USDT, HOTAIR/USDT
      max_drawdown      0.1236 -> 0.6451
      verdict           UPHELD

A researcher registers a drawdown claim over the instruments still trading and
it is confirmed. A Critic names SURVIVORSHIP. The Chair dispatches the test.
The point-in-time re-run restores three delisted names, drawdown goes from 12%
to 65%, and the claim dies by measurement rather than by argument.

The critic does not write the test
----------------------------------

It names a defect; `meetings/taxonomy.py` generates the varied specification
from the one under review. That distinction is the point. A critic that
composes its own test can write one that cannot fail, or that tests something
else, or that quietly uses a capability it does not hold. Naming a defect gets
a test whose construction is written down, reviewed, and identical every time
the same defect is alleged. The prose is the critic's; the arithmetic is not.

Each builder varies exactly one thing -- asserted by a test -- because a test
that changed the universe AND the cost model would settle nothing. Which way
"worse" points depends on the metric: drawdown getting bigger is bad, return
getting bigger is not, and getting that backwards would make every objection
unfalsifiable in one direction and automatic in the other.

Survivorship had to be made measurable, not merely discussable
--------------------------------------------------------------

The fixture universe gained three instruments that die. The first version had
them drifting quietly down -- and survivorship became undetectable, because no
ranking rule would ever hold one. That was wrong about how the failure
actually happens: LUNA and FTT both looked like the best names right up until
they were worth nothing. The casualties now PUMP before they collapse, which
is what draws a rotation rule into them, and a universe that quietly drops
them reports the attraction without ever paying for it.

`point_in_time` is now a first-class engine operation rather than a footnote
in a data pipeline, which is the only reason a Critic can see the defect and a
test can vary it.

The engine went cross-sectional
-------------------------------

`rotation` ranks the whole universe each bar and holds the leaders. Multi-asset
simulation, still one-bar latency applied in a single place rather than trusted
to each signal.

Path metrics gained a block bootstrap interval. Without one they cannot support
a confirmatory claim at all -- the verdict rule reports UNDERPOWERED, correctly,
and every drawdown claim becomes unanswerable. Blocks rather than individual
returns because shuffling one at a time destroys the runs of losses that ARE
the drawdown.

That interval is honestly wide: roughly 20 percentage points around a 200-bar
maximum drawdown. So the demonstration declares a minimum effect of 0.11 rather
than 0.05. A claim pretending to resolve five points would be UNDERPOWERED and
the rule would be right to say so -- declaring what the data can support,
before looking at it, is the discipline rather than a concession to it.

On the numbers
--------------

martex-quant found this defect on real crypto history, where it took a Sharpe
of 1.47 to 0.86. Those figures belong to that corpus and are NOT reproduced
here; Aurelis has no market data of its own yet. What is reproduced is the
mechanism, on fixture instruments where the bias is present by construction.
The figures above are whatever the engine computed. Nothing was tuned until a
number came out right.

Honest finding: leakguard, purged-cv, calibrate and timeleak are not
resolvable from PyPI, the same as martex-quant. The integrity checks M5 needs
are implemented natively (`integrity.point_in_time`), and doctor reports what
is actually present.

376 tests, ruff clean, mypy strict.

Also fixed: two earlier README edits used .replace() without asserting and had
silently done nothing, so the front page still described M2. Every doc edit in
this commit asserts its anchor first.

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

Author: martex-dev

README.md

@@ -11,9 +11,9 @@ themselves as the evidence justifies it.
 [![Python 3.12+](https://img.shields.io/badge/python-3.12%2B-blue)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/license-MIT-green)](LICENSE)
 
-Status: **M4 complete — research runs, and can conclude it found nothing.**
-Preregistration locked by database trigger, verdicts derived by rule, every
-number traceable to an artifact. · 2026-09-05
+Status: **M5 complete — the company overturns its own confirmed result.**
+A Critic names survivorship, the Chair runs the test, the claim dies. No human
+in the loop. · 2026-09-05
 
 > Research software. No live trading adapter exists. Nothing here is proven
 > profitable. Read [DISCLAIMER.md](DISCLAIMER.md).
@@ -24,37 +24,69 @@ number traceable to an artifact. · 2026-09-05
 
 ```bash
 pip install -e ".[dev]"
-aurelis db init          # schema, invariants, the org chart
-aurelis agent hire       # staff the launch roster
-aurelis mission run      # open a mission and work it to completion
-aurelis doctor
+aurelis db init            # schema, invariants, the org chart
+aurelis agent hire         # staff the launch roster
+aurelis research review    # the demonstration
 ```
 
-`mission run` opens a mission with a **Kickoff meeting**, plans a project into
-three dependent tasks, runs them, and closes with a **Retrospective** that
-scores the kickoff's forecasts against what actually happened.
-
-Between the meetings: **INTEL** briefs the crypto desk from measured bars.
-**QUANT** reads that briefing, checks it against an independent window it
-measured itself, and raises a research question. **LEAD-R** decides whether the
-question earns a project. Each waits for the one before because the queue will
-not hand out a task whose dependency has not succeeded — there is no
-orchestrator.
+### The demonstration
 
 ```
- mission         MSN-0001
- kickoff         MTG-0001 — 5 turns, 0 exchange round(s)
- turns           3
- progress        3/3 succeeded
- retrospective   MTG-0006 — 5 turns
- calibration     AG-0004: Brier 0.2500 over 1 forecast — no better than 50/50
- chain           chain verified: 141 events, seq 1..141
+HYP-0001  CONFIRMED -> REFUTED
+
+ claimed           max_drawdown < 0.20, measured 0.12364208
+ universe          3 names (still trading)
+ objection         OBJ-0001 SURVIVORSHIP, critical
+ test              the same rule, universe restored to point-in-time
+ re-run universe   6 names
+ restored          LUNC/USDT, FTT/USDT, HOTAIR/USDT
+ max_drawdown      0.12364208 -> 0.64507263
+ verdict           UPHELD
+ chain             chain verified: 68 events, seq 1..68
 ```
 
-Look around: `aurelis org show` · `aurelis org desks` · `aurelis agent list` ·
-`aurelis agent show INTEL` (what one agent holds, sees, writes and may invoke)
-· `aurelis mission show MSN-0001` (every task, its status, what it waits on) ·
-`aurelis tick` (advance the working day one turn).
+A researcher registers a drawdown claim over the instruments still trading,
+runs it, and it is **confirmed**. A Critic names `SURVIVORSHIP` — it does not
+write the test; the taxonomy generates it from the specification under review.
+The Chair dispatches it. The point-in-time re-run restores three delisted names
+and drawdown goes from 12% to 65%. The objection is upheld and the claim is
+**refuted by a measurement**.
+
+Nobody intervenes at any point.
+
+*martex-quant found this same defect on real crypto history, where it took a
+Sharpe of 1.47 to 0.86. Those figures belong to that corpus; the ones above are
+what this engine measured on fixture instruments where the bias is present by
+construction.*
+
+### The rest of the company
+
+`aurelis mission run` opens a mission with a **Kickoff meeting**, plans a
+project into three dependency-sequenced tasks, runs them, and closes with a
+**Retrospective** that scores the kickoff's forecasts against what happened.
+**INTEL** briefs the desk, **QUANT** checks that briefing against a window it
+measured itself, **LEAD-R** decides. There is no orchestrator — a task whose
+dependency has not succeeded is simply invisible to the queue.
+
+`aurelis research run` takes a single hypothesis from claim to verdict:
+propose, screen for prior art, **lock a preregistration**, design, run, and
+derive the verdict from criteria fixed before anything executed. On 240 bars it
+returns `UNDERPOWERED`, because 240 bars genuinely cannot detect a Sharpe of
+0.05 — and saying so is the point.
+
+Look around:
+
+| | |
+|---|---|
+| `aurelis org show` · `org desks` · `org charters` | the company as designed |
+| `aurelis agent list` · `agent show INTEL` | what one agent holds, sees, writes, may invoke |
+| `aurelis mission show MSN-0001` | every task, its status, what it waits on |
+| `aurelis meeting show MTG-0001` | the transcript, who changed their mind, who dissented |
+| `aurelis meeting calibration` | how good the company's forecasts have been |
+| `aurelis research show HYP-0001` | every metric, its interval, and who computed it |
+| `aurelis research graveyard` | everything killed, and why |
+| `aurelis research defects` | every market defect and how it is settled |
+| `aurelis tick` · `aurelis doctor` | advance the working day; check the workspace |
 
 ---
 
@@ -252,7 +284,7 @@ automatically by the company, five milestones in.
 | **M2** ✅ | Missions | missions → projects → tasks, dependencies, the working day |
 | **M3** ✅ | **Meetings** | seven-phase protocol, forecasts, objections with tests, dissent |
 | **M4** ✅ | Research lifecycle | engines, preregistration, experiments, verdicts |
-| **M5** | Critique & audit | objections with tests, the H71 reproduction |
+| **M5** ✅ | Critique & audit | market defects, point-in-time, the review that kills |
 | **M6** | Memory & knowledge | graph, lessons, corpus import, vault export |
 | **M7** | **Mission Control** | the live facility |
 | **M8** | Strategy, portfolio, risk | versions, gates, veto |

docs/07-roadmap.md

@@ -94,7 +94,7 @@ identical artifact hash. No agent can write a `Result` row.
 
 ---
 
-## M5 — Critique, replication, and the Research Review
+## M5 — Critique, replication, and the Research Review ✅
 
 - Strategy Lab roles: Critic, Adversarial, Replication, Robustness, Validation.
 - Market objection taxonomy with mechanical discriminating tests:

src/aurelis/agents/tools.py

@@ -254,3 +254,84 @@ def _engine_features(arguments: dict[str, Any]) -> ToolResult:
         raise ValueError("features requires a non-empty 'bars' list from data.ohlcv")
     measures = describe_bars(bars)
     return ToolResult(value=measures, detail=f"{len(measures)} measures over {len(bars)} bars")
+
+@register_tool(
+    ToolScope.ENGINE_BACKTEST,
+    "Run an experiment specification and return its metrics as scalars",
+)
+def _engine_backtest(arguments: dict[str, Any]) -> ToolResult:
+    """Run a specification through the engine registry.
+
+    This is what makes a discriminating test executable. A Critic alleging
+    survivorship supplies the same rule over a point-in-time universe, the
+    Chair dispatches it here, and the room sees the number rather than the
+    argument.
+
+    Metrics come back flat -- ``{"sharpe": "0.12", ...}`` -- so a test can name
+    a field and compare it without the objection needing to know the artifact
+    format.
+    """
+    from aurelis.engines.registry import engine_for
+    from aurelis.engines.spec import ExperimentSpec
+    from aurelis.research.lifecycle import _spec_from_payload
+
+    payload = arguments.get("spec")
+    if not isinstance(payload, dict):
+        raise ValueError("engine.backtest requires a 'spec' payload")
+
+    spec: ExperimentSpec = _spec_from_payload(payload)
+    artifact = engine_for(spec).run(spec)
+
+    flat: dict[str, Any] = {m.name: str(m.value) for m in artifact.metrics.metrics}
+    for metric in artifact.metrics.metrics:
+        if metric.low is not None:
+            flat[f"{metric.name}_low"] = str(metric.low)
+            flat[f"{metric.name}_high"] = str(metric.high)
+    flat["spec_digest"] = artifact.spec_digest
+    flat["data_fingerprint"] = artifact.data_fingerprint
+    flat["universe_basis"] = str(artifact.diagnostics.get("universe_basis", ""))
+    flat["universe_size"] = str(len(artifact.diagnostics.get("universe", [])))
+
+    return ToolResult(
+        value=flat,
+        detail=(
+            f"{spec.signal.kind} over {flat['universe_size']} symbols, "
+            f"{flat['universe_basis']}"
+        ),
+    )
+
+
+@register_tool(
+    ToolScope.INTEGRITY_POINT_IN_TIME,
+    "Report whether a universe was chosen with hindsight, and what it dropped",
+)
+def _integrity_point_in_time(arguments: dict[str, Any]) -> ToolResult:
+    """Check a universe definition for survivorship exposure.
+
+    Deterministic and free. It does not re-run anything -- it answers the
+    prior question of whether the universe *could* be biased, which is what a
+    Data Auditor samples for and what tells a Critic whether the objection is
+    worth raising at all.
+    """
+    from aurelis.engines.universe import resolve_universe
+    from aurelis.intel.sources import source_for
+
+    desk = str(arguments.get("desk", "crypto"))
+    symbols = tuple(arguments.get("symbols") or ())
+    point_in_time = bool(arguments.get("point_in_time", False))
+
+    source = source_for(desk)
+    resolved = resolve_universe(
+        desk, symbols, point_in_time=point_in_time, as_of=source.anchor()
+    )
+    return ToolResult(
+        value={
+            "point_in_time": str(resolved.point_in_time),
+            "universe_size": str(len(resolved.symbols)),
+            "excluded_count": str(len(resolved.excluded)),
+            "excluded": list(resolved.excluded),
+            "survivorship_exposed": str(resolved.survivorship_exposed),
+            "summary": resolved.describe(),
+        },
+        detail=resolved.describe(),
+    )

src/aurelis/cli/research.py

@@ -320,3 +320,123 @@ def research_engines() -> None:
             console.print(f"  metrics  {', '.join(sorted(capabilities.metrics))}")
             console.print(f"  desks    {', '.join(sorted(capabilities.desks))}")
         console.print()
+
+@research_app.command("review")
+def research_review(
+    workspace: WorkspaceOption = None,
+    bars: Annotated[int, typer.Option(help="Window length in bars.")] = 200,
+) -> None:
+    """The M5 demonstration: a confirmed claim, challenged and killed.
+
+    A researcher registers a drawdown claim over the universe of instruments
+    still trading, runs it, and it is CONFIRMED. A Critic names SURVIVORSHIP.
+    The Chair dispatches the generated test -- the same rule over the universe
+    as it actually stood, delisted names restored. The measurement comes back,
+    the objection is upheld, and the hypothesis is refuted.
+
+    Nobody intervenes at any point.
+    """
+    from aurelis.research.review import hold_research_review
+
+    runtime = _runtime(workspace)
+    try:
+        runtime.initialise()
+        runtime.staff()
+        with runtime.database.session() as session:
+            quant = runtime.roster.by_handle(session, "QUANT").ref
+            critic = runtime.roster.by_handle(session, "CRITIC").ref
+            lead = runtime.roster.by_handle(session, "LEAD-R").ref
+            outcome = hold_research_review(
+                session,
+                research=runtime.research,
+                chair=runtime.chair,
+                author=quant,
+                critic=critic,
+                chair_ref=runtime.roster.by_handle(session, "OPS").ref,
+                participants=(quant, critic, lead),
+                registrar=runtime.roster.by_handle(session, "GOV").ref,
+                bars=bars,
+            )
+            verification = runtime.ledger.verify(session)
+    finally:
+        runtime.close()
+
+    console.print()
+    console.print(
+        f"[bold]{outcome.hypothesis_ref}[/bold]  "
+        f"[green]{outcome.verdict_before.value.upper()}[/green] -> "
+        f"[red]{outcome.verdict_after.value.upper()}[/red]"
+    )
+    console.print()
+
+    table = Table(show_header=False, box=None)
+    table.add_column("", style="bold", width=18)
+    table.add_column("")
+    table.add_row("claimed", f"{outcome.metric} < 0.20, measured {outcome.claimed}")
+    table.add_row("universe", f"{outcome.universe_before} names (still trading)")
+    table.add_row("objection", f"{outcome.objection_ref} SURVIVORSHIP, critical")
+    table.add_row("test", "the same rule, universe restored to point-in-time")
+    table.add_row("re-run universe", f"{outcome.universe_after} names")
+    table.add_row("restored", ", ".join(outcome.excluded))
+    table.add_row(
+        outcome.metric,
+        f"[green]{outcome.claimed}[/green] -> [red]{outcome.measured}[/red]",
+    )
+    table.add_row("verdict", f"[red]{outcome.objection_status.value.upper()}[/red]")
+    table.add_row(
+        "chain",
+        f"[green]{verification.describe()}[/green]"
+        if verification.ok
+        else f"[red]{verification.describe()}[/red]",
+    )
+    console.print(table)
+
+    console.print()
+    console.print(f"  [dim]{escape(outcome.detail)}[/dim]")
+    console.print()
+    console.print(
+        "[dim]The universe was chosen knowing which names survived. A top-1 "
+        "rotation is drawn to whatever runs hottest, and the names that later "
+        "delisted ran hottest of all right before they stopped.[/dim]"
+    )
+    console.print(
+        "[dim]martex-quant found this same defect on real crypto history, where "
+        "it took a Sharpe of 1.47 to 0.86. Those figures belong to that corpus; "
+        "the ones above are what this engine measured.[/dim]"
+    )
+    console.print()
+
+    if not outcome.overturned:
+        console.print("[yellow]The review did not overturn the claim.[/yellow]")
+        raise typer.Exit(code=1)
+    console.print(
+        "[green]M5 acceptance: a confirmed result refuted by a measurement, "
+        "with no human in the loop.[/green]"
+    )
+
+
+@research_app.command("defects")
+def research_defects() -> None:
+    """The market defects a Critic can allege, and how each is settled."""
+    from aurelis.meetings.taxonomy import MARKET_DEFECTS
+
+    table = Table(show_header=True, header_style="bold", box=None)
+    table.add_column("defect", style="bold", width=20)
+    table.add_column("severity", width=10)
+    table.add_column("varies", width=30)
+    table.add_column("asks", overflow="fold")
+    for defect in MARKET_DEFECTS.values():
+        colour = "red" if defect.severity.value == "critical" else "yellow"
+        table.add_row(
+            defect.name,
+            f"[{colour}]{defect.severity.value}[/{colour}]",
+            defect.varies,
+            defect.asks,
+        )
+    console.print(table)
+    console.print()
+    console.print(
+        "[dim]A Critic names a defect; the test is generated from the "
+        "specification under review. The prose is the critic's; the arithmetic "
+        "is not.[/dim]"
+    )

src/aurelis/core/enums.py

@@ -119,6 +119,10 @@ class EventKind(StrEnum):
     chose it."""
 
     REPLICATION_RECORDED = "research.replication_recorded"
+    VERDICT_OVERTURNED = "research.verdict_overturned"
+    """A confirmed result was refuted by a later measurement. Its own kind,
+    because a corpus that quietly rewrote conclusions would be worse than one
+    that never revised them."""
 
     # Agent work
     TOOL_CALLED = "tool.called"