@@ -837,8 +837,8 @@ Rewards item: account settings no rail can see, re-checked after any account cha
 ## The operator console, in a browser
 
 `keel serve` opens keel's **operator console**: a local web page showing Pulse (the home view),
-Setup, Holdings, Balances, Timeline, Insights, Research, Rules, Venues and Plans, over the
-same `keel/commands/*` service layer the CLI commands call. It is being slimmed to four engine
+Setup, Holdings, Balances, Timeline, Rules, Venues and Plans, over the same `keel/commands/*`
+service layer the CLI commands call. It is being slimmed to four engine
 views -- Pulse, Holdings, Rules, Audit & Setup; see
 `docs/superpowers/plans/2026-10-10-console-four-views.md`. An architectural test (`tests/commands/test_console_thinness.py`) pins that thinness -- the
 front-end renders and dispatches, and every behaviour comes from the services.
@@ -858,6 +858,19 @@ placement and the fill figures read "unknown", never zero. Below it, keel's rece
 the same scope and status tabs the Orders view had. There is no close and no cancel: `keel orders
 cancel` and the exit path stay at the terminal.
 
+**Rules.** Everything keel knows about its rules, on one page, and nothing on it is a control:
+promotion happens in the CLI. The rule ledger and each rule's parameters come first, then the
+track records of the rules in the promotion pipeline (candidate and paper) with each paper rule's
+distance to the promotion gate -- unsorted, because a sorted record is a leaderboard -- then the
+DCA plan proposal (`/rules?budget=500&buffer=0.1` fills it; it is applied by the `keel dca plan`
+command it shows, at a terminal), then the research record: every trial, the evidence matrix, the
+gauntlet and the slippage assumptions. Track records, promotion-gate distances and the research
+record used to be the Insights and Research views. The equity charts and the closed-trade table
+left the console: the closed-trade journal is `keel insights journal`, your own journal is `keel
+journal list`, and in the browser every fill is still a Timeline `trade` row and every journal
+entry a Timeline `attestation` row. A live rule's track record is `keel insights summary --mode
+live`.
+
 **Halting from the browser.** Pulse carries a HALT button. It engages the kill switch through the
 same operation `keel kill` performs (`POST /api/gates/halt`), after one confirm dialog and nothing
 else: stopping must never be slower than starting. It needs the console session and the gate token
 
@@ -101,18 +101,23 @@ def shown_count(self) -> int:
 
         It lives HERE rather than in a front-end because `total_count` alone does not answer "am I
         looking at a page"; the pair does, and the pair is the report's statement about itself.
-        Every renderer -- the CLI's lines, the HTML, `keel/web/payload.py`'s JSON -- reads it
-        instead of measuring the list again, so none of them can disagree about how many rows the
-        same report held. `asdict()` does not include properties, so `--json`'s shape is
-        unchanged.
+        Every renderer -- the CLI's lines today, and `keel/web/payload.py`'s JSON while the console
+        served a journal (until console PR3) -- reads it instead of measuring the list again, so
+        none of them can disagree about how many rows the same report held. `asdict()` does not
+        include properties, so `--json`'s shape is unchanged.
         """
         return len(self.entries)
 
 
 # -- the equity curve (#537) --------------------------------------------------------------------
 #
-# The browser's one chart. It lives HERE, in the report layer, rather than in `keel/web/` -- and
-# the coordinates live here too, which is the part that looks misplaced and is not.
+# **No front-end draws this today.** The console drew it (and `build_equity_series` below) on its
+# Insights view until console PR3 retired the charts; the builders and their tests stay, by that
+# PR's ruling, so a chart can come back as a client module alone, with no server work. The notes
+# below describe the contract any such chart must keep.
+#
+# It lives HERE, in the report layer, rather than in `keel/web/` -- and the coordinates live here
+# too, which is the part that looks misplaced and is not.
 #
 # **Scaling a chart is a judgement about the data, not a drawing detail.** Where the vertical
 # axis starts decides what the picture says: a curve plotted between its own min and max makes a
@@ -124,10 +129,10 @@ def shown_count(self) -> int:
 #
 # The second reason is arithmetic. Normalising a series means subtracting, dividing and comparing
 # it, and the client is the one place in this system where those operations happen in IEEE-754
-# doubles over values that were exact `Decimal`s a moment earlier. `keel/web/static/js/chart.js`
-# consequently contains no arithmetic at all and `tests/web/test_client_assets.py` scans it for
-# the absence, exactly as it scans `render.js` -- which is only possible because the numbers it
-# draws with arrive finished.
+# doubles over values that were exact `Decimal`s a moment earlier. The console's `chart.js`
+# (deleted in console PR3) consequently contained no arithmetic at all and was scanned for the
+# absence exactly as `render.js` still is -- which was only possible because the numbers it drew
+# with arrived finished.
 #
 # What it would take to move: a chart with a zoom or a pan control. That is interaction over a
 # range the server did not choose, and at that point the range becomes a client concern and this
@@ -558,6 +563,18 @@ def _plot_x(index: int, total: int) -> Decimal:
     return (PLOT_WIDTH * Decimal(index) / Decimal(total - 1)).quantize(_COORD)
 
 
+def _percent_units(fraction: float) -> Decimal:
+    """A 0..1 fraction in percent units (`0.415` -> `41.5`), with the multiply's scale artifact
+    removed.
+
+    The conversion lives HERE, in the report, for the reason `commands/slippage.py::_bp` gives:
+    `payload.percent` takes a figure already in percent units and the serialiser must not
+    rescale -- that would be "the serialiser computing a figure the report never held". The
+    shortest round-trip repr goes in, so `0.3` is `30` and not `30.000000000000004`.
+    """
+    return (Decimal(repr(fraction)) * 100).normalize()
+
+
 @dataclass(frozen=True)
 class GateDistance:
     rule_name: str
@@ -574,6 +591,16 @@ class GateDistance:
     passing: bool
     blocking_reasons: list[str]
 
+    @property
+    def win_rate_pct(self) -> Decimal:
+        """`win_rate` in percent units, for the web page. The CLI keeps printing the fraction."""
+        return _percent_units(self.win_rate)
+
+    @property
+    def min_win_rate_pct(self) -> Decimal:
+        """`min_win_rate` in percent units, for the web page."""
+        return _percent_units(self.min_win_rate)
+
 
 @dataclass(frozen=True)
 class RuleTrackRecord:
@@ -596,6 +623,11 @@ class RuleTrackRecord:
     """`None` for any status other than `paper` -- a `candidate` hasn't backtested yet and a
     `live`/`disabled` rule has already cleared (or been pulled from) the gate this measures."""
 
+    @property
+    def win_rate_pct(self) -> Decimal:
+        """`win_rate` in percent units, for the web page. The CLI keeps printing the fraction."""
+        return _percent_units(self.win_rate)
+
 
 @dataclass(frozen=True)
 class AccountSummary:
 
@@ -2,8 +2,10 @@
 
 The `journal` table has been in the schema from the beginning with no repository method and no
 caller -- dead schema, which is worse than no schema because a reader assumes a declared table is
-a used one. This is its wiring: a CLI that writes it, a report both front-ends read, and a place
-in the audit chain beside everything else a human swore to.
+a used one. This is its wiring: a CLI that writes it, a report `keel journal list` reads, and a
+place in the audit chain beside everything else a human swore to -- which is where the console
+shows it, as Timeline `attestation` rows (its own section left with the Insights view in console
+PR3).
 
 ── WHY THIS RECORD IS DIFFERENT FROM EVERY OTHER RECORD HERE ────────────────────────────────────
 
@@ -75,7 +77,7 @@
 
 @dataclass(frozen=True)
 class JournalEntry:
-    """One entry, as both front-ends read it.
+    """One entry, as `keel journal list` reads it.
 
     Every field but `id`/`ts` is optional, and `None` means DID NOT SAY -- never a zero, an empty
     string, or a `False`. `rules_followed` in particular is three-valued: `False` is the operator
@@ -93,15 +95,6 @@ class JournalEntry:
     screenshot_ref: str | None
 
 
-#: How many entries the console shows without being asked for more.
-#:
-#: The journal has its OWN cap and is deliberately not paged by `/api/journal`'s `?limit=`. That
-#: parameter is the closed-trade table's page control; applying it here was a coincidence of the
-#: two records sharing a route, and it meant narrowing to one trade silently hid 300 of an
-#: operator's 301 notes.
-DEFAULT_NOTES_LIMIT = 50
-
-
 @dataclass(frozen=True)
 class JournalReport:
     now_ts: int
@@ -147,8 +140,8 @@ def gather_journal(repo: Repository, *, now_ts: int, limit: int | None = None) -
 
     A NEGATIVE OR ZERO LIMIT IS REFUSED rather than obeyed. SQLite reads a negative `LIMIT` as
     unbounded, so `--limit -1` would silently print everything; a zero returns no rows, and an
-    empty result is indistinguishable from an empty journal on both front-ends -- which is exactly
-    the hazard `keel/web/api.py::_journal_limit` was written to name. Refusing is the only reading
+    empty result is indistinguishable from an empty journal to whoever reads it -- which is exactly
+    the hazard `keel/web/api.py::_whole_number` was written to name. Refusing is the only reading
     that cannot lie.
     """
     if limit is not None and limit < 1:
 
@@ -83,9 +83,9 @@
 #: table, with the same reasoning, as `activity._SCOPE_DAYS`.
 _SCOPE_DAYS: dict[str, int] = {"today": 1, "7d": 7}
 
-#: Rows served when a caller names no limit. The journal's cap (`api.DEFAULT_JOURNAL_LIMIT`),
-#: for the same reason: a bounded read against a book that may grow for years, sized so the
-#: common case is never truncated at all.
+#: Rows served when a caller names no limit. The cap the console's journal used (retired in
+#: console PR3), for the same reason: a bounded read against a book that may grow for years,
+#: sized so the common case is never truncated at all.
 DEFAULT_ORDERS_LIMIT = 50
 
 #: The ceiling on a caller-supplied limit. A row count from a query string is a memory
 
@@ -209,11 +209,11 @@ def gather_slippage(repo: Repository, config: Config, *, now_ts: int) -> Slippag
     """The configured universe, each product priced from its own cached liquidity.
 
     Rows come back ordered by PRODUCT ID -- the same order `keel simulate` already prints its
-    slippage table in. Not by cost, and that is deliberate under the Strathern rail this whole
-    `/research` surface sits under: a cost table sorted cheapest-first reads as a shortlist of
-    what to trade, and a page that ranks the universe by anything is doing selection while
-    calling itself reporting. Alphabetical is also stable, so the table does not reshuffle
-    between polls as candles arrive.
+    slippage table in. Not by cost, and that is deliberate under the Strathern rail the whole
+    research record (on the console's Rules view) sits under: a cost table sorted cheapest-first
+    reads as a shortlist of what to trade, and a page that ranks the universe by anything is
+    doing selection while calling itself reporting. Alphabetical is also stable, so the table does
+    not reshuffle between polls as candles arrive.
     """
     from keel.commands._products import _default_sim_products
     from keel.strategy import backtest as backtest_mod