diff --git a/keel/commands/plans.py b/keel/commands/plans.py
new file mode 100644
index 0000000..0da6431
--- /dev/null
+++ b/keel/commands/plans.py
@@ -0,0 +1,290 @@
+"""The Plans page, inverted -- a transparency artifact, not a paywall matrix (#706).
+
+Alpaca's Plans & Features page is a tier matrix with "Current plan" and "Upgrade" badges. It is
+radically clear about pricing and it is honest *as marketing*: every row exists to move a reader
+one row down. Jesse paywalls even paper trading.
+
+keel's constitution runs the other way -- "Paper is free and unlimited, forever" and "The free
+engine is never a demo" are two of its eight numbered lines. So this page takes the clarity and
+refuses the gating. It states what runs on this device and why it costs nothing, what a tier would
+change if one ever existed, and the named trigger that must fire before any of it does.
+
+── EVERY CLAIM CARRIES THE DOCUMENT IT CAME FROM, AND A TEST READS THAT DOCUMENT ────────────────
+
+The acceptance criterion is traceability, so it is mechanical rather than asserted. A page of
+marketing sentences that merely SOUNDED like the project's documents would pass a human reviewer
+and rot within a month; the sentences here are quoted verbatim and `tests/commands/test_plans.py`
+opens each cited file and looks for them.
+
+That check runs in both directions, and the second one is why it is worth having. A claim nobody
+can trace fails the build -- but so does a claim the project has since edited out of its own
+documents, which is the failure that would otherwise go unnoticed: a promise page still making a
+promise nobody kept.
+
+── NOTHING HERE IS FOR SALE, AND THE PAGE SAYS SO RATHER THAN IMPLYING IT ───────────────────────
+
+ADR 0004's answer is "not now" and none of its four triggers has fired. No tier below is
+`shipped`. There is no price a reader can act on, no address, no link and no instruction --
+because a page that told someone how to pay would have shipped the tier. If a tier ever does
+ship, its `shipped` flag is flipped by the PR that ships it, never ahead of it.
+
+── AND NO DATABASE ──────────────────────────────────────────────────────────────────────────────
+
+This page describes the project, not the deployment. It reads no repository, no config and no
+network, which is why its route can answer on a machine with nothing set up at all.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator
+from dataclasses import dataclass
+
+#: The two documents every claim on this page is quoted from.
+EVOLUTION_PLAN = "docs/evolution-plan.md"
+DECISION_RECORD = "docs/decisions/0004-monetisation-not-now.md"
+
+
+@dataclass(frozen=True)
+class Claim:
+    """One quoted sentence and the file it came from.
+
+    `source` is a repository-relative path rather than a title, so the test that checks this can
+    OPEN it. A citation naming "the evolution plan" would be a citation nothing could verify --
+    worse than none, because it looks checkable.
+    """
+
+    text: str
+    source: str
+
+
+@dataclass(frozen=True)
+class Tier:
+    """One row of the Phase F table, as published.
+
+    `shipped` is `False` on every row and is the only field a future PR should change. It exists
+    as a field rather than being implied by the page's prose because "this does not exist yet" is
+    the single most important thing this table says, and a sentence can be edited past without
+    anything failing.
+
+    `available_now` is separate and true of exactly one row: the free tier is what the reader is
+    already running. A table that presented four rows as four CHOICES would be a paywall matrix
+    with the prices greyed out.
+    """
+
+    name: str
+    price: str
+    buys: str
+    promise: str
+    source: str
+    shipped: bool = False
+    available_now: bool = False
+
+
+@dataclass(frozen=True)
+class Trigger:
+    """One of ADR 0004's four triggers -- what would have to happen before a tier exists.
+
+    The record says the four are the complete set and that a new trigger is a new decision record
+    rather than an edit, so this page may not grow a fifth.
+    """
+
+    number: int
+    text: str
+    source: str = DECISION_RECORD
+
+
+#: The constitution, §4 of the evolution plan, verbatim and entire.
+#:
+#: ALL EIGHT. A page that quoted seven would be choosing which of the project's own commitments to
+#: show a reader, on the page whose whole subject is what the project promises -- and the test
+#: counts the numbered lines in the document rather than against a literal, so a ninth line fails
+#: the build until this carries it.
+CONSTITUTION: tuple[Claim, ...] = (
+    Claim("A tool that cannot say no is a flattery tool.", EVOLUTION_PLAN),
+    Claim("Scores report and gate; they never rank (the Strathern rail).", EVOLUTION_PLAN),
+    Claim("Fees are priced at what was actually paid.", EVOLUTION_PLAN),
+    Claim("Paper is free and unlimited, forever.", EVOLUTION_PLAN),
+    Claim("Every attestation is human-sourced, or refused.", EVOLUTION_PLAN),
+    Claim("The free engine is never a demo.", EVOLUTION_PLAN),
+    Claim("The operator's servers never hold venue keys.", EVOLUTION_PLAN),
+    Claim("Negative results are published.", EVOLUTION_PLAN),
+)
+
+#: Phase F's tier table, as a published intention. Nothing here is buyable.
+TIERS: tuple[Tier, ...] = (
+    Tier(
+        name="Free",
+        price="$0, forever",
+        buys="The full engine. Never a demo.",
+        promise="We see nothing",
+        source=EVOLUTION_PLAN,
+        available_now=True,
+    ),
+    Tier(
+        name='Pro — "your box, anywhere"',
+        price="$14/mo · $140/yr prepay",
+        buys=(
+            "managed `keel link`, signed+notarized installers (the #438 certs become Pro "
+            "value), managed updates, Web Push plumbing, priority support"
+        ),
+        promise="We can't see your data",
+        source=EVOLUTION_PLAN,
+    ),
+    Tier(
+        name="Founder — lifetime",
+        price="$399, first 200, then gone",
+        buys="Everything in Pro, forever, founder badge",
+        promise="Grandfathering is a promise, not a promo",
+        source=EVOLUTION_PLAN,
+    ),
+    Tier(
+        name='Hosted-confirm — "our brain, your keys"',
+        price="$49/mo · $450/yr (built last)",
+        buys="Full hosted engine; your device holds the keys and approves every order",
+        promise="We can see, we can't act",
+        source=EVOLUTION_PLAN,
+    ),
+)
+
+#: How ADR 0004 frames what would reopen the question. Quoted because the framing IS the claim:
+#: a trigger measured in revenue would make this page a countdown, and one measured in users makes
+#: it a condition a reader can check for themselves.
+TRIGGER_FRAMING = "Framed in users and demonstrated demand"
+TRIGGER_FRAMING_SOURCE = DECISION_RECORD
+
+#: The four triggers, quoting the record's "What fires it" cell WHOLE.
+#:
+#: The evidence column and the observer column stay in the record -- this page carries what would
+#: have to be true, not how it would be established. But the FIRING CONDITION is quoted entire,
+#: cell for cell, and a test compares it against the record's own table rather than merely finding
+#: it inside the document.
+#:
+#: The first cut cut all three short, and each cut changed what fires. Trigger 3 lost "not a
+#: feature request, a request to pay for upkeep" -- the clause separating it from an ordinary
+#: feature request. Trigger 1 lost most of its condition. Trigger 4 lost "evidenced by external
+#: contributors, not by the founder's schedule", which is what stops a tired maintainer being the
+#: evidence. A truncated trigger fires on strictly more of the world than the record's does, so
+#: the page would have been publishing an easier promise than the one that was made -- and
+#: anchoring a quote to the start of a statement catches a quote that begins late, never one that
+#: ends early.
+TRIGGERS: tuple[Trigger, ...] = (
+    Trigger(
+        1,
+        "keel reaches an audience shaped like Jesse's pre-2021 one — public for a comparable "
+        "stretch, with adoption to show for it",
+    ),
+    Trigger(
+        2,
+        "The headline finding reverses — a shipped rule family is measured net-positive at the "
+        "taker fee actually paid",
+    ),
+    Trigger(
+        3,
+        "Operators repeatedly and unprompted ask for something that costs real money to run on "
+        "their behalf — hosted infra, a maintained third-party integration, priority support — "
+        "not a feature request, a request to pay for upkeep",
+    ),
+    Trigger(
+        4,
+        "keel's own maintenance load demonstrably exceeds what volunteer, spare-time work can "
+        "carry — evidenced by external contributors, not by the founder's schedule",
+    ),
+)
+
+#: What no tier will ever gate. The load-bearing half of this page, and the half a later
+#: contributor would be most tempted to soften -- so each line is quoted from a document that
+#: already committed to it rather than written fresh here.
+#:
+#: SIX CLAIMS THAT ARE ACTUALLY ABOUT GATING. The first cut carried three constitution lines
+#: verbatim from the section above, so a reader met them twice -- and two of them ("Fees are
+#: priced at what was actually paid", "Every attestation is human-sourced, or refused") are not
+#: things a tier could gate at all. A refusal list padded from the section above it reads as a
+#: longer promise than the project made, which on this page is the specific failure to avoid.
+#:
+#: The markdown emphasis and the sentence tails are stripped: `**bold**` markers render as literal
+#: asterisks through `plain()` (the client has no markdown pass and bans `innerHTML`), and the
+#: affiliate line ended mid-sentence at its closing `**`, which reads as a truncation bug on the
+#: page whose whole subject is that it can be checked. The TEST normalises the document instead --
+#: see `_readable` there -- so these stay checkable while reading as prose.
+NEVER_PAYWALLED: tuple[Claim, ...] = (
+    Claim("Paper is free and unlimited, forever.", EVOLUTION_PLAN),
+    Claim("The free engine is never a demo.", EVOLUTION_PLAN),
+    Claim("No engine feature gates for paid tiers", "docs/architecture.md"),
+    Claim(
+        "Live order placement (`keel/execution/`) stays inside the Apache-2.0 tree in full, "
+        "always.",
+        DECISION_RECORD,
+    ),
+    Claim(
+        "Affiliate or referral links to any trading venue, broker, or exchange are never added "
+        "to keel, its documentation, or its site",
+        DECISION_RECORD,
+    ),
+    Claim(
+        "No accounts, billing relationship, license-token gate, or server-side validation gets "
+        "added to keel while this record stands.",
+        DECISION_RECORD,
+    ),
+)
+
+#: What the page says about today, in one sentence. Held here rather than in the renderer for the
+#: usual reason (Rule 2): it is a judgement about the project's state, and judgements are made in
+#: Python.
+NOTHING_FOR_SALE = (
+    "Nothing on this page is for sale. keel is free, entirely, and no tier below exists — "
+    "the prices are a published intention, not an offer."
+)
+
+
+def every_claim() -> Iterator[Claim]:
+    """Every traceable claim on the page, for the test that checks each cited file exists."""
+    yield from CONSTITUTION
+    yield from NEVER_PAYWALLED
+    for tier in TIERS:
+        # NAME, PRICE, BUYS AND PROMISE. The first cut yielded only the promise, so `buys` -- the
+        # longest string on the page and a whole table column -- was traced by nothing: a
+        # contributor could add "early access to new rule families" to a tier, render it with a
+        # citation beside it, and pass every gate. The acceptance criterion is traceability, and
+        # the largest cell in the table was outside it.
+        yield Claim(tier.name, tier.source)
+        yield Claim(tier.price, tier.source)
+        yield Claim(tier.buys, tier.source)
+        yield Claim(tier.promise, tier.source)
+    for trigger in TRIGGERS:
+        yield Claim(trigger.text, trigger.source)
+    yield Claim(TRIGGER_FRAMING, TRIGGER_FRAMING_SOURCE)
+
+
+@dataclass(frozen=True)
+class PlansReport:
+    #: NO TIMESTAMP, deliberately, and the sibling settles it: `gates_payload` describes capability
+    #: rather than deployment and takes no `now_ts` at all. Every other view stamps itself because
+    #: its figures were observed at a moment; nothing on this page was observed. The first cut sent
+    #: `as_of` and `generated_at` and rendered neither -- a stamp nobody shows is a stamp that will
+    #: eventually be shown, and it would date a page whose content changes only when a document
+    #: does.
+    constitution: tuple[Claim, ...]
+    tiers: tuple[Tier, ...]
+    triggers: tuple[Trigger, ...]
+    never_paywalled: tuple[Claim, ...]
+
+    @property
+    def anything_for_sale(self) -> bool:
+        """Whether any tier has actually shipped.
+
+        Derived from the table rather than from a constant, so flipping one `shipped` flag is all
+        it takes for the page to stop saying nothing is for sale -- and so that the sentence and
+        the table can never disagree.
+        """
+        return any(tier.shipped for tier in self.tiers)
+
+
+def gather_plans() -> PlansReport:
+    """The page. No repository, no config, no network and no clock -- it describes the project,
+    not the deployment, which is why its route answers on a machine with nothing set up."""
+    return PlansReport(
+        constitution=CONSTITUTION,
+        tiers=TIERS,
+        triggers=TRIGGERS,
+        never_paywalled=NEVER_PAYWALLED,
+    )
diff --git a/keel/web/api.py b/keel/web/api.py
index cd14abe..b0401cf 100644
--- a/keel/web/api.py
+++ b/keel/web/api.py
@@ -740,6 +740,23 @@ def read_journal(cfg: ServeConfig, query: Query, _state: Any, now_ts: int) -> di
     )
 
 
+def read_plans(_cfg: ServeConfig, _query: Query, _state: Any, _now_ts: int) -> dict[str, Any]:
+    """The Plans page (#706) -- the one route whose subject is the PROJECT, not the deployment.
+
+    No repository, no config, no network. Every string it answers with is quoted from a document
+    in this repository and carries that document's path, so a reader can check the page against
+    the source and `tests/commands/test_plans.py` can check it on every build.
+
+    `needs_database=False` for the same reason `/api/config` and `/api/venues` carry it: this
+    answers identically on a machine with nothing set up, and a page explaining that keel is free
+    and runs entirely on the operator's own hardware would be a strange one to gate behind having
+    already installed it.
+    """
+    from keel.commands.plans import gather_plans
+
+    return payload.plans_payload(gather_plans())
+
+
 def read_rules(cfg: ServeConfig, _query: Query, _state: Any, _now_ts: int) -> dict[str, Any]:
     repo = open_repo(cfg.db_path)
     try:
@@ -1007,6 +1024,14 @@ class ApiRoute:
         collection="rules",
         sortable=("id", "kind", "status", "created_at", "promoted_at", "demoted_at"),
     ),
+    # #706. `needs_database=False`, and NO `collection`/`sortable`: there is nothing on this page
+    # to sort. A tier table ordered by price is a shopping comparison, and the whole point of the
+    # inversion is that these four rows are not four choices.
+    "/api/plans": ApiRoute(
+        html_route="/plans",
+        read=read_plans,
+        needs_database=False,
+    ),
     "/api/venues": ApiRoute(
         html_route="/venues",
         read=read_venues,
diff --git a/keel/web/payload.py b/keel/web/payload.py
index c82eec7..56772f4 100644
--- a/keel/web/payload.py
+++ b/keel/web/payload.py
@@ -140,6 +140,7 @@
     # rather than leaving two `JournalReport`s in one namespace to be told apart by context.
     from keel.commands.journal import JournalReport as DiscretionaryJournal
     from keel.commands.orders import OrderRow, OrdersReport
+    from keel.commands.plans import Claim, PlansReport, Tier, Trigger
     from keel.commands.positions import PositionRow, PositionsReport
     from keel.commands.research_record import RuleExploration, TrialRow, TrialsReport
     from keel.commands.slippage import SlippageReport, SlippageRow
@@ -1367,6 +1368,139 @@ def _rules_followed_state(value: bool | None) -> str:
     return NEUTRAL if value else WARN
 
 
+# -- plans, inverted (#706) ------------------------------------------------------------------------
+#
+# THE ONE PAGE IN THIS APPLICATION WHOSE SUBJECT IS THE PROJECT RATHER THAN THE DEPLOYMENT, and
+# the only one that reads no repository at all.
+#
+# Every string below is quoted from a document and carries the file it came from, checked by
+# `tests/commands/test_plans.py` against the file itself. Nothing here is composed, summarised or
+# softened on the way to the wire -- the whole value of the page is that a reader can check it,
+# and a payload that rephrased a promise would be the first place the checking stopped working.
+
+
+def _claim_payload(claim: Claim) -> dict[str, Any]:
+    """One quoted sentence and its citation.
+
+    `source` is a repository-relative PATH, not a title, because a reader with the repository in
+    front of them can open it -- and because the test that keeps this page honest opens it too. A
+    citation naming "the evolution plan" would look checkable and be nothing of the kind.
+    """
+    return {"text": claim.text, "source": claim.source}
+
+
+def _tier_payload(tier: Tier) -> dict[str, Any]:
+    """One row of the Phase F table, and whether it exists.
+
+    `status` is a `label` and the readings are NOT good and bad. The free tier is what the
+    reader is already running (`GOOD` -- it is the one thing on this page that is true today), and
+    every other row is `UNKNOWN`: not warned about, not promised, simply not a thing yet. `WARN`
+    would read as a caution about a product, and there is no product to caution anyone about.
+
+    `shipped` and `available_now` are separate fields on the report and collapse to one word here,
+    because a client rendering two booleans would be deciding what their combination means, which
+    is a judgement (Rule 2). The state comes off the SAME word, not off `available_now` -- the
+    first cut read `GOOD if tier.available_now else UNKNOWN`, so the day a Pro tier shipped, the
+    one row that had become real would have worn the same "not a thing yet" badge as the three
+    that had not.
+    """
+    return {
+        "name": tier.name,
+        "price": tier.price,
+        "buys": tier.buys,
+        "promise": tier.promise,
+        "source": tier.source,
+        "status": label(
+            _tier_status(tier),
+            display=_TIER_STATUS_NOTES[_tier_status(tier)],
+            state=_TIER_STATES[_tier_status(tier)],
+        ),
+    }
+
+
+#: What each tier's one-word status MEANS. The word is short enough for a table cell; the sentence
+#: is what stops a reader taking "planned" for "coming soon", which is the reading a page like this
+#: is normally built to encourage.
+_TIER_STATUS_NOTES: Mapping[str, str] = {
+    "running": "this is what you are running now, and it is the whole engine",
+    "planned": "does not exist — a published intention, gated on a trigger that has not fired",
+    # The one status a future PR will actually set, and the first cut left its display collapsed to
+    # the word itself -- so the cell would have read "shipped / shipped" on the only row where a
+    # reader most needs a sentence.
+    "shipped": "this exists and can be bought — see the decision record that superseded ADR 0004",
+}
+
+
+#: The state each status word carries. `running` and `shipped` are both things that EXIST; the
+#: difference between them is price, not reality, and a page that graded the shipped one as unknown
+#: would be contradicting its own table. `planned` is UNKNOWN and never WARN: there is no product
+#: to caution anyone about.
+_TIER_STATES: Mapping[str, str] = {
+    "running": GOOD,
+    "shipped": GOOD,
+    "planned": UNKNOWN,
+}
+
+
+def _tier_status(tier: Tier) -> str:
+    """`running` for the free tier, `planned` for the rest -- and `shipped` for whichever row a
+    future PR flips, which is the only edit this page should ever need."""
+    if tier.shipped:
+        return "shipped"
+    return "running" if tier.available_now else "planned"
+
+
+def _trigger_payload(trigger: Trigger) -> dict[str, Any]:
+    return {
+        "number": str(trigger.number),
+        "text": trigger.text,
+        "source": trigger.source,
+    }
+
+
+def plans_payload(report: PlansReport) -> dict[str, Any]:
+    """The transparency artifact (#706).
+
+    **The refusals are structural, not editorial.** There is no `cta`, no `url`, no `action` and
+    no `contact` key on this payload, and there is nothing for a client to build one out of.
+    `render.js` cannot make a button out of a page that never sends it a destination.
+
+    `for_sale` is a `flag` derived from the tier table rather than a constant, so the sentence and
+    the table cannot come to disagree: flipping one tier's `shipped` is all it takes for the page
+    to stop saying nothing is for sale.
+    """
+    from keel.commands.plans import (
+        NOTHING_FOR_SALE,
+        TRIGGER_FRAMING,
+        TRIGGER_FRAMING_SOURCE,
+    )
+    from keel.commands.plans import (
+        Claim as _Claim,
+    )
+
+    return {
+        # NO `as_of`/`generated_at`, matching `gates_payload` next door, which also describes
+        # capability rather than deployment and also sends none. Nothing on this page was
+        # OBSERVED at a moment -- it changes when a document changes -- and a stamp nobody renders
+        # is a stamp that eventually gets rendered, dating a page that has no date.
+        "for_sale": flag(
+            report.anything_for_sale,
+            on="a tier has shipped — this page is out of date",
+            off=NOTHING_FOR_SALE,
+            on_state=WARN,
+            off_state=NEUTRAL,
+        ),
+        "constitution": [_claim_payload(claim) for claim in report.constitution],
+        "tiers": [_tier_payload(tier) for tier in report.tiers],
+        # The framing rides as a CLAIM like every other sentence here -- it is quoted from ADR
+        # 0004 and is checkable against it, and a trigger measured in revenue rather than users
+        # would turn this page into a countdown.
+        "trigger_framing": _claim_payload(_Claim(TRIGGER_FRAMING, TRIGGER_FRAMING_SOURCE)),
+        "triggers": [_trigger_payload(trigger) for trigger in report.triggers],
+        "never_paywalled": [_claim_payload(claim) for claim in report.never_paywalled],
+    }
+
+
 # -- activity ------------------------------------------------------------------------------------
 
 
diff --git a/keel/web/static/css/keel.css b/keel/web/static/css/keel.css
index 71efd29..8834e45 100644
--- a/keel/web/static/css/keel.css
+++ b/keel/web/static/css/keel.css
@@ -256,6 +256,28 @@ header .mode-paper { color: var(--muted); }
 header .mode-confirm,
 header .mode-live { color: var(--accent); border-color: var(--accent); }
 
+/* THE PLANS PAGE's claim list (#706).
+ *
+ * A quoted sentence with its citation beside it, not beneath it: a citation a reader has to go
+ * looking for is one they take on trust, and taking this page on trust is the one thing it cannot
+ * afford. `list-style: none` because the numbering belongs to the document being quoted, not to
+ * this rendering of it -- a page that renumbered the constitution would be paraphrasing it in a
+ * different way. */
+.claims {
+  list-style: none;
+  margin: 0.5rem 0 1rem;
+  padding: 0;
+}
+.claims li {
+  padding: 0.35rem 0;
+  border-bottom: 1px solid var(--line);
+}
+.claims li:last-child { border-bottom: none; }
+.claims code {
+  font-size: 0.8em;
+  color: var(--muted);
+}
+
 /* THE SESSION CHIP (#704): profile · mode · equity state, as one group.
  *
  * A group and not three loose items, because the three are one answer: "which deployment is this
diff --git a/keel/web/static/index.html b/keel/web/static/index.html
index 90074c8..09b3273 100644
--- a/keel/web/static/index.html
+++ b/keel/web/static/index.html
@@ -25,7 +25,7 @@
     2. It is the project's own argument for choosing the web at all (§4 of the spec's
        Philosophy): the structure of the page is readable in view-source without running
        anything.
-    3. The nav is a fixed list of eight links. Building a fixed list at runtime buys nothing and
+    3. The nav is a fixed list of links. Building a fixed list at runtime buys nothing and
        costs the keyboard path before the module has loaded.
 
   ── NO INLINE SCRIPT AND NO INLINE STYLE, AND THAT IS ENFORCED ──────────────────────────────
@@ -134,10 +134,18 @@
       <li><a href="/venues">Venues</a></li>
       <li><a href="/gates">Gates</a></li>
       <!--
-        THE EIGHTH NAV ENTRY IS A LINK, NOT A VIEW (#539).
+        #706. Beside Gates because it belongs to the same half of the app: what this deployment is
+        allowed to do, and what it costs. A transparency artifact rather than a paywall matrix --
+        it lists what is free forever and why, and there is nothing on it to buy.
+      -->
+      <li><a href="/plans">Plans</a></li>
+      <!--
+        THE LAST NAV ENTRY IS A LINK, NOT A VIEW (#539).
 
-        `render.py`'s NAV has eight entries and this client has seven, and the difference is the
-        glossary. keel's `docs/` lives at the REPOSITORY root, outside the `keel/` module that
+        It was "the eighth" when the nav had seven views; it is now the fourteenth, and a count
+        written into prose is a count that goes stale silently -- so it is described by its
+        position rather than numbered. (`render.py`, which this comment used to compare against,
+        was deleted at #540; the difference it named was the glossary.) keel's `docs/` lives at the REPOSITORY root, outside the `keel/` module that
         `uv_build` packages, so no wheel has ever carried it -- every installed deployment
         renders an empty glossary today. That is not fixable with a packaging glob (measured at
         #535: the `artifacts` key is inert on the pinned backend), so the documentation is
diff --git a/keel/web/static/js/main.js b/keel/web/static/js/main.js
index afcd537..b0b440a 100644
--- a/keel/web/static/js/main.js
+++ b/keel/web/static/js/main.js
@@ -42,6 +42,7 @@ import {
   buildLine,
   engineBanner,
   gatesView,
+  plansView,
   insightsView,
   modeBadge,
   paperBanner,
@@ -111,6 +112,7 @@ const ROUTES = [
   { name: "rules", label: "Rules", endpoints: ["rules"] },
   { name: "venues", label: "Venues", endpoints: ["venues"] },
   { name: "gates", label: "Gates", endpoints: ["gates"] },
+  { name: "plans", label: "Plans", endpoints: ["plans"] },
 ];
 
 /** Where an unrecognised path lands, and what `BASE` alone means. @type {Route} */
@@ -470,6 +472,7 @@ function mount(route, readings) {
   if (route.name === "rules") return rulesView(data, primary.sort, onSort);
   if (route.name === "venues") return venuesView(data, primary.sort, onSort);
   if (route.name === "gates") return gatesView(data);
+  if (route.name === "plans") return plansView(data);
   return statusView(data);
 }
 
diff --git a/keel/web/static/js/render.js b/keel/web/static/js/render.js
index 2efc78a..9521fc0 100644
--- a/keel/web/static/js/render.js
+++ b/keel/web/static/js/render.js
@@ -2889,6 +2889,128 @@ function venueCard(info) {
   return node;
 }
 
+/**
+ * The Plans page, inverted (#706).
+ *
+ * A retail broker's Plans & Features page is a tier matrix with "Current plan" and "Upgrade"
+ * badges: radically clear about pricing, and honest as marketing, because every row exists to
+ * move a reader one row down. keel's constitution runs the other way -- "Paper is free and
+ * unlimited, forever" and "The free engine is never a demo" are two of its eight numbered lines.
+ *
+ * So this takes the clarity and refuses the gating. **There is nothing here to click.** No
+ * button, no link, no form, no price a reader can act on -- and not because this function
+ * declines to draw one, but because the payload sends no destination to draw it from. A page that
+ * told someone how to pay would have shipped the tier.
+ *
+ * Every sentence arrives quoted, with the repository path it came from, and this function places
+ * both. It composes nothing: the whole value of the page is that a reader can check it against
+ * the documents, and a renderer that rephrased a promise would be the first place the checking
+ * stopped working.
+ *
+ * @param {any} data  `/api/plans`'s `data`.
+ * @returns {DocumentFragment}
+ */
+export function plansView(data) {
+  const fragment = document.createDocumentFragment();
+  fragment.append(el("h1", undefined, "Plans"));
+  fragment.append(
+    el("p", "sub", "what runs on this device, what it costs, and why"),
+  );
+
+  // The state of play, first and in a card of its own. On a page shaped like a price list, the
+  // one thing a reader must not have to infer is whether any of it is for sale.
+  const state = el("div", "card");
+  state.append(field(data.for_sale));
+  fragment.append(state);
+
+  fragment.append(heading("h-constitution", "What every feature has to pass"));
+  fragment.append(claimList(data.constitution));
+
+  fragment.append(heading("h-tiers", "What a tier would change, if one existed"));
+  fragment.append(
+    table(
+      "h-tiers",
+      [
+        { label: "tier", numeric: false },
+        { label: "price", numeric: false },
+        { label: "what it would buy", numeric: false },
+        { label: "the promise", numeric: false },
+        { label: "status", numeric: false },
+      ],
+      (data.tiers || []).map(/** @param {any} tier */ (tier) => [
+        plain(tier.name),
+        plain(tier.price),
+        plain(tier.buys),
+        plain(tier.promise),
+        tier.status,
+      ]),
+      "No tiers published.",
+    ),
+  );
+
+  fragment.append(heading("h-triggers", "What would have to happen first"));
+  const framing = el("p", "note");
+  framing.append(citation(data.trigger_framing));
+  fragment.append(framing);
+  fragment.append(
+    table(
+      "h-triggers",
+      [
+        { label: "#", numeric: true },
+        { label: "what fires it", numeric: false },
+        { label: "recorded in", numeric: false },
+      ],
+      (data.triggers || []).map(/** @param {any} trigger */ (trigger) => [
+        plain(trigger.number),
+        plain(trigger.text),
+        plain(trigger.source),
+      ]),
+      "No triggers recorded.",
+    ),
+  );
+
+  fragment.append(heading("h-never", "What no tier will ever gate"));
+  fragment.append(claimList(data.never_paywalled));
+
+  return fragment;
+}
+
+/**
+ * A list of quoted claims, each with the file it came from (#706).
+ *
+ * The citation is beside the sentence rather than in a footnote, because a citation a reader has
+ * to go looking for is a citation they will take on trust -- which is the one thing this page
+ * cannot afford, its entire subject being what the project promises.
+ *
+ * @param {any[]} claims
+ * @returns {HTMLElement}
+ */
+function claimList(claims) {
+  const list = el("ul", "claims");
+  for (const claim of claims || []) {
+    const item = el("li");
+    item.append(el("span", undefined, plain(claim.text)), " ");
+    item.append(citation(claim));
+    list.append(item);
+  }
+  return list;
+}
+
+/**
+ * One citation: the repository-relative path a sentence was quoted from.
+ *
+ * A `<code>` and NOT an `<a>`. There is no server here to fetch a document from -- `keel serve`
+ * is a loopback SQLite reader -- and a link that 404ed would be worse than a path a reader can
+ * open in their own checkout. It is also the page's one structural refusal: nothing in this view
+ * builds an anchor, so nothing in it can become a destination.
+ *
+ * @param {any} claim
+ * @returns {HTMLElement}
+ */
+function citation(claim) {
+  return el("code", "muted", plain(claim.source));
+}
+
 /**
  * Gates: `/api/gates`'s payload -- the capability inventory (#436).
  *
diff --git a/keel/web/staticfiles.py b/keel/web/staticfiles.py
index 2ea5be0..64556f8 100644
--- a/keel/web/staticfiles.py
+++ b/keel/web/staticfiles.py
@@ -149,6 +149,7 @@ def resolve_static_asset(root: Path, url_path: str) -> Path | None:
     "rules",
     "venues",
     "gates",
+    "plans",
 )
 
 #: The shell every client route is served from, relative to `STATIC_ROOT`.
diff --git a/tests/commands/test_plans.py b/tests/commands/test_plans.py
new file mode 100644
index 0000000..9e0a6a0
--- /dev/null
+++ b/tests/commands/test_plans.py
@@ -0,0 +1,383 @@
+"""The Plans page, inverted (#706).
+
+Alpaca's Plans & Features page is a tier matrix with "Current plan" and "Upgrade" badges --
+radical clarity about pricing, and honest *as marketing*. keel's constitution runs the other way:
+paper is free and unlimited forever, and the free engine is never a demo.
+
+So this page takes the clarity and refuses the gating. It is a TRANSPARENCY ARTIFACT: what runs on
+this device and why it costs nothing, what a tier would change if one ever existed, and the named
+trigger that must fire before any of it does.
+
+── THE ACCEPTANCE CRITERION IS TRACEABILITY, SO IT IS MECHANICAL ────────────────────────────────
+
+"Every claim on the page traces to the evolution plan or the constitution -- no aspirational
+copy." A page of marketing sentences that *sound* like the documents would satisfy a human
+reviewer and rot in a month.
+
+So every claim carries the file it came from, and these tests read that file and assert the
+sentence is IN it. A claim nobody can trace fails the build; a document edited out from under the
+page fails the build too, which is the direction that actually matters -- the page cannot go on
+asserting something the project has stopped believing.
+"""
+
+from __future__ import annotations
+
+import re
+from pathlib import Path
+
+from keel.commands import plans
+
+_ROOT = Path(__file__).resolve().parents[2]
+
+
+def _doc(relative: str) -> str:
+    return (_ROOT / relative).read_text(encoding="utf-8")
+
+
+def _readable(document: str) -> str:
+    """The document with its markdown EMPHASIS removed, and nothing else changed.
+
+    The page renders quoted sentences through `plain()`, which sets `textContent` -- the client has
+    no markdown pass and bans `innerHTML` -- so a quote carrying `**bold**` shows literal asterisks
+    on the page whose whole subject is that it can be checked. Worse, quoting up to a closing `**`
+    ends the sentence where the emphasis ends rather than where the sentence does, which reads as a
+    truncation bug: the affiliate rule did exactly that.
+
+    So the CLAIMS are written as prose and the DOCUMENT is normalised to meet them. Only `**` and
+    backticks go; every word stays, so a quote still has to be the document's own words in the
+    document's own order.
+    """
+    return document.replace("**", "")
+
+
+def _statements(document: str) -> list[str]:
+    """Every place the document STARTS saying something, as the text from there on.
+
+    A bare `in` verifies PRESENCE, not faithfulness, and the difference is not academic:
+    `"reopens affiliate links"` is a contiguous substring of ADR 0004, where the sentence reads
+    "None of these four reopens affiliate links". Quoted alone under a heading saying "What no tier
+    will ever gate", it would invert the record's meaning, carry a checkable citation, and pass a
+    substring test.
+
+    So this enumerates statement starts -- a list item, a table cell, a paragraph, and each
+    sentence within one -- and `_quotes` asks whether a claim begins at one. Continuation lines are
+    joined and whitespace collapsed first, because these documents wrap at 100 columns and a quoted
+    sentence should not have to reproduce where the wrapping fell.
+    """
+    starts: list[str] = []
+    for block in _readable(document).split("\n\n"):
+        for row in block.splitlines():
+            if row.strip().startswith("|"):
+                # A table row: every cell is its own statement. `| 3 | Operators repeatedly...`
+                starts.extend(cell.strip() for cell in row.strip().strip("|").split("|"))
+        prose = " ".join(
+            row.strip() for row in block.splitlines() if not row.strip().startswith("|")
+        )
+        prose = " ".join(prose.split())
+        if not prose:
+            continue
+        # The block itself, the text after each list marker, and each sentence within it.
+        starts.append(prose)
+        starts.extend(_LIST_MARKER.split(prose)[1:])
+        starts.extend(part.strip() for part in _SENTENCE_END.split(prose)[1:])
+    return [start for start in starts if start]
+
+
+#: A markdown list marker anywhere in a joined block -- `- `, `* `, `1. `. Used to SPLIT, so what
+#: follows each marker becomes a statement start of its own.
+_LIST_MARKER = re.compile(r"(?:^|\s)(?:[-*]|\d+\.)\s+")
+
+#: Sentence-ending punctuation followed by a space. Same use: what follows is a new statement.
+_SENTENCE_END = re.compile(r"(?<=[.?!:])\s+")
+
+
+def _quotes(claim: str, document: str) -> bool:
+    """Whether `claim` is quoted from the START of something the document says.
+
+    Not that it appears somewhere in it. That does not make a quote honest -- nothing can -- but it
+    removes the trick of beginning a sentence in the middle to drop the word that reverses it.
+    """
+    wanted = " ".join(claim.split())
+    return any(start.startswith(wanted) for start in _statements(document))
+
+
+# -- traceability ---------------------------------------------------------------------------------
+
+
+def test_every_constitution_line_is_quoted_from_the_evolution_plan() -> None:
+    """The eight numbered lines of §4, verbatim. Not paraphrased: a paraphrase is a new claim
+    wearing the authority of an old one."""
+    text = _readable(_doc("docs/evolution-plan.md"))
+    assert plans.CONSTITUTION, "the scan found no lines -- it would pass against any page"
+    for line in plans.CONSTITUTION:
+        assert _quotes(line.text, text), (
+            f"constitution line not quoted from the start of a statement: {line.text!r}"
+        )
+
+
+def test_the_constitution_here_is_the_WHOLE_constitution() -> None:
+    """Eight lines, and a page that quoted seven would be choosing which of the project's own
+    commitments to show a reader -- on the page whose entire subject is what the project promises.
+    Read out of the document rather than counted against a literal, so adding a ninth line to the
+    constitution fails this until the page carries it."""
+    text = _doc("docs/evolution-plan.md")
+    heading = re.search(r"^#+ [\d.]* ?The constitution.*$", text, re.MULTILINE)
+    assert heading is not None, (
+        "the evolution plan has no 'The constitution' heading -- this test cannot find the "
+        "section it is counting, which is a failure to report and not one to crash on"
+    )
+    section = text[heading.end() :].split("\n## ")[0]
+    # `^\d+\. ` at the START of a line, anchored. The first cut filtered on "first character is a
+    # digit", which counted a nested sub-list item and a prose line beginning with a year as
+    # constitution lines -- three innocent reformats of the document turned into build failures
+    # that said the constitution had grown.
+    numbered = re.findall(r"^\d+\. ", section, re.MULTILINE)
+    assert numbered, "found no numbered lines in the constitution section"
+    assert len(numbered) == len(plans.CONSTITUTION), (
+        f"the constitution has {len(numbered)} lines and this page carries "
+        f"{len(plans.CONSTITUTION)}"
+    )
+
+
+def test_every_tier_is_quoted_from_the_phase_f_table() -> None:
+    """Price and promise both. A page that restated `$14/mo` as "about fifteen dollars" would be
+    a friendlier number than the one the project committed to."""
+    text = _readable(_doc("docs/evolution-plan.md"))
+    assert plans.TIERS
+    for tier in plans.TIERS:
+        # ALL FOUR CELLS. `buys` is the longest string on the page and a whole
+        # table column, and the first cut of this test checked name, price and
+        # promise only -- so a contributor could add "early access to new rule
+        # families" to a tier, render it with a citation beside it, and pass
+        # every gate.
+        for cell in (tier.name, tier.price, tier.buys, tier.promise):
+            assert _quotes(cell, text), (
+                f"tier cell not quoted from the start of a statement: {cell!r}"
+            )
+
+
+def test_every_trigger_is_quoted_from_the_decision_record() -> None:
+    """ADR 0004 says the four triggers are the complete set and that a new trigger is a new
+    decision record. The page may not grow a fifth."""
+    text = _readable(_doc("docs/decisions/0004-monetisation-not-now.md"))
+    assert len(plans.TRIGGERS) == 4
+    for trigger in plans.TRIGGERS:
+        assert _quotes(trigger.text, text), (
+            f"trigger not quoted from the start of its cell: {trigger.text!r}"
+        )
+
+
+def test_every_refusal_is_quoted_from_a_named_document() -> None:
+    """The "never paywalled" list is the load-bearing half of this page, and it is the half a
+    later contributor would be most tempted to soften."""
+    assert plans.NEVER_PAYWALLED
+    for refusal in plans.NEVER_PAYWALLED:
+        assert _quotes(refusal.text, _readable(_doc(refusal.source))), (
+            f"refusal not quoted from the start of a statement in {refusal.source}: "
+            f"{refusal.text!r}"
+        )
+
+
+def test_every_claim_names_a_file_that_exists() -> None:
+    """A citation to a document that is not there is worse than none: it looks checkable."""
+    sources = {claim.source for claim in plans.every_claim()}
+    assert sources
+    for source in sources:
+        assert (_ROOT / source).is_file(), f"cited document is missing: {source}"
+
+
+# -- the refusals ---------------------------------------------------------------------------------
+
+
+def test_nothing_on_this_page_is_for_sale_today() -> None:
+    """ADR 0004's answer is "not now", and no trigger has fired. A tier rendered as available
+    would be this page announcing a product that does not exist."""
+    assert all(not tier.shipped for tier in plans.TIERS)
+    report = plans.gather_plans()
+    assert report.anything_for_sale is False
+
+
+def test_no_tier_carries_a_price_a_reader_could_act_on() -> None:
+    """No link, no address, no instruction. The prices are here as a published intention, and a
+    page that told a reader how to pay one would have shipped the tier."""
+    from tests.web.test_client_assets import _PURCHASE_AFFORDANCES
+
+    # The SAME list the payload test uses. Two lists drift, and the first cut had exactly that:
+    # six generic e-commerce words here and six different ones there, neither a superset of the
+    # other, and a `bitcoin:` URI -- the rail ADR 0004 actually names -- invisible to both.
+    #
+    # This is the second belt. The first is `test_every_tier_is_quoted_from_the_phase_f_table`
+    # above: every cell of every row has to appear verbatim in the evolution plan, so an injected
+    # call to action fails traceability without anyone having had to think of its wording.
+    for tier in plans.TIERS:
+        blob = " ".join((tier.name, tier.price, tier.buys, tier.promise)).lower()
+        for affordance in _PURCHASE_AFFORDANCES:
+            assert affordance not in blob, f"{tier.name} carries an affordance: {affordance}"
+
+
+def test_the_page_says_what_would_have_to_happen_first() -> None:
+    """The difference between a transparency artifact and a coming-soon page. A reader learns the
+    condition, and the condition is about users rather than revenue."""
+    assert plans.TRIGGER_FRAMING_SOURCE
+    text = _doc(plans.TRIGGER_FRAMING_SOURCE)
+    assert plans.TRIGGER_FRAMING in text
+
+
+def test_the_free_tier_is_the_one_that_exists() -> None:
+    """Every other row is conditional; this one is what the reader is running. The page must not
+    present the four as four choices."""
+    (free,) = [tier for tier in plans.TIERS if tier.available_now]
+    assert "Free" in free.name
+    assert free.price.startswith("$0")
+
+
+def test_the_for_sale_sentence_is_read_from_the_table_not_asserted_beside_it() -> None:
+    """The day a tier ships, the page must stop saying nothing is for sale -- and it must do so
+    because the TABLE changed, not because someone remembered to edit a sentence too.
+
+    A constant here would let the two disagree, and the direction they would disagree in is the
+    one that matters: a shipped product under a headline saying there is nothing to buy.
+    """
+    from dataclasses import replace
+
+    report = plans.gather_plans()
+    assert report.anything_for_sale is False
+
+    shipped = replace(report, tiers=(replace(report.tiers[1], shipped=True), *report.tiers[2:]))
+    assert shipped.anything_for_sale is True
+
+
+def test_a_shipped_tier_changes_what_the_page_says(monkeypatch) -> None:
+    """End to end through the payload, because the sentence is what a reader sees. The `on`
+    wording is a WARNING rather than an announcement: a page still describing itself as a
+    transparency artifact while a tier is live is out of date, and that is the honest reading."""
+    from dataclasses import replace
+
+    from keel.web import payload
+
+    report = plans.gather_plans()
+    shipped = replace(report, tiers=(replace(report.tiers[1], shipped=True), *report.tiers[2:]))
+
+    assert payload.plans_payload(report)["for_sale"]["value"] == "false"
+    body = payload.plans_payload(shipped)["for_sale"]
+    assert body["value"] == "true"
+    assert body["state"] == "warn"
+
+
+def test_a_quote_that_starts_mid_sentence_is_refused() -> None:
+    """The mechanism, demonstrated on the exact case that motivated it.
+
+    ADR 0004 says "None of these four reopens affiliate links (rule 2, above)". The tail of that
+    sentence, quoted alone under "What no tier will ever gate", says the opposite of the record --
+    and it is a contiguous substring, so a plain `in` accepts it.
+    """
+    record = _doc(plans.DECISION_RECORD)
+    assert "reopens affiliate links" in record, "the premise: it IS a substring"
+    assert not _quotes("reopens affiliate links", record)
+    assert _quotes("None of these four reopens affiliate links", record)
+
+
+def test_a_quote_may_span_the_documents_line_wrapping() -> None:
+    """These documents wrap at 100 columns, and a quoted sentence should not have to reproduce
+    where the wrapping fell -- only what the sentence says."""
+    record = _doc(plans.DECISION_RECORD)
+    wrapped = (
+        "Affiliate or referral links to any trading venue, broker, or exchange are never added "
+        "to keel, its documentation, or its site"
+    )
+    assert wrapped not in record, "the premise: the raw document breaks this line"
+    assert _quotes(wrapped, _readable(record)) or _quotes(wrapped, record)
+
+
+def test_every_string_the_page_shows_is_traced_by_something() -> None:
+    """The coverage question, asked of the payload rather than of the tables.
+
+    `every_claim` is what the traceability tests iterate, and the first cut of it omitted
+    `Tier.buys` -- a whole table column, and the longest string on the page. This compares what
+    the wire actually carries against what is traced, so the next omission fails here rather than
+    waiting for someone to notice a column nobody checks.
+
+    The sentences this codebase WRITES -- status notes, the nothing-for-sale line -- are named
+    exemptions: they describe the page's own state rather than quoting a document, and there is
+    nothing for them to trace to.
+    """
+    from keel.web import payload
+
+    traced = {" ".join(claim.text.split()) for claim in plans.every_claim()}
+    body = payload.plans_payload(plans.gather_plans())
+
+    shown: set[str] = set()
+    for claim in [*body["constitution"], *body["never_paywalled"], body["trigger_framing"]]:
+        shown.add(" ".join(str(claim["text"]).split()))
+    for tier in body["tiers"]:
+        for key in ("name", "price", "buys", "promise"):
+            shown.add(" ".join(str(tier[key]).split()))
+    for trigger in body["triggers"]:
+        shown.add(" ".join(str(trigger["text"]).split()))
+
+    assert shown <= traced, f"shown on the page and traced by nothing: {sorted(shown - traced)}"
+
+
+def _table_rows(document: str, header: str) -> list[list[str]]:
+    """The cells of every row of the markdown table whose header row contains `header`."""
+    rows: list[list[str]] = []
+    seen_header = False
+    for line in _readable(document).splitlines():
+        stripped = line.strip()
+        if not stripped.startswith("|"):
+            seen_header = False
+            continue
+        cells = [cell.strip() for cell in stripped.strip("|").split("|")]
+        if header in cells:
+            seen_header = True
+            continue
+        if seen_header and not set("".join(cells)) <= set("-: "):
+            rows.append(cells)
+    return rows
+
+
+def test_each_trigger_is_the_WHOLE_firing_condition_not_a_prefix_of_it() -> None:
+    """Anchoring a quote to the start of a statement stops it beginning mid-sentence. It does not
+    stop it ENDING early, and for a trigger that is the dangerous half.
+
+    ADR 0004's trigger 3 reads "...ask for something that costs real money to run on their behalf
+    — hosted infra, ... — not a feature request, a request to pay for upkeep". Cut at "on their
+    behalf", it fires on any feature request, which is strictly more of the world than the record
+    says. The page would then be publishing an easier promise than the one that was made.
+
+    So the firing condition is compared WHOLE, against the record's own "What fires it" cell.
+    """
+    rows = _table_rows(_doc(plans.DECISION_RECORD), "What fires it")
+    assert len(rows) == 4, f"ADR 0004's trigger table has {len(rows)} rows"
+
+    recorded = {int(cells[0]): " ".join(cells[1].split()) for cells in rows}
+    for trigger in plans.TRIGGERS:
+        assert " ".join(trigger.text.split()) == recorded[trigger.number], (
+            f"trigger {trigger.number} is not the record's whole firing condition"
+        )
+
+
+def test_the_constitution_counter_ignores_a_nested_sub_list() -> None:
+    """The parser's own regression. "First character is a digit" counted a nested sub-point and a
+    prose line beginning with a year as constitution lines, so three innocent reformats of the
+    document became build failures claiming the constitution had grown."""
+    import re as _re
+
+    # Three numbered lines, plus the two shapes the old predicate miscounted: a nested sub-point
+    # that happens to be numbered, and a prose line beginning with a date. Both satisfy "first
+    # character is a digit" and one of them satisfies ". " as well.
+    section = (
+        "1. One.\n"
+        "2. Two.\n"
+        "   1. a numbered sub-point\n"
+        "2026-08-31 note. Every Jesse mechanic adopted passed a line here.\n"
+        "3. Three.\n"
+    )
+    assert len(_re.findall(r"^\d+\. ", section, _re.MULTILINE)) == 3
+
+    loose = [
+        line
+        for raw in section.splitlines()
+        if (line := raw.strip()) and line[0].isdigit() and ". " in line
+    ]
+    assert len(loose) == 5, "the premise: the old predicate counted five"
diff --git a/tests/web/test_api.py b/tests/web/test_api.py
index 1cbffc2..3c6d363 100644
--- a/tests/web/test_api.py
+++ b/tests/web/test_api.py
@@ -69,6 +69,7 @@
     "/api/rules",
     "/api/venues",
     "/api/gates",
+    "/api/plans",
 )
 
 
@@ -742,7 +743,11 @@ def test_a_stopped_engine_still_answers_the_endpoints_that_describe_the_binary(
     about (200 with data, nothing required to exist first) still holds. All three still report
     `engine`, because a client showing the "keel isn't running" banner should not have to fetch a
     different endpoint to know whether to show it."""
-    for path in ("/api/config", "/api/venues", "/api/gates"):
+    # `/api/plans` (#706) joins them and is the purest case: its subject is the PROJECT rather
+    # than the deployment, so it reads no repository at all -- and a page explaining that keel is
+    # free and runs on the operator's own hardware would be a strange one to gate behind having
+    # already installed it.
+    for path in ("/api/config", "/api/venues", "/api/gates", "/api/plans"):
         status, _headers, document = _json(empty_machine, path)
 
         assert status == 200, path
@@ -850,7 +855,7 @@ def test_setup_carries_the_csrf_token_and_only_setup_does(
     _status, _headers, document = _json(empty_machine, "/api/setup")
     assert document["data"]["csrf"] == csrf_token(empty_machine.token)
 
-    for path in ("/api/config", "/api/status", "/api/venues", "/api/gates"):
+    for path in ("/api/config", "/api/status", "/api/venues", "/api/gates", "/api/plans"):
         _status, _headers, other = _json(empty_machine, path)
         assert csrf_token(empty_machine.token) not in json.dumps(other), path
 
diff --git a/tests/web/test_client_assets.py b/tests/web/test_client_assets.py
index e71838e..02c3c27 100644
--- a/tests/web/test_client_assets.py
+++ b/tests/web/test_client_assets.py
@@ -732,8 +732,10 @@ def test_the_python_and_javascript_route_tables_agree() -> None:
 def test_the_route_table_parser_actually_found_something() -> None:
     """The premise for the test above: an empty parse compared to an empty tuple is green.
 
-    `CLIENT_ROUTES` has seven entries today, and the assertion is on a floor rather than on the
-    exact number so that #537 adding a view does not have to edit this test to keep it honest."""
+    The assertion is a FLOOR rather than an exact number, so adding a view does not have to edit
+    this test to keep it honest -- which is also why the docstring no longer names a count. It
+    said "seven entries today" while `CLIENT_ROUTES` held thirteen, which is the failure mode of
+    writing a number into prose beside a test that deliberately does not assert one."""
     names = _js_route_names()
     assert len(names) >= 7, f"parsed {names} out of main.js -- the parser has stopped working"
     assert "status" in names
@@ -2021,6 +2023,25 @@ def test_the_clickable_scan_can_actually_see_a_string_literal() -> None:
     assert "form" not in kept, "comments must still be stripped"
 
 
+#: What a display-only renderer may not contain. ONE list, shared by every such test, because two
+#: lists drift: #704's blocked `button` and `href` UNQUOTED and #706's blocked `"button"` quoted
+#: and dropped `href` -- so `el('button', 'cta', 'Buy Pro')` in single quotes, and a `setAttribute`
+#: of `href` on a span, both passed the newer test while failing the older one.
+#:
+#: Unquoted, so a quoting style cannot evade it. `element` and `anchor` are absent deliberately:
+#: `el(...)` is this file's own constructor and every renderer calls it.
+_INTERACTIVE_TOKENS: tuple[str, ...] = (
+    "button",
+    "addEventListener",
+    "onclick",
+    '"a"',
+    "'a'",
+    "href",
+    "form",
+    "input",
+)
+
+
 def test_neither_the_chip_nor_the_banner_builds_anything_clickable() -> None:
     """Display and navigation only, by construction rather than by intent.
 
@@ -2032,7 +2053,7 @@ def test_neither_the_chip_nor_the_banner_builds_anything_clickable() -> None:
     source = _source("render.js")
     for name in ("sessionChip", "paperBanner"):
         body = _function_body(source, name)
-        for forbidden in ("button", "addEventListener", "onclick", '"a"', "href", "form", "input"):
+        for forbidden in _INTERACTIVE_TOKENS:
             assert forbidden not in body, f"{name} builds something interactive: {forbidden}"
 
 
@@ -2175,3 +2196,103 @@ def test_the_journal_section_offers_no_sort_control() -> None:
     body = _function_body(_source("render.js"), "notesSection")
     assert "onSort" not in body
     assert "sort:" not in body
+
+
+# -- the Plans page's refusals (#706) -------------------------------------------------------------
+#
+# The acceptance criterion is "zero interactive purchase affordances", which is a NEGATIVE -- the
+# thing that rots silently. So it is asserted structurally against the parsed function bodies,
+# with string literals KEPT (the earlier lesson: a scan that strips them cannot see `el("a")`).
+
+
+#: Text that would turn a published price into something a reader could act on.
+#:
+#: A SECOND BELT, and it is worth saying which belt is first: every string in the tier table has to
+#: appear verbatim in `docs/evolution-plan.md` (`tests/commands/test_plans.py`), so an injected
+#: call to action fails traceability before it reaches this list. That is the defence that does not
+#: depend on anyone having thought of the wording.
+#:
+#: This list exists for the strings traceability does not cover, and it carries the schemes the
+#: project ACTUALLY chose: ADR 0004 and Phase F both name self-hosted BTCPay, so `bitcoin:` and
+#: `lightning:` URIs are the single most likely real affordance here -- and the first cut of this
+#: list, built from generic e-commerce words, could not see either of them.
+_PURCHASE_AFFORDANCES: tuple[str, ...] = (
+    "http://",
+    "https://",
+    "mailto:",
+    "bitcoin:",
+    "lightning:",
+    "btcpay",
+    "lnbc",
+    "checkout",
+    "subscribe",
+    "upgrade",
+    "purchase",
+    "pay via",
+    "pay with",
+    "get started",
+    "buy ",
+    "order at",
+    "contact sales",
+)
+
+
+def test_the_plans_view_builds_nothing_a_reader_can_click() -> None:
+    """No button, no anchor, no form, no handler.
+
+    A retail Plans page is a funnel by construction: every row exists to move a reader one row
+    down. The inversion is not a matter of gentler wording -- there must be nothing on the page
+    that could take an action, so that the page cannot become a funnel by a later edit that only
+    changes copy.
+    """
+    source = _source("render.js")
+    for name in ("plansView", "claimList", "citation"):
+        body = _function_body(source, name)
+        for forbidden in _INTERACTIVE_TOKENS:
+            assert forbidden not in body, f"{name} builds something interactive: {forbidden}"
+
+
+def test_the_plans_payload_sends_no_destination_to_build_one_from() -> None:
+    """The refusal is structural rather than editorial: `render.js` cannot make a link out of a
+    payload that never sends a URL. Asserted over the SERIALISED payload, so a key added anywhere
+    beneath it is caught too."""
+    from keel.commands.plans import gather_plans
+    from keel.web import payload as payload_mod
+
+    body = json.dumps(payload_mod.plans_payload(gather_plans())).lower()
+    for affordance in _PURCHASE_AFFORDANCES:
+        assert affordance not in body, f"the plans payload carries {affordance}"
+
+
+def test_the_plans_view_cites_a_path_and_never_links_to_one() -> None:
+    """`keel serve` is a loopback SQLite reader with no document server behind it, so a link to a
+    document would 404 -- and a path a reader can open in their own checkout is the honest form.
+    It is also what keeps this page free of anchors entirely."""
+    body = _function_body(_source("render.js"), "citation")
+    assert '"code"' in body
+    assert "href" not in body
+
+
+def test_the_plans_view_shows_every_section_the_payload_sends() -> None:
+    """A page that quoted the constitution and dropped the refusal list would be a page choosing
+    which of the project's commitments a reader sees -- on the page whose subject is exactly
+    that."""
+    from keel.commands.plans import gather_plans
+    from keel.web import payload as payload_mod
+
+    # DERIVED from the payload, not a list of literals: a section added to the wire and never
+    # rendered would have passed a hardcoded list forever.
+    sections = set(payload_mod.plans_payload(gather_plans()))
+    assert sections, "the scan found no sections -- it would pass against any view"
+
+    body = _function_body(_source("render.js"), "plansView")
+    for key in sorted(sections):
+        assert "data." + key in body, f"/api/plans sends {key}; plansView never renders it"
+
+
+def test_the_plans_table_offers_no_sort_control() -> None:
+    """A tier table ordered by price is a shopping comparison. These four rows are not four
+    choices, and `table()` draws a sort control only when handed a `sort`/`onSort` pair."""
+    body = _function_body(_source("render.js"), "plansView")
+    assert "onSort" not in body
+    assert "sort:" not in body
diff --git a/tests/web/test_payload.py b/tests/web/test_payload.py
index b54b86a..44922d7 100644
--- a/tests/web/test_payload.py
+++ b/tests/web/test_payload.py
@@ -1908,3 +1908,39 @@ def test_a_profitable_self_reported_day_still_warns() -> None:
     body = payload._discretionary_journal_payload(_notes(dollar_impact=Decimal("250")))
     entry = body["entries"][0]
     assert entry["dollar_impact"]["state"] == "warn"
+
+
+def test_a_shipped_tier_reads_as_something_that_exists() -> None:
+    """#706. The state comes off the STATUS WORD, not off `available_now`.
+
+    The first cut read `GOOD if tier.available_now else UNKNOWN`, so the day a Pro tier shipped,
+    the one row that had become real would have worn the same "not a thing yet" badge as the three
+    that had not -- while the docstring beside it asserted every other row is unknown because it is
+    "simply not a thing yet". `running` and `shipped` are both things that EXIST; the difference
+    between them is price, not reality.
+    """
+    from dataclasses import replace
+
+    from keel.commands.plans import gather_plans
+
+    report = gather_plans()
+    shipped = replace(report, tiers=tuple(replace(t, shipped=True) for t in report.tiers))
+    statuses = {
+        row["status"]["value"]: row["status"] for row in payload.plans_payload(shipped)["tiers"]
+    }
+
+    assert set(statuses) == {"shipped"}
+    assert statuses["shipped"]["state"] == "good"
+    # And a sentence, not the word again: this is the one status a future PR will actually set.
+    assert statuses["shipped"]["display"] != "shipped"
+
+
+def test_a_planned_tier_is_unknown_and_never_a_warning() -> None:
+    """There is no product to caution anyone about. `WARN` would read as a caveat on something a
+    reader might buy."""
+    from keel.commands.plans import gather_plans
+
+    rows = payload.plans_payload(gather_plans())["tiers"]
+    planned = [row["status"] for row in rows if row["status"]["value"] == "planned"]
+    assert len(planned) == 3
+    assert {status["state"] for status in planned} == {"unknown"}