Skip to content

Open-source platform for 3D AI agents. Turn text or a photo into a rigged, animated GLB avatar, give it an LLM brain, memory and a wallet, and embed it anywhere with one web component. Remote MCP server, x402 payments, Three.js, browser-native.

fix(three): stop the tier cards listing unbuilt perks as delivered benefits

ni3a596a14c78376
diff --git a/CHANGELOG.md b/CHANGELOG.md
index 4932234fa..ba7171250 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -25,6 +25,7 @@ Public history for [three.ws](https://three.ws), newest first. New pages come fr
- **Put any token's 3D scene on your own site, keyed by the pair address you already have**: Token in 3D is now embeddable anywhere with a single iframe, and it accepts two identifiers instead of one. Chart terminals, launchpads and wallets name a market by its pair (pool) address, while three.ws keys tokens by mint, so /coin3d now takes ?pair= as well as ?mint= and resolves the rest itself through a new public endpoint, /api/coin/pair. Add ?embed=1 and the scene drops the chrome your own page owns, keeps one attribution link, and sends its links to a new tab instead of navigating your frame. Free, keyless, and no account: paste the iframe and it renders the live medallion, holder galaxy, graduation ring and real trade tape for that market. (`/docs/coin3d-embed`) `[feature, sdk]`
- **Queued posts can quote an earlier post**: A post in the @trythreews content queue can now name an earlier post to quote, so a follow-up can add the detail the original left out instead of repeating it. The first use quotes the $THREE token MCP announcement with the numbers behind the MCP Tool Catalog: 321 tools across 42 servers, 293 of them free, and 215 whose read-only label is checked against the source on every build. (`/mcp-tools`) `[improvement]`
- **The @trythreews account now posts three times a day, every day**: The reviewed content queue that runs the @trythreews account moved to three posts a day, eight hours apart, on every day of the week including weekends. It used to hold its flagship slot for weekdays and pack all three posts into an eight-hour afternoon window, which meant a weekend could only ever carry two. Three posts went out under the new cadence today: the $THREE token MCP server, Forge Max, and the free object library. The Forge Max post also gained a check that proves the high-quality tier is a real, gated lane before it can be published, rather than only proving its page loads. (`/changelog`) `[improvement]`
+- **The $THREE tier cards no longer list unbuilt perks next to real ones**: Each tier on the holder page carries two kinds of line: things the hold turns on today, and things that are registered but not built yet. Further down the same card the unbuilt ones were already flagged Planned, but higher up they also appeared as plain bullets with no flag, so Silver read as though private worlds and priority routing were included and Gold as though branded environments were. They are not. The two lists are now kept apart at the source, the planned lines carry the Planned flag wherever they appear, and the pricing API publishes them as a separate field so anything reading it automatically cannot mistake a roadmap line for a benefit. Nothing about what you actually get has changed. A test now fails the build if an unbuilt feature finds its way back into the delivered list. (`/three`) `[fix, improvement]`
- **The flagship post slot now gets flagship material**: The @trythreews account publishes into three slots a day, one owned by each tier: proof of work at 04:00 UTC, a shipped feature at 12:00, a flagship at 20:00. The machine that drafts announcements from the backlog was not filling them that way. It never recorded a tier on anything it wrote, so every draft it produced was treated as a mid-tier feature and the 20:00 slot was left to whatever happened to be ready. It also dated the surfaces that need owner sign-off on their imagery into the best slot of every day, which pushed everything it could publish on its own weeks into the future. Announcements are now planned into the slot their own tier owns, the ones awaiting sign-off are listed separately instead of blocking the calendar, and six new announcements are queued for review. (`/changelog`) `[improvement]`
- **Two Uniswap v4 hooks: wearable 3D items as coins, and fees that reward agent reputation**: New open-source contracts. SkinHook turns a wearable 3D item into a fixed-supply coin with its own pool: wearing it locks one token, so every wearer shrinks the tradable supply, and the creator's royalty is taken inside the swap where it cannot be skipped, with a share for the site that referred the sale. AgentTierHook gives ERC-8004 agents a lower trading fee as their on-chain reputation grows, with liquidity providers keeping every fee. Both are tested against the real Uniswap v4 contracts and are not deployed yet. `[feature, sdk]`
diff --git a/api/_lib/three-tier.js b/api/_lib/three-tier.js
index 58c20c2e4..8b559f902 100644
--- a/api/_lib/three-tier.js
+++ b/api/_lib/three-tier.js
@@ -21,8 +21,17 @@ import { TOKEN_MINT } from './token/config.js';
// ── Tier ladder ─────────────────────────────────────────────────────────────────
// Ordered low→high. `minUsd` is the USD value of $THREE held to reach the tier.
// `discountBps` is the fee discount on fixed-price compute. `rateMultiplier`
-// scales free quotas. Thresholds/curve are tunable knobs (see plan) — starting
-// points chosen so the entry tier is reachable and the top tier is aspirational.
+// scales free quotas.
+//
+// `perks` lists ONLY what a holder gets today. Anything registered but not yet
+// enforced belongs in `planned`, never in `perks`: a tier that lists an unbuilt
+// feature as a flat benefit is a roadmap wearing a price tag, and every surface
+// that renders the ladder (/three, GET /api/pricing, GET /api/three/tier) would
+// repeat that promise unqualified. When a gate ships, flip its `enforced` in
+// three-access.js and move its line from `planned` to `perks` in the same change.
+//
+// Thresholds/curve are tunable knobs (see plan): starting points chosen so the
+// entry tier is reachable and the top tier is aspirational.
export const TIERS = Object.freeze([
Object.freeze({
level: 0,
@@ -32,6 +41,7 @@ export const TIERS = Object.freeze([
discountBps: 0,
rateMultiplier: 1,
perks: Object.freeze(['Everything free-forever: create, discover, embed, social, basic worlds']),
+ planned: Object.freeze([]),
}),
Object.freeze({
level: 1,
@@ -41,6 +51,7 @@ export const TIERS = Object.freeze([
discountBps: 500, // 5% off compute
rateMultiplier: 2,
perks: Object.freeze(['5% off all $THREE compute', '2× free generation quota', 'Bronze profile badge']),
+ planned: Object.freeze([]),
}),
Object.freeze({
level: 2,
@@ -49,12 +60,8 @@ export const TIERS = Object.freeze([
minUsd: 100,
discountBps: 1000, // 10%
rateMultiplier: 3,
- perks: Object.freeze([
- '10% off all $THREE compute',
- '3× free generation quota',
- 'Private worlds',
- 'Priority MCP routing',
- ]),
+ perks: Object.freeze(['10% off all $THREE compute', '3× free generation quota']),
+ planned: Object.freeze(['Private worlds', 'Priority MCP routing']),
}),
Object.freeze({
level: 3,
@@ -63,12 +70,8 @@ export const TIERS = Object.freeze([
minUsd: 500,
discountBps: 2000, // 20%
rateMultiplier: 5,
- perks: Object.freeze([
- '20% off all $THREE compute',
- '5× free generation quota',
- 'Branded worlds + custom environments',
- 'Early access to drops',
- ]),
+ perks: Object.freeze(['20% off all $THREE compute', '5× free generation quota']),
+ planned: Object.freeze(['Branded worlds + custom environments', 'Early access to drops']),
}),
Object.freeze({
level: 4,
@@ -77,12 +80,8 @@ export const TIERS = Object.freeze([
minUsd: 2500,
discountBps: 3000, // 30%
rateMultiplier: 10,
- perks: Object.freeze([
- '30% off all $THREE compute',
- '10× free generation quota',
- 'First dibs on rare names + collectibles',
- 'Genesis-only cosmetics',
- ]),
+ perks: Object.freeze(['30% off all $THREE compute', '10× free generation quota']),
+ planned: Object.freeze(['First dibs on rare names + collectibles', 'Genesis-only cosmetics']),
}),
]);
diff --git a/api/pricing.js b/api/pricing.js
index c919179a1..84541be70 100644
--- a/api/pricing.js
+++ b/api/pricing.js
@@ -30,7 +30,10 @@ function tierLadder() {
discount_bps: t.discountBps,
discount_percent: (t.discountBps / 100).toFixed(t.discountBps % 100 === 0 ? 0 : 1),
rate_multiplier: t.rateMultiplier,
+ // Delivered today vs registered-but-unenforced. Kept apart so a machine
+ // reading this endpoint cannot mistake a roadmap line for a benefit.
perks: t.perks,
+ planned: t.planned ?? [],
}));
}
@@ -82,7 +85,14 @@ export default wrap(async (req, res) => {
const { tier, usd, next } = await resolveUserTier(user);
const nt = next ?? nextTier(tier);
holder = {
- tier: { level: tier.level, id: tier.id, label: tier.label, discount_bps: tier.discountBps, perks: tier.perks },
+ tier: {
+ level: tier.level,
+ id: tier.id,
+ label: tier.label,
+ discount_bps: tier.discountBps,
+ perks: tier.perks,
+ planned: tier.planned ?? [],
+ },
usd_held: Math.round((Number(usd) || 0) * 100) / 100,
discount_bps: tier.discountBps,
discount_percent: (tier.discountBps / 100).toFixed(tier.discountBps % 100 === 0 ? 0 : 1),
diff --git a/api/three/[action].js b/api/three/[action].js
index 557bbe439..9766633f1 100644
--- a/api/three/[action].js
+++ b/api/three/[action].js
@@ -70,6 +70,7 @@ function tierPayload({ tier, usd, amount, priceUsd, next, wallet = null, source
label: tier.label,
discount_bps: tier.discountBps,
perks: tier.perks,
+ planned: tier.planned ?? [],
},
held_usd: usd,
held_amount: amount,
@@ -88,6 +89,7 @@ function tierPayload({ tier, usd, amount, priceUsd, next, wallet = null, source
discount_bps: t.discountBps,
rate_multiplier: t.rateMultiplier,
perks: t.perks,
+ planned: t.planned ?? [],
})),
};
}
diff --git a/data/changelog.json b/data/changelog.json
index 0724b504f..d8535f067 100644
--- a/data/changelog.json
+++ b/data/changelog.json
@@ -28557,6 +28557,16 @@
"improvement"
],
"link": "/three"
+ },
+ {
+ "date": "2026-09-20",
+ "title": "The $THREE tier cards no longer list unbuilt perks next to real ones",
+ "summary": "Each tier on the holder page carries two kinds of line: things the hold turns on today, and things that are registered but not built yet. Further down the same card the unbuilt ones were already flagged Planned, but higher up they also appeared as plain bullets with no flag, so Silver read as though private worlds and priority routing were included and Gold as though branded environments were. They are not. The two lists are now kept apart at the source, the planned lines carry the Planned flag wherever they appear, and the pricing API publishes them as a separate field so anything reading it automatically cannot mistake a roadmap line for a benefit. Nothing about what you actually get has changed. A test now fails the build if an unbuilt feature finds its way back into the delivered list.",
+ "tags": [
+ "fix",
+ "improvement"
+ ],
+ "link": "/three"
}
]
}
diff --git a/docs/hold-to-access.md b/docs/hold-to-access.md
index 7dd7494ba..db7f1a7d5 100644
--- a/docs/hold-to-access.md
+++ b/docs/hold-to-access.md
@@ -149,6 +149,17 @@ in the product** — a request for it is actually checked. `false` means the per
registered/planned but not enforced anywhere. The `/three` page reads this flag to mark a
feature **Live** vs **Planned**, so the platform never promises an unwired perk.
+The same honesty applies to the prose perk lines on each tier card. `TIERS` carries two
+lists: **`perks`** is what the hold buys today, and **`planned`** is what is registered
+but not enforced yet. Every surface that renders the ladder (`/three`,
+`GET /api/pricing`, `GET /api/three/tier`) serves both, and `/three` draws the `planned`
+lines with the same Planned flag as the gated-feature rows. Keeping them in one list is
+how an unbuilt feature ends up reading as a benefit, so when a gate ships, flip its
+`enforced` here and move its line from `planned` to `perks` in the same change.
+`tests/three-tier-honesty.test.js` fails if an unenforced feature's label reappears in a
+`perks` list, and `npm run verify:three-gate` checks the same thing against the live
+`/api/pricing` payload.
+
| Feature | Min tier | Status | Pay-per-use | Backend |
|---------|----------|--------|-------------|---------|
| `forge.high` — High-quality generation (200k poly + PBR) | Bronze | **Live** | yes | [`api/forge.js`](../api/forge.js) |
diff --git a/public/changelog-recent.json b/public/changelog-recent.json
index 8f48f556e..1eedd244f 100644
--- a/public/changelog-recent.json
+++ b/public/changelog-recent.json
@@ -1,11 +1,11 @@
{
- "generated_at": "2026-09-20T19:41:27.892Z",
+ "generated_at": "2026-09-20T19:56:28.901Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
"url": "https://three.ws"
},
- "total": 3732,
+ "total": 3733,
"complete": false,
"full_feed": "/changelog.json",
"entries": [
@@ -209,6 +209,17 @@
"improvement"
]
},
+ {
+ "date": "2026-09-20",
+ "type": "update",
+ "title": "The $THREE tier cards no longer list unbuilt perks next to real ones",
+ "summary": "Each tier on the holder page carries two kinds of line: things the hold turns on today, and things that are registered but not built yet. Further down the same card the unbuilt ones were already flagged Planned, but higher up they also appeared as plain bullets with no flag, so Silver read as though private worlds and priority routing were included and Gold as though branded environments were. They are not. The two lists are now kept apart at the source, the planned lines carry the Planned flag wherever they appear, and the pricing API publishes them as a separate field so anything reading it automatically cannot mistake a roadmap line for a benefit. Nothing about what you actually get has changed. A test now fails the build if an unbuilt feature finds its way back into the delivered list.",
+ "link": "/three",
+ "tags": [
+ "fix",
+ "improvement"
+ ]
+ },
{
"date": "2026-09-20",
"type": "update",
@@ -1608,17 +1619,6 @@
"fix",
"infra"
]
- },
- {
- "date": "2026-09-09",
- "type": "update",
- "title": "Three fades now stop when you ask the site to stop moving",
- "summary": "Turn on reduced motion in your operating system and three.ws is supposed to hold still: every animation timing on the site is named rather than spelled out, so one switch can zero all of them at once. Three places had drifted off that and spelled their own timing instead, which meant the object library card fade, the avatar picker chips and the Money Pulse rows kept animating for people who had explicitly asked them not to. One of them was pointing at a timing name that does not exist, so the value it fell back to was never the one anyone chose. All three are back on the named ladder at the same speed they always looked, and the reduced-motion switch reaches them again.",
- "link": "/objects",
- "tags": [
- "fix",
- "improvement"
- ]
}
]
}
diff --git a/public/changelog.json b/public/changelog.json
index a470804fc..51b664d06 100644
--- a/public/changelog.json
+++ b/public/changelog.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-09-20T19:41:27.867Z",
+ "generated_at": "2026-09-20T19:56:28.610Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json + data/changelog.json",
"site": {
"name": "three.ws",
@@ -206,6 +206,17 @@
"improvement"
]
},
+ {
+ "date": "2026-09-20",
+ "type": "update",
+ "title": "The $THREE tier cards no longer list unbuilt perks next to real ones",
+ "summary": "Each tier on the holder page carries two kinds of line: things the hold turns on today, and things that are registered but not built yet. Further down the same card the unbuilt ones were already flagged Planned, but higher up they also appeared as plain bullets with no flag, so Silver read as though private worlds and priority routing were included and Gold as though branded environments were. They are not. The two lists are now kept apart at the source, the planned lines carry the Planned flag wherever they appear, and the pricing API publishes them as a separate field so anything reading it automatically cannot mistake a roadmap line for a benefit. Nothing about what you actually get has changed. A test now fails the build if an unbuilt feature finds its way back into the delivered list.",
+ "link": "/three",
+ "tags": [
+ "fix",
+ "improvement"
+ ]
+ },
{
"date": "2026-09-20",
"type": "update",
diff --git a/public/changelog.xml b/public/changelog.xml
index 138208f35..143bca169 100644
--- a/public/changelog.xml
+++ b/public/changelog.xml
@@ -158,6 +158,14 @@
<category>improvement</category>
<description>The reviewed content queue that runs the @trythreews account moved to three posts a day, eight hours apart, on every day of the week including weekends. It used to hold its flagship slot for weekdays and pack all three posts into an eight-hour afternoon window, which meant a weekend could only ever carry two. Three posts went out under the new cadence today: the $THREE token MCP server, Forge Max, and the free object library. The Forge Max post also gained a check that proves the high-quality tier is a real, gated lane before it can be published, rather than only proving its page loads.</description>
</item>
+ <item>
+ <title>The $THREE tier cards no longer list unbuilt perks next to real ones</title>
+ <link>https://three.ws/three</link>
+ <guid isPermaLink="false">2026-09-20:The $THREE tier cards no longer list unbuilt perks next to real ones</guid>
+ <pubDate>Sun, 20 Sep 2026 12:00:00 GMT</pubDate>
+ <category>fix</category>
+ <description>Each tier on the holder page carries two kinds of line: things the hold turns on today, and things that are registered but not built yet. Further down the same card the unbuilt ones were already flagged Planned, but higher up they also appeared as plain bullets with no flag, so Silver read as though private worlds and priority routing were included and Gold as though branded environments were. They are not. The two lists are now kept apart at the source, the planned lines carry the Planned flag wherever they appear, and the pricing API publishes them as a separate field so anything reading it automatically cannot mistake a roadmap line for a benefit. Nothing about what you actually get has changed. A test now fails the build if an unbuilt feature finds its way back into the delivered list.</description>
+ </item>
<item>
<title>The flagship post slot now gets flagship material</title>
<link>https://three.ws/changelog</link>
diff --git a/public/features.json b/public/features.json
index f1ff3f934..6e915428e 100644
--- a/public/features.json
+++ b/public/features.json
@@ -1,5 +1,5 @@
{
- "generated_at": "2026-09-20T19:41:27.855Z",
+ "generated_at": "2026-09-20T19:56:28.508Z",
"generated_by": "scripts/build-page-index.mjs from data/pages.json",
"site": {
"name": "three.ws",
diff --git a/scripts/verify-three-gate.mjs b/scripts/verify-three-gate.mjs
index a26067079..086a53910 100644
--- a/scripts/verify-three-gate.mjs
+++ b/scripts/verify-three-gate.mjs
@@ -189,6 +189,27 @@ async function checkHonesty() {
}
const planned = features.filter((f) => !f.enforced).map((f) => f.feature);
check('planned features are flagged, not sold as live', planned.length === features.length - LIVE_GATES.length, planned.join(', ') || 'none');
+
+ // The tier cards render `perks` flat, with no flag, so an unbuilt line sitting
+ // in `perks` instead of `planned` reads as a delivered benefit on /three and to
+ // anything parsing /api/pricing. Check the published ladder keeps them apart.
+ const { body: pricing } = await getJson(`${BASE}/api/pricing`);
+ const ladder = pricing?.three_tiers ?? pricing?.tiers ?? [];
+ check('pricing ladder served', ladder.length > 0, `${ladder.length} tiers`);
+ const plannedLabels = new Set(
+ features.filter((f) => !f.enforced).map((f) => f.label.toLowerCase()),
+ );
+ for (const t of ladder) {
+ const perks = t.perks ?? [];
+ // The key must be PRESENT, not merely defaultable: a ladder served without
+ // it is one where perks and roadmap are still the same list.
+ check(`${t.id} exposes a planned list`, Object.prototype.hasOwnProperty.call(t, 'planned'));
+ const leaked = perks.filter((p) => {
+ const needle = String(p).toLowerCase();
+ return [...plannedLabels].some((l) => l.includes(needle) || needle.includes(l));
+ });
+ check(`${t.id} perks promise nothing unbuilt`, leaked.length === 0, leaked.join(', ') || `${perks.length} delivered perks`);
+ }
}
async function main() {
diff --git a/src/three-tier-page.js b/src/three-tier-page.js
index 601857eb1..1ca8c19aa 100644
--- a/src/three-tier-page.js
+++ b/src/three-tier-page.js
@@ -224,9 +224,24 @@ function renderTier(t, { currentLevel, heldUsd, featuresByLevel }) {
? ''
: `<span class="tt-status tt-status--togo">${fmtUsd(toGo, toGo < 1 ? 2 : 0)} to go</span>`;
- const perks = (t.perks || [])
- .map((p) => `<li class="tt-perk"><span class="tt-perk-tick" aria-hidden="true">✦</span><span class="tt-perk-text">${esc(p)}</span></li>`)
- .join('');
+ // Delivered perks render plain; anything the ladder still lists as `planned`
+ // renders with the same Planned flag the gated-feature rows use, so a tier card
+ // never presents an unbuilt benefit as something the hold buys today.
+ const perks =
+ (t.perks || [])
+ .map(
+ (p) =>
+ `<li class="tt-perk"><span class="tt-perk-tick" aria-hidden="true">✦</span><span class="tt-perk-text">${esc(p)}</span></li>`,
+ )
+ .join('') +
+ (t.planned || [])
+ .map(
+ (p) =>
+ `<li class="tt-perk tt-perk--soon"><span class="tt-perk-tick" aria-hidden="true">✦</span>` +
+ `<span class="tt-perk-text">${esc(p)}</span>` +
+ `<span class="tt-flag tt-flag--soon">Planned</span></li>`,
+ )
+ .join('');
// Concrete gated features that unlock at this tier, with Live/Planned honesty
// and a check when the current holder already clears them.
@@ -505,6 +520,9 @@ function injectStyles() {
.tt-perk{display:flex;gap:8px;align-items:flex-start;font-size:13px;line-height:1.45;color:#c7c7d0;}
.tt-perk-text{flex:1;min-width:0;}
.tt-perk-tick{flex-shrink:0;color:#6ee7a8;font-size:11px;line-height:1.5;}
+ .tt-perk--soon{align-items:center;color:#8a8a93;}
+ .tt-perk--soon .tt-perk-tick{color:#4a4a55;}
+ .tt-perk--soon .tt-flag{margin-left:2px;}
.tt-gold .tt-perk-tick{color:#f5c451;}
.tt-silver .tt-perk-tick{color:#cfd6e4;}
.tt-bronze .tt-perk-tick{color:#e0a878;}
diff --git a/tests/three-tier-honesty.test.js b/tests/three-tier-honesty.test.js
new file mode 100644
index 000000000..3c157327c
--- /dev/null
+++ b/tests/three-tier-honesty.test.js
@@ -0,0 +1,65 @@
+// The ladder must never sell an unbuilt perk as a benefit of holding.
+//
+// /three, GET /api/pricing and GET /api/three/tier all render TIERS[].perks
+// verbatim. Before this guard, "Private worlds" and "Priority MCP routing" sat in
+// Silver's perks while their gates were registered with enforced:false, so the
+// page promised them flatly in one list and flagged them Planned two rows down.
+// These assertions keep the two lists honest: anything without a live gate behind
+// it belongs in `planned`, which every surface renders with the Planned flag.
+
+import { describe, it, expect } from 'vitest';
+import { TIERS } from '../api/_lib/three-tier.js';
+import { GATED_FEATURES } from '../api/_lib/three-access.js';
+
+const norm = (s) => String(s).toLowerCase().replace(/[^a-z0-9]+/g, ' ').trim();
+
+describe('$THREE tier ladder honesty', () => {
+ it('gives every tier both lists', () => {
+ for (const t of TIERS) {
+ expect(Array.isArray(t.perks), `${t.id}.perks`).toBe(true);
+ expect(Array.isArray(t.planned), `${t.id}.planned`).toBe(true);
+ expect(t.perks.length, `${t.id} must offer something today`).toBeGreaterThan(0);
+ }
+ });
+
+ it('never lists the same line as both delivered and planned', () => {
+ const delivered = new Set(TIERS.flatMap((t) => t.perks.map(norm)));
+ for (const t of TIERS) {
+ for (const p of t.planned) {
+ expect(delivered.has(norm(p)), `"${p}" is in both perks and planned`).toBe(false);
+ }
+ }
+ });
+
+ it('keeps the label of an unenforced gate out of every perks list', () => {
+ const deliveredWords = TIERS.flatMap((t) => t.perks.map(norm));
+ for (const [id, f] of Object.entries(GATED_FEATURES)) {
+ if (f.enforced) continue;
+ // A perk line that restates an unenforced feature's label (in either
+ // direction, since the perk copy is shorter than the registry label) is
+ // the exact failure this test exists to catch.
+ for (const perk of deliveredWords) {
+ const label = norm(f.label);
+ const overlap = label.includes(perk) || perk.includes(label);
+ expect(overlap, `perk "${perk}" promises unenforced feature ${id}`).toBe(false);
+ }
+ }
+ });
+
+ it('declares planned lines on every tier that has an unenforced gate', () => {
+ for (const t of TIERS) {
+ const unenforcedHere = Object.values(GATED_FEATURES).filter(
+ (f) => f.minLevel === t.level && !f.enforced,
+ );
+ if (unenforcedHere.length === 0) continue;
+ expect(t.planned.length, `${t.id} has unenforced gates but no planned list`).toBeGreaterThan(0);
+ }
+ });
+
+ it('marks the two shipped gates as enforced', () => {
+ expect(GATED_FEATURES['forge.high'].enforced).toBe(true);
+ expect(GATED_FEATURES['forge.gameready'].enforced).toBe(true);
+ expect(GATED_FEATURES['forge.high'].minLevel).toBe(1);
+ expect(GATED_FEATURES['forge.gameready'].minLevel).toBe(1);
+ });
+});