fix: close four review minors on the attention-ordered brief

- tone_strip._reading split on the Unicode arrow only while _SERIES_RE
already accepted "->" as well, so an upstream ASCII normalisation would
have kept the rate series working while the plain-language reading
silently vanished. Both halves of the parser are now tolerant.

- test_kpi_footnote_html_is_byte_identical_without_source_url copied the
footnote composition out of _render_quarter_kpis and asserted on the
copy, so changing the separator left it green while it claimed to be a
regression net. Replaced with a spy on verdict.st.markdown driving the
real renderer -- confirmed to fail when the separator is changed, which
the old test did not. test_kpi_source_note_is_exact_empty_string...
is kept as-is.

- attention_view._evasion_deltas duplicated evasion_deltas; it now
delegates, with a test pinning that the two agree across every delta
shape including a non-string kind.

- Roadmap: record explicitly that the consensus-archive work must add a
live reader of display_policy["market_expectations_aligned"]. This
branch deleted market_read.py, the flag's only (dead) consumer, and no
roadmap item was carrying the requirement.

Co-Authored-By: Claude Opus 5 (1M context) <noreply@anthropic.com>

dashboard/attention_view.py

@@ -58,10 +58,10 @@ def _fmt_period(period: str) -> str:
 
 
 def _evasion_deltas(brief: dict) -> list[dict]:
-    return [
-        d for d in (brief.get("quarter_deltas") or [])
-        if isinstance(d, dict) and d.get("kind") == "recurring_evasion"
-    ]
+    """Kept as the in-module name the heatmap view reads; the selection itself
+    lives in `evasion_deltas` below, which The Brief's summary panel and
+    verdict.brief_block_order also call."""
+    return evasion_deltas(brief)
 
 
 def _heatmap(clusters: list[dict]) -> str:

dashboard/tone_strip.py

@@ -31,6 +31,10 @@ from dashboard.theme import (
 # tone_drift.compute_tone_trend's `trajectory = "→".join(...)`.
 _SERIES_RE = re.compile(r"\d+(?:\.\d+)?(?:\s*(?:→|->)\s*\d+(?:\.\d+)?)+")
 _NUMBER_RE = re.compile(r"\d+(?:\.\d+)?")
+# Same two arrow forms _SERIES_RE accepts. Splitting on the Unicode arrow
+# alone would keep the rate series working under an upstream ASCII
+# normalisation while silently dropping the plain-language reading.
+_ARROW_RE = re.compile(r"→|->")
 
 
 def parse_rates(computed_metric: str) -> list[float]:
@@ -56,9 +60,10 @@ def tone_deltas(brief: dict) -> list[dict]:
 def _reading(computed_metric: str) -> str:
     """The analyser's plain-language reading, e.g. "more cautious".
 
-    tone_drift formats it as the trailing "→ <reading>" segment.
+    tone_drift formats it as the trailing "→ <reading>" segment. Both arrow
+    forms _SERIES_RE accepts are honoured here too.
     """
-    parts = str(computed_metric or "").split("→")
+    parts = _ARROW_RE.split(str(computed_metric or ""))
     return parts[-1].strip() if len(parts) > 1 else ""
 
 

docs/superpowers/specs/2026-08-28-attention-dashboard-roadmap.md

@@ -78,6 +78,15 @@ switched off by the app's own fail-closed alignment gate. No UI change can turn
 it on. Only a point-in-time consensus archive carrying our own verifiable
 capture timestamp can.
 
+Follow-on requirement, carried here explicitly: **the archive work is not done
+until a live screen reads `display_policy["market_expectations_aligned"]`.**
+The flag is produced on every run and, as of the attention-ordered-brief branch,
+read by nothing -- that branch deleted `dashboard/market_read.py`, its only
+consumer, and that consumer was dead code (no screen routed to it). A flag
+computed and never consulted is indistinguishable from a flag that is wrong, so
+whichever work item lands the consensus archive must ADD a real consumer, not
+merely flip the hardcoded `False` at `agent/graph.py:665` to a computed value.
+
 **2. No base rate exists.** `analysis/textdiff.py:665-673` diffs the latest
 10-Q against exactly one prior 10-Q. Significance thresholds are module
 constants (`textdiff.py:31-33`, `:61-62`). `compute_lexicon_trend`

tests/test_brief_order.py

@@ -443,3 +443,38 @@ def test_render_keeps_zone_3_inside_the_expander_and_everything_else_above_it(
     # Order is preserved within each side, not merely partitioned.
     assert above == [k for k in order if k not in set(mod.ZONE_3)]
     assert inside == [k for k in order if k in set(mod.ZONE_3)]
+
+
+def test_private_evasion_deltas_delegates_to_the_public_one():
+    """Two near-identical four-line comprehensions answered the same question.
+    _evasion_deltas now delegates; this pins that they agree on every shape a
+    persisted delta list can take -- missing key, None, empty, non-dict
+    entries, and a non-string `kind` (where the two spellings,
+    `d.get("kind") == ...` and `str(d.get("kind") or "") == ...`, could
+    conceivably have diverged)."""
+    from dashboard.attention_view import _evasion_deltas, evasion_deltas
+
+    cases = [
+        {},
+        {"quarter_deltas": None},
+        {"quarter_deltas": []},
+        {"quarter_deltas": [{}]},
+        {"quarter_deltas": [{"kind": None}]},
+        {"quarter_deltas": [{"kind": ""}]},
+        {"quarter_deltas": [{"kind": 5}]},
+        {"quarter_deltas": [{"kind": True}]},
+        {"quarter_deltas": [{"kind": ["recurring_evasion"]}]},
+        {"quarter_deltas": ["not-a-dict", None, 7]},
+        {"quarter_deltas": [
+            _delta("recurring_evasion", "margin"),
+            _delta("risk_added", "supply"),
+            _delta("recurring_evasion", "pricing"),
+        ]},
+    ]
+
+    for brief in cases:
+        assert _evasion_deltas(brief) == evasion_deltas(brief), brief
+
+    # Not vacuous: the last case must actually select something, in order.
+    selected = _evasion_deltas(cases[-1])
+    assert [d["term"] for d in selected] == ["margin", "pricing"]

tests/test_tone_strip.py

@@ -164,3 +164,40 @@ def test_render_tone_strip_never_calls_markdown_when_metric_has_no_numbers(monke
     ]})
 
     assert calls == []
+
+
+_ASCII_METRIC = (
+    "hedge-word rate 27->13->15->55 per 10k words over FY2025->Q32026 "
+    "(rising 3 quarters) -> more cautious"
+)
+
+
+def test_reading_accepts_both_arrow_forms():
+    """_SERIES_RE already tolerates "->" as well as "→"; _reading split on the
+    Unicode arrow alone. An upstream ASCII normalisation would therefore keep
+    the rate series working while the plain-language reading silently
+    vanished -- half a tolerant parser is worse than none."""
+    from dashboard.tone_strip import _reading
+
+    assert _reading(_METRIC) == "more cautious"
+    assert _reading(_ASCII_METRIC) == "more cautious"
+    assert _reading("rate 1->2 per 10k words → less assertive") == "less assertive"
+    assert _reading("no arrows at all") == ""
+    assert _reading("") == ""
+
+
+def test_render_tone_strip_shows_the_reading_for_an_ascii_series(monkeypatch):
+    """End to end through render: the ASCII form must produce the sparkline
+    AND the reading, not the sparkline alone."""
+    import dashboard.tone_strip as mod
+
+    captured: list[str] = []
+    monkeypatch.setattr(
+        mod.st, "markdown", lambda html, **kw: captured.append(str(html))
+    )
+
+    mod.render_tone_strip({"quarter_deltas": [_tone_delta(_ASCII_METRIC)]})
+
+    joined = "".join(captured)
+    assert "<svg" in joined
+    assert "more cautious" in joined

tests/test_verdict.py

@@ -278,42 +278,58 @@ def test_kpi_source_note_is_exact_empty_string_without_source_url():
     assert _kpi_source_note({"source_url": ""}) == ""
 
 
-def test_kpi_footnote_html_is_byte_identical_without_source_url():
+def test_kpi_footnote_composition_goes_through_the_production_renderer(monkeypatch):
     """Regression net for the footnote composition in _render_quarter_kpis.
 
-    _render_quarter_kpis calls st.markdown(...), so the footnote string
-    itself isn't reachable without Streamlit. This mirrors the exact
-    composition from dashboard/verdict.py (the lines immediately above the
-    st.markdown call):
-
-        source_note = _kpi_source_note(latest)
-        source_html = f' · {source_note}' if source_note else ""
-        footnote = f'...{brief_quarter_note_text}{source_html}</div>'
-
-    and asserts that when source_note is "" (no source_url), source_html is
-    also exactly "" -- so the surrounding footnote text is byte-identical
-    to what it was before this feature existed, with no dangling separator.
+    This test used to mirror the composition (`source_html = f' . {note}' if
+    note else ""`) into itself and assert on the copy, so changing the
+    separator in verdict.py left it green while it claimed to be a regression
+    net. It now spies on verdict.st.markdown and drives the real renderer, so
+    the assertions are about the HTML the user actually receives.
     """
-    from dashboard.verdict import _kpi_source_note
+    import dashboard.verdict as mod
+    import dashboard.financials as fin
+    import storage.metrics_db as mdb
     from dashboard.i18n import t
 
     base_text = t("brief_quarter_note").format(section=t("nav_financials"))
 
-    no_url_note = _kpi_source_note({})
-    no_url_html = f' · {no_url_note}' if no_url_note else ""
-    assert no_url_html == ""
-    footnote_without_url = f'{base_text}{no_url_html}'
-    assert footnote_without_url == base_text
-
-    with_url_note = _kpi_source_note({
-        "source_url": "https://www.sec.gov/Archives/edgar/data/320193/x.htm",
-        "accession": "0000320193-26-000081",
-    })
-    with_url_html = f' · {with_url_note}' if with_url_note else ""
-    footnote_with_url = f'{base_text}{with_url_html}'
-
-    assert footnote_with_url != footnote_without_url
-    assert footnote_with_url == f'{base_text} · {with_url_note}'
+    def _row(source_url):
+        return {
+            "period": "Q32026", "form_type": "10-Q", "period_basis": "quarterly",
+            "revenue": 94_000_000_000.0, "eps": 1.57,
+            "gross_margin": 0.469, "operating_margin": 0.301,
+            "free_cash_flow": 24_000_000_000.0,
+            "accession": "0000320193-26-000081", "source_url": source_url,
+        }
+
+    def _render(source_url) -> str:
+        captured: list[str] = []
+        monkeypatch.setattr(mdb, "get_all_metrics", lambda ticker: [_row(source_url)])
+        monkeypatch.setattr(fin, "_display_rows", lambda rows: [_row(source_url)])
+        monkeypatch.setattr(mod.st, "markdown", lambda html, **kw: captured.append(str(html)))
+        mod._render_quarter_kpis("AAPL")
+        return "".join(captured)
+
+    url = "https://www.sec.gov/Archives/edgar/data/320193/000032019326000081/x.htm"
+    with_url = _render(url)
+    without_url = _render(None)
+
+    # The renderer's try/except swallows failures and returns -- an empty
+    # capture would make every assertion below vacuous.
+    assert base_text in without_url
+    assert base_text in with_url
+
+    # No dangling separator, no empty span, nothing at all after the note.
+    assert f'{base_text}</div>' in without_url
+    assert "<a href=" not in without_url
+
+    # The link path adds exactly the separator plus the anchor, and removing
+    # that one segment reproduces the no-URL output byte for byte.
+    note = mod._kpi_source_note({"source_url": url, "accession": "0000320193-26-000081"})
+    assert note
+    assert f'{base_text} . {note}</div>'.replace(" . ", " · ") in with_url
+    assert with_url.replace(f' · {note}', "") == without_url
 
 
 def test_market_band_cells_exclude_commodity_reference_numbers():