feat(levelcode): Fable 5 and Fable 5.1 at Pro — lead with the frontier

app/services/levelcode/model_catalog.rb

@@ -92,12 +92,28 @@ module ModelCatalog
         input: 5.00, cached_input: 0.50, output: 30.00,
         context: 1_050_000, min_tier: :pro, status: :confirmed
       },
+      # Fable 5.1 is NOT a price twin of Fable 5: same $10/$50, but cached reads are $0.25/M against
+      # $1.00, so a reference turn is cheaper (~12.9x vs ~13.3x). The monotonic-multiplier invariant
+      # orders by cost, so it sits BEFORE Fable 5 and Astra rather than beside them.
+      "anthropic/claude-fable-5.1" => {
+        label: "Fable 5.1", provider: "openrouter",
+        # Confirmed vs the OpenRouter models API (2026-09-08, listed 2026-09-01): $10/M in · $50/M out
+        # · $0.25/M cached read · 1M ctx. Image + file input. Every endpoint (Anthropic, Azure, Bedrock,
+        # Google) is at exactly this price, so the routing ceiling leaves all of them standing.
+        # Tier: pro — the same decision as Fable 5 below. ~20 turns a month on Pro, ~40 on Pro+.
+        input: 10.00, cached_input: 0.25, output: 50.00,
+        context: 1_000_000, min_tier: :pro, status: :confirmed
+      },
       "anthropic/claude-fable-5" => {
         label: "Fable 5", provider: "openrouter",
-        # OpenRouter 2026-07-26: $10/M in, $50/M out, $1/M cached, 1M ctx. ~13.3x -> ~28 Pro turns;
-        # gated to Max/Ultra so it never feels broken (rec #3).
+        # OpenRouter 2026-07-26, re-checked 2026-09-08: $10/M in, $50/M out, $1/M cached, 1M ctx. ~13.3x.
+        #
+        # Tier: pro (was max). Owner's decision, 2026-09-08: reach over rec #3. As of that date no
+        # business-approved editor ships a Fable/Astra-class model, and the dollar budget means a pricey
+        # pick drains the allowance faster without touching margin. What Pro buys is ~19 turns a month,
+        # so the honest count lives on the pricing page and in the picker rather than in the gate.
         input: 10.00, cached_input: 1.00, output: 50.00,
-        context: 1_000_000, min_tier: :max, status: :confirmed
+        context: 1_000_000, min_tier: :pro, status: :confirmed
       },
       # Sits immediately after Fable 5 because the rate card is IDENTICAL ($10/$1/$50) — an equal
       # neighbour, exactly as Opus 5 follows Opus 4.8, so the monotonic-multiplier invariant holds.
@@ -109,7 +125,8 @@ module ModelCatalog
         #
         # Tier: pro_plus, not max. Same per-turn cost as Fable 5 (~13.3x), which buys ~39 turns on Pro+ —
         # the number Pro already advertises for Opus 5 — and only ~19 on Pro, which is where rec #3 says a
-        # model starts to feel broken. Fable 5 stays at :max as previously decided; revisit together.
+        # model starts to feel broken. Fable 5 / 5.1 went to :pro on 2026-09-08 by the owner's call;
+        # Astra stays at pro_plus until the same call is made for it.
         input: 10.00, cached_input: 1.00, output: 50.00,
         context: 1_050_000, min_tier: :pro_plus, status: :confirmed
       }

lib/levelcode.rb

@@ -28,9 +28,9 @@ module Levelcode
       turns: 260,
       stripe_lookup_key: "orbits_pro",
       features: [
-        "2,000 credits/mo · ~260 Kimi turns, or ~39 on Opus 5",
+        "2,000 credits/mo · ~260 Kimi turns · ~39 on Opus 5 · ~20 on Fable 5.1",
         "Usage that refreshes through your billing cycle",
-        "Kimi K2.7 Code + Opus 5",
+        "Kimi K2.7 Code + Opus 5 + Fable 5 / 5.1",
         "Bring-your-own-key always free"
       ]
     },
@@ -44,9 +44,9 @@ module Levelcode
       turns: 520,
       stripe_lookup_key: "orbits_pro_plus",
       features: [
-        "4,000 credits/mo · ~520 Kimi turns, or ~78 on Opus 5",
+        "4,000 credits/mo · ~520 Kimi turns · ~78 on Opus 5 · ~40 on Fable 5.1",
         "Usage that refreshes through your billing cycle",
-        "Kimi K2.7 Code + Opus 5",
+        "Kimi K2.7 Code + Opus 5 + Fable 5 / 5.1 + GPT-6 Astra",
         "Priority routing"
       ]
     },
@@ -60,9 +60,9 @@ module Levelcode
       turns: 780,
       stripe_lookup_key: "orbits_max",
       features: [
-        "6,000 credits/mo · ~780 Kimi turns, or ~117 on Opus 5",
+        "6,000 credits/mo · ~780 Kimi turns · ~117 on Opus 5 · ~60 on Fable 5.1",
         "Usage that refreshes through your billing cycle",
-        "Kimi K2.7 Code + Opus 5",
+        "Kimi K2.7 Code + Opus 5 + Fable 5 / 5.1 + GPT-6 Astra",
         "Priority routing"
       ]
     },
@@ -76,9 +76,9 @@ module Levelcode
       turns: 1_300,
       stripe_lookup_key: "orbits_ultra",
       features: [
-        "10,000 credits/mo · ~1,300 Kimi turns, or ~195 on Opus 5",
+        "10,000 credits/mo · ~1,300 Kimi turns · ~195 on Opus 5 · ~100 on Fable 5.1",
         "Usage that refreshes through your billing cycle",
-        "Kimi K2.7 Code + Opus 5",
+        "Kimi K2.7 Code + Opus 5 + Fable 5 / 5.1 + GPT-6 Astra",
         "Highest priority routing"
       ]
     }

spec/models/levelcode_model_catalog_spec.rb

@@ -4,15 +4,12 @@
 # design invariants hold (entitlement tiers, monotonic multipliers, dollar-denominated budgets).
 RSpec.describe Levelcode::ModelCatalog do
   describe "roster integrity" do
+    # Asked of the roster itself, not of a list of ids kept by hand: only a :confirmed row is selectable
+    # or billable, so any other status — staged as "coming soon", mistyped, or missing — is a model
+    # that has silently gone dark. A hand-kept list guards only the rows someone remembered to add.
     it "carries a confirmed price on every roster engine — the frontier rows are enabled now" do
-      %w[openai/gpt-oss-120b moonshotai/kimi-k2.7-code anthropic/claude-opus-4-8 moonshotai/kimi-k3
-         anthropic/claude-opus-5 openai/gpt-5.3-codex openai/gpt-5.5 anthropic/claude-sonnet-5
-         anthropic/claude-fable-5].each do |id|
-        expect(described_class.find(id)[:status]).to eq(:confirmed), id
-      end
-      # Nothing left staged — the "coming soon" set is empty.
-      assumed = described_class.all.select { |_id, m| m[:status] == :assumption }.keys
-      expect(assumed).to be_empty
+      unconfirmed = described_class.all.reject { |_id, model| model[:status] == :confirmed }.keys
+      expect(unconfirmed).to eq([])
     end
 
     # `context` is not decoration — estimate_cost_micros clamps its input estimate DOWN to it, so a
@@ -24,6 +21,7 @@
       expect(described_class.find("moonshotai/kimi-k3")[:context]).to eq(1_048_576)
       expect(described_class.find("openai/gpt-oss-120b")[:context]).to eq(131_072)
       expect(described_class.find("openai/gpt-6-astra")[:context]).to eq(1_050_000)
+      expect(described_class.find("anthropic/claude-fable-5.1")[:context]).to eq(1_000_000)
       # No row may go without one: a nil/0 window disables the clamp entirely.
       expect(described_class.all.values.map { |m| m[:context] }).to all(be_positive)
     end
@@ -51,6 +49,9 @@
         # it sit beside 4.8 without disturbing the monotonic ordering asserted below.
         "anthropic/claude-opus-4-8" => 6.67, "anthropic/claude-opus-5" => 6.67,
         "openai/gpt-5.5" => 7.40,
+        # Fable 5.1 is CHEAPER than Fable 5 per turn — same $10/$50 but $0.25 cached vs $1.00 — so it
+        # must sit before Fable 5 for the monotonic ordering below to hold.
+        "anthropic/claude-fable-5.1" => 12.93,
         # GPT-6 Astra TIES Fable 5 — identical rate card ⇒ identical multiplier — so it sits after Fable
         # without disturbing the monotonic ordering, the same way Opus 5 sits beside Opus 4.8.
         "anthropic/claude-fable-5" => 13.35, "openai/gpt-6-astra" => 13.35
@@ -69,20 +70,21 @@
       expect(described_class.entitled(:free)).to eq([ "openai/gpt-oss-120b" ])
     end
 
-    it "pro reaches the roster EXCEPT the ~13x models (Fable, Astra — ~19 Pro turns feels broken, rec #3)" do
+    it "pro reaches Fable 5 and 5.1 (owner's call, 2026-09-08 — reach over rec #3) but not Astra" do
       pro = described_class.entitled(:pro)
-      expect(pro).to include("moonshotai/kimi-k2.7-code", "anthropic/claude-opus-4-8", "anthropic/claude-opus-5", "openai/gpt-5.5")
-      expect(pro).not_to include("anthropic/claude-fable-5", "openai/gpt-6-astra")
+      expect(pro).to include("moonshotai/kimi-k2.7-code", "anthropic/claude-opus-4-8", "anthropic/claude-opus-5", "openai/gpt-5.5",
+                             "anthropic/claude-fable-5", "anthropic/claude-fable-5.1")
+      expect(pro).not_to include("openai/gpt-6-astra")
     end
 
-    it "pro_plus adds GPT-6 Astra (~39 turns — the count Pro already advertises for Opus 5) but not Fable" do
+    it "pro_plus adds GPT-6 Astra on top of everything Pro reaches" do
       pro_plus = described_class.entitled(:pro_plus)
-      expect(pro_plus).to include("openai/gpt-6-astra")
-      expect(pro_plus).not_to include("anthropic/claude-fable-5")
+      expect(pro_plus).to include("openai/gpt-6-astra", "anthropic/claude-fable-5", "anthropic/claude-fable-5.1")
+      expect(pro_plus).to include(*described_class.entitled(:pro))
     end
 
-    it "Max/Ultra reach the full roster incl. Fable and Astra" do
-      expect(described_class.entitled(:max)).to include("anthropic/claude-fable-5", "openai/gpt-6-astra")
+    it "Max/Ultra reach the full roster" do
+      expect(described_class.entitled(:max)).to include("anthropic/claude-fable-5", "anthropic/claude-fable-5.1", "openai/gpt-6-astra")
       expect(described_class.entitled(:ultra)).to match_array(described_class.ids)
     end
   end
@@ -139,9 +141,11 @@
   end
 
   describe ".entitled_models / .plan_tier" do
-    it "maps plan keys to tiers and gates Fable to Max/Ultra" do
+    it "maps plan keys to tiers; Pro reaches Fable 5 / 5.1 (2026-09-08), Astra still needs Pro+" do
       expect(Levelcode.plan_tier("orbits_pro")).to eq(:pro)
-      expect(Levelcode.entitled_models("orbits_pro")).not_to include("anthropic/claude-fable-5")
+      expect(Levelcode.entitled_models("orbits_pro")).to include("anthropic/claude-fable-5", "anthropic/claude-fable-5.1")
+      expect(Levelcode.entitled_models("orbits_pro")).not_to include("openai/gpt-6-astra")
+      expect(Levelcode.entitled_models("orbits_pro_plus")).to include("openai/gpt-6-astra")
       expect(Levelcode.entitled_models("orbits_ultra")).to include("anthropic/claude-fable-5")
       expect(Levelcode.entitled_models("free")).to eq([ "openai/gpt-oss-120b" ])
     end

spec/models/levelcode_plans_spec.rb

@@ -107,6 +107,30 @@
     end
   end
 
+  # The pricing page prints PLANS[:features] verbatim. Pin the turn counts in each plan's first line
+  # to the formula, so a catalog price change (or a hand edit) cannot leave the page promising turns
+  # the budget no longer buys.
+  describe 'the pricing line' do
+    advertised = /~(?<kimi>[\d,]+) Kimi turns · ~(?<opus>\d+) on Opus 5 · ~(?<fable>\d+) on Fable 5\.1\z/
+
+    Levelcode::PLANS.each do |plan|
+      it "advertises the turns #{plan[:name]}'s budget buys — exact for the frontier models, within 1% for the rounded Kimi figure" do
+        line = plan[:features].first
+        # Asserted before it is relied on: if the copy changes shape, the failure is this line saying
+        # so — not a nil further down, or a count that silently reads as 0.
+        expect(line).to match(advertised)
+        counts = line.match(advertised)
+
+        expect(opus: counts[:opus].to_i, fable: counts[:fable].to_i).to eq(
+          opus: Levelcode.turns_for(plan[:key], 'anthropic/claude-opus-5'),
+          fable: Levelcode.turns_for(plan[:key], 'anthropic/claude-fable-5.1')
+        )
+        kimi = Levelcode.turns_for(plan[:key], Levelcode::DEFAULT_MODEL)
+        expect(counts[:kimi].delete(',').to_i).to be_within(kimi * 0.01).of(kimi)
+      end
+    end
+  end
+
   describe '.allowed_models / .gateway_model (entitlement)' do
     it 'free/no-plan may use ONLY the open-weights engine' do
       expect(Levelcode.allowed_models('free')).to eq([ Levelcode::FREE_MODEL ])
@@ -115,15 +139,16 @@
 
     it 'a paid plan may use the flagship AND the open-weights engine (confirmed-price roster)' do
       # Every Pro-tier engine is confirmed now — the frontier rows (Codex 5.3, GPT-5.5, Sonnet 5) went live.
-      expect(Levelcode.allowed_models('orbits_pro')).to match_array([ Levelcode::DEFAULT_MODEL, Levelcode::FREE_MODEL, 'anthropic/claude-opus-4-8', 'anthropic/claude-opus-5', 'moonshotai/kimi-k3', 'openai/gpt-5.3-codex', 'openai/gpt-5.5', 'anthropic/claude-sonnet-5' ])
-      # Fable 5 is confirmed too, but Max-tier — a Pro plan still can't reach it (entitlement, not price).
-      expect(Levelcode.allowed_models('orbits_pro')).not_to include('anthropic/claude-fable-5', 'openai/gpt-6-astra')
+      expect(Levelcode.allowed_models('orbits_pro')).to match_array([ Levelcode::DEFAULT_MODEL, Levelcode::FREE_MODEL, 'anthropic/claude-opus-4-8', 'anthropic/claude-opus-5', 'moonshotai/kimi-k3', 'openai/gpt-5.3-codex', 'openai/gpt-5.5', 'anthropic/claude-sonnet-5',
+                                                                       'anthropic/claude-fable-5', 'anthropic/claude-fable-5.1' ])
+      # Fable 5 / 5.1 are Pro-tier since 2026-09-08 (owner's call). Astra is the one Pro can't reach.
+      expect(Levelcode.allowed_models('orbits_pro')).not_to include('openai/gpt-6-astra')
     end
 
-    it 'Pro+ reaches GPT-6 Astra; Fable stays Max-tier; Max reaches both' do
-      expect(Levelcode.allowed_models('orbits_pro_plus')).to include('openai/gpt-6-astra')
-      expect(Levelcode.allowed_models('orbits_pro_plus')).not_to include('anthropic/claude-fable-5')
-      expect(Levelcode.allowed_models('orbits_max')).to include('openai/gpt-6-astra', 'anthropic/claude-fable-5')
+    it 'Pro reaches Fable 5.1 as requested; Pro+ adds GPT-6 Astra; Max reaches all three' do
+      expect(Levelcode.gateway_model('orbits_pro', 'anthropic/claude-fable-5.1')).to eq('anthropic/claude-fable-5.1')
+      expect(Levelcode.allowed_models('orbits_pro_plus')).to include('openai/gpt-6-astra', 'anthropic/claude-fable-5', 'anthropic/claude-fable-5.1')
+      expect(Levelcode.allowed_models('orbits_max')).to include('openai/gpt-6-astra', 'anthropic/claude-fable-5', 'anthropic/claude-fable-5.1')
       # Entitlement, not price: a Pro user asking for Astra is routed to the plan default, never 402'd.
       expect(Levelcode.gateway_model('orbits_pro', 'openai/gpt-6-astra')).to eq(Levelcode::DEFAULT_MODEL)
       expect(Levelcode.gateway_model('orbits_pro_plus', 'openai/gpt-6-astra')).to eq('openai/gpt-6-astra')