Add routing cost floor to stop the dream ratcheting balancedCeiling to its floor (#451)

* Add routing cost floor to stop the dream ratcheting balancedCeiling to its floor

The tier-routing review pass walked balancedCeiling down to its 0.40 floor and
kept it there, over-routing subagent traffic to the High tier. Two defects drove
this:

1. The dream and the introspection summary tool never passed `tierModelMap` to
   `TierRoutingAnalyzer.Analyze`, so every `thresholdScan.projectedCostDelta` was
   null — the LLM had no cost signal to weigh against quality, and the
   "don't under-route" guidance won by default.
2. Even with the map, High and Balanced currently share a model (gpt-5.5), so a
   Balanced->High shift projects a $0 cost delta — read as "free", never
   "unfavorable". Lowering balancedCeiling was always free and raising it was
   never indicated, so it ratcheted to the floor with no restoring force.

Fix:
- TierRoutingAnalyzer: add a High-tier cost floor. For threshold-scan and
  flagged-cluster cost projections, price High at >= N x the Balanced tier's real
  rate (Math.Max — a genuinely premium High model keeps its real price). Real-spend
  reporting (ProjectedCost) is unchanged. Wire `tierModelMap` through both decision
  paths.
- DreamService: build the tier->model map from TieredChatClientRegistry and pass it
  plus the configured multiplier to Analyze. Add a deterministic ratchet-stop
  (GuardBalancedCeilingDecrease) that refuses to lower balancedCeiling while the
  observed High routing share exceeds the target — independent of the LLM.
- DreamOptions: TierRoutingHighCostFloorMultiplier (2.0), TierRoutingHighTargetPct (20).
- routing-dream.md: tell the reviewer to trust projectedCostDelta and prefer raising
  balancedCeiling when High share is high.

The MCP summary tool keeps its existing 3-arg call (no floor) — its alert needs
only counts; the floor is for the tuner.

Tests: cost-floor sign/zero/premium-model cases on the analyzer; over/under-budget
and null-config cases on the guard. Full Host.Tests suite green (1037).

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

* Bump version to 0.12.24 for dream routing cost-floor test deploy

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

---------

Co-authored-by: Claude Opus 4.7 (1M context) <noreply@anthropic.com>

Author: rockfordlhotka

Directory.Build.props

@@ -9,7 +9,7 @@
     <!-- Version can be overridden from the command line: -p:Version=0.3.1
          AssemblyVersion and FileVersion are derived automatically by the SDK
          (prerelease suffixes like -beta001 are stripped for assembly versions). -->
-<Version>0.12.23</Version>
+<Version>0.12.24</Version>
   </PropertyGroup>
 
   <!-- NuGet package metadata (shared across all packable projects) -->

src/RockBot.Agent/agent/routing-dream.md

@@ -82,6 +82,14 @@ Apply a threshold shift only when **both** of these hold:
 - The cost delta is favorable, OR you have a clear quality reason (e.g., panic-escalation
   clusters dominating a tier)
 
+**Trust `projectedCostDelta`.** It now reflects a *routing cost floor*: the High tier is
+priced as a premium tier (≥ a fixed multiple of Balanced) even when High and Balanced
+currently share the same model. So a `balancedCeiling` **decrease** (which routes more
+traffic to High) will show a **positive (unfavorable)** delta, and an **increase** a
+**negative (favorable)** one. Do not read "same model today" as "free" — lowering
+`balancedCeiling` is treated as a real future cost. When High routing share is already
+high, prefer **raising** `balancedCeiling` to pull verbose-but-simple tasks back to Balanced.
+
 Adjustments must be **small (±0.05)**. Hard bounds the code clamps to:
 - `lowCeiling` ∈ [0.15, 0.40]
 - `balancedCeiling` ∈ [0.40, 0.80]

src/RockBot.Host.Abstractions/DreamOptions.cs

@@ -77,6 +77,24 @@ public sealed class DreamOptions
     /// <summary>Whether the tier routing self-correction review pass is enabled.</summary>
     public bool TierRoutingReviewEnabled { get; set; } = true;
 
+    /// <summary>
+    /// Routing cost floor for the tier-routing review pass. The High tier is priced at no less
+    /// than this multiple of the Balanced tier's real rate when projecting threshold-scan and
+    /// flagged-cluster costs. This stops the dream from reading a Balanced→High shift as
+    /// zero-cost — and ratcheting <c>balancedCeiling</c> to its floor — when High currently
+    /// shares Balanced's model. A genuinely premium High model keeps its real (higher) price.
+    /// Set to 1.0 to disable the floor. Default: 2.0.
+    /// </summary>
+    public double TierRoutingHighCostFloorMultiplier { get; set; } = 2.0;
+
+    /// <summary>
+    /// Target ceiling on the High-tier routing share (percent of routing decisions in the review
+    /// window). While the observed High share exceeds this, the review pass will NOT apply a
+    /// <c>balancedCeiling</c> decrease (which would push even more traffic to High) — a
+    /// deterministic backstop independent of the LLM's judgment. Default: 20 (%).
+    /// </summary>
+    public double TierRoutingHighTargetPct { get; set; } = 20.0;
+
     /// <summary>
     /// Path to the routing dream directive file, relative to <see cref="AgentProfileOptions.BasePath"/>.
     /// When the file does not exist, a built-in fallback directive is used.

src/RockBot.Host.Abstractions/TierRoutingAnalyzer.cs

@@ -35,11 +35,20 @@ public static class TierRoutingAnalyzer
     /// Run the analyzer over a snapshot of entries. The caller is responsible for
     /// any time-window filtering before calling — this method aggregates whatever it gets.
     /// </summary>
+    /// <param name="highTierCostFloorMultiplier">
+    /// Routing cost floor. For threshold-scan and flagged-cluster cost projections, the High
+    /// tier is priced at no less than this multiple of the Balanced tier's real rate. Prevents
+    /// the dream from reading a Balanced→High shift as zero-cost — and ratcheting balancedCeiling
+    /// to its floor — when High currently shares Balanced's model. <c>Math.Max</c> means a
+    /// genuinely premium High model keeps its real (higher) price. 1.0 disables the floor.
+    /// Does NOT affect <see cref="TierRoutingProjectedCost"/>, which always reports real spend.
+    /// </param>
     public static TierRoutingAnalysis Analyze(
         IReadOnlyList<TierRoutingEntry> entries,
         TierSelectorConfig? currentConfig = null,
         IReadOnlyList<LlmPricingRow>? pricing = null,
-        IReadOnlyDictionary<ModelTier, string?>? tierModelMap = null)
+        IReadOnlyDictionary<ModelTier, string?>? tierModelMap = null,
+        double highTierCostFloorMultiplier = 1.0)
     {
         var lowCeiling = currentConfig?.LowCeiling ?? DefaultLowCeiling;
         var balancedCeiling = currentConfig?.BalancedCeiling ?? DefaultBalancedCeiling;
@@ -65,9 +74,9 @@ public static TierRoutingAnalysis Analyze(
 
         var globalStats = BuildGlobalStats(entries, fallbackCount);
         var clusters = BuildClusters(quality);
-        var flagged = FlagClusters(clusters, pricing, tierModelMap);
+        var flagged = FlagClusters(clusters, pricing, tierModelMap, highTierCostFloorMultiplier);
         var keywordCandidates = BuildKeywordCandidates(quality);
-        var scans = BuildThresholdScans(quality, lowCeiling, balancedCeiling, pricing, tierModelMap);
+        var scans = BuildThresholdScans(quality, lowCeiling, balancedCeiling, pricing, tierModelMap, highTierCostFloorMultiplier);
         var projectedCost = BuildProjectedCost(entries, pricing);
 
         return new TierRoutingAnalysis(
@@ -183,7 +192,8 @@ private static string BuildSignature(TierRoutingEntry e)
     private static IReadOnlyList<TierRoutingFlaggedCluster> FlagClusters(
         IReadOnlyList<TierRoutingCluster> clusters,
         IReadOnlyList<LlmPricingRow>? pricing,
-        IReadOnlyDictionary<ModelTier, string?>? tierModelMap)
+        IReadOnlyDictionary<ModelTier, string?>? tierModelMap,
+        double highTierCostFloorMultiplier)
     {
         var flagged = new List<TierRoutingFlaggedCluster>();
 
@@ -195,7 +205,7 @@ private static IReadOnlyList<TierRoutingFlaggedCluster> FlagClusters(
             {
                 flagged.Add(BuildFlagged(c, "panicEscalation",
                     $"Low tier averaging {c.AvgToolCalls:F1} tool calls across {c.Count} entries — model likely struggling.",
-                    ModelTier.Balanced, pricing, tierModelMap));
+                    ModelTier.Balanced, pricing, tierModelMap, highTierCostFloorMultiplier));
                 continue;
             }
 
@@ -204,7 +214,7 @@ private static IReadOnlyList<TierRoutingFlaggedCluster> FlagClusters(
             {
                 flagged.Add(BuildFlagged(c, "tokenSurprise",
                     $"Score {c.AvgComplexityScore:F2} but post-injection tokens {p} — context inflation, not user complexity. Informational only.",
-                    alternateTier: null, pricing, tierModelMap));
+                    alternateTier: null, pricing, tierModelMap, highTierCostFloorMultiplier));
                 continue;
             }
 
@@ -213,7 +223,7 @@ private static IReadOnlyList<TierRoutingFlaggedCluster> FlagClusters(
             {
                 flagged.Add(BuildFlagged(c, "lowOutputAtHigh",
                     $"High tier producing only {o} avg output tokens across {c.Count} entries — possible over-routing.",
-                    ModelTier.Balanced, pricing, tierModelMap));
+                    ModelTier.Balanced, pricing, tierModelMap, highTierCostFloorMultiplier));
             }
         }
 
@@ -222,18 +232,19 @@ private static IReadOnlyList<TierRoutingFlaggedCluster> FlagClusters(
 
     private static TierRoutingFlaggedCluster BuildFlagged(
         TierRoutingCluster cluster, string flag, string rationale, ModelTier? alternateTier,
-        IReadOnlyList<LlmPricingRow>? pricing, IReadOnlyDictionary<ModelTier, string?>? tierModelMap)
+        IReadOnlyList<LlmPricingRow>? pricing, IReadOnlyDictionary<ModelTier, string?>? tierModelMap,
+        double highTierCostFloorMultiplier)
     {
         decimal? currentCost = null;
         decimal? alternateCost = null;
         if (pricing is not null && tierModelMap is not null
             && cluster.AvgInputTokens is long ai && cluster.AvgOutputTokens is long ao)
         {
-            var perCallCurrent = TryPriceCall(tierModelMap.GetValueOrDefault(cluster.Tier), ai, ao, pricing);
+            var perCallCurrent = TryPriceCallForTier(cluster.Tier, ai, ao, tierModelMap, pricing, highTierCostFloorMultiplier);
             currentCost = perCallCurrent * cluster.Count;
             if (alternateTier is ModelTier alt)
             {
-                var perCallAlt = TryPriceCall(tierModelMap.GetValueOrDefault(alt), ai, ao, pricing);
+                var perCallAlt = TryPriceCallForTier(alt, ai, ao, tierModelMap, pricing, highTierCostFloorMultiplier);
                 alternateCost = perCallAlt * cluster.Count;
             }
         }
@@ -325,14 +336,15 @@ private static IReadOnlyList<TierRoutingThresholdScan> BuildThresholdScans(
         IReadOnlyList<TierRoutingEntry> entries,
         double lowCeiling, double balancedCeiling,
         IReadOnlyList<LlmPricingRow>? pricing,
-        IReadOnlyDictionary<ModelTier, string?>? tierModelMap)
+        IReadOnlyDictionary<ModelTier, string?>? tierModelMap,
+        double highTierCostFloorMultiplier)
     {
         return new[]
         {
-            BuildScan(entries, "lowCeiling", +ThresholdScanDelta, lowCeiling, balancedCeiling, pricing, tierModelMap),
-            BuildScan(entries, "lowCeiling", -ThresholdScanDelta, lowCeiling, balancedCeiling, pricing, tierModelMap),
-            BuildScan(entries, "balancedCeiling", +ThresholdScanDelta, lowCeiling, balancedCeiling, pricing, tierModelMap),
-            BuildScan(entries, "balancedCeiling", -ThresholdScanDelta, lowCeiling, balancedCeiling, pricing, tierModelMap)
+            BuildScan(entries, "lowCeiling", +ThresholdScanDelta, lowCeiling, balancedCeiling, pricing, tierModelMap, highTierCostFloorMultiplier),
+            BuildScan(entries, "lowCeiling", -ThresholdScanDelta, lowCeiling, balancedCeiling, pricing, tierModelMap, highTierCostFloorMultiplier),
+            BuildScan(entries, "balancedCeiling", +ThresholdScanDelta, lowCeiling, balancedCeiling, pricing, tierModelMap, highTierCostFloorMultiplier),
+            BuildScan(entries, "balancedCeiling", -ThresholdScanDelta, lowCeiling, balancedCeiling, pricing, tierModelMap, highTierCostFloorMultiplier)
         };
     }
 
@@ -341,7 +353,8 @@ private static TierRoutingThresholdScan BuildScan(
         string threshold, double delta,
         double lowCeiling, double balancedCeiling,
         IReadOnlyList<LlmPricingRow>? pricing,
-        IReadOnlyDictionary<ModelTier, string?>? tierModelMap)
+        IReadOnlyDictionary<ModelTier, string?>? tierModelMap,
+        double highTierCostFloorMultiplier)
     {
         // Round shifted thresholds to 4 decimals — bare double subtraction yields
         // 0.15 - 0.05 = 0.09999999999999998, which makes boundary entries (score 0.10)
@@ -370,8 +383,8 @@ private static TierRoutingThresholdScan BuildScan(
             foreach (var (e, from, to) in flips)
             {
                 if (e.InputTokens is not long it || e.OutputTokens is not long ot) continue;
-                var fromCost = TryPriceCall(tierModelMap.GetValueOrDefault(from), it, ot, pricing);
-                var toCost = TryPriceCall(tierModelMap.GetValueOrDefault(to), it, ot, pricing);
+                var fromCost = TryPriceCallForTier(from, it, ot, tierModelMap, pricing, highTierCostFloorMultiplier);
+                var toCost = TryPriceCallForTier(to, it, ot, tierModelMap, pricing, highTierCostFloorMultiplier);
                 if (fromCost is null || toCost is null) continue;
                 accum += toCost.Value - fromCost.Value;
                 any = true;
@@ -442,11 +455,67 @@ private static TierRoutingProjectedCost BuildProjectedCost(
             EntriesUnpricedCount: unpriced);
     }
 
+    /// <summary>
+    /// Prices a call by raw model ID at real pricing — no cost floor. Used for
+    /// <see cref="BuildProjectedCost"/>, which reports actual spend.
+    /// </summary>
     private static decimal? TryPriceCall(string? modelId, long inputTokens, long outputTokens, IReadOnlyList<LlmPricingRow> pricing)
     {
-        if (string.IsNullOrEmpty(modelId)) return null;
-        var row = pricing.FirstOrDefault(p => modelId.Contains(p.Prefix, StringComparison.OrdinalIgnoreCase));
+        var row = MatchRow(modelId, pricing);
         if (row is null) return null;
         return (inputTokens * row.InputPerM + outputTokens * row.OutputPerM) / 1_000_000m;
     }
+
+    /// <summary>
+    /// Prices a call for a specific <see cref="ModelTier"/> with the routing cost floor applied
+    /// (see <see cref="EffectiveTierRates"/>). Used by the threshold-scan and flagged-cluster
+    /// projections that drive tuning decisions — NOT by real-spend reporting.
+    /// </summary>
+    private static decimal? TryPriceCallForTier(
+        ModelTier tier, long inputTokens, long outputTokens,
+        IReadOnlyDictionary<ModelTier, string?> tierModelMap,
+        IReadOnlyList<LlmPricingRow> pricing,
+        double highTierCostFloorMultiplier)
+    {
+        var rates = EffectiveTierRates(tier, tierModelMap, pricing, highTierCostFloorMultiplier);
+        if (rates is null) return null;
+        var (inPerM, outPerM) = rates.Value;
+        return (inputTokens * inPerM + outputTokens * outPerM) / 1_000_000m;
+    }
+
+    /// <summary>
+    /// Effective per-million-token rates for a tier. For the High tier, rates are floored at
+    /// <paramref name="highTierCostFloorMultiplier"/> × the Balanced tier's real rates so a
+    /// Balanced→High shift never projects as zero-cost when High shares Balanced's model.
+    /// <c>Math.Max</c> keeps a genuinely premium High model at its real (higher) price.
+    /// Returns <c>null</c> when the tier's model has no pricing row.
+    /// </summary>
+    private static (decimal InputPerM, decimal OutputPerM)? EffectiveTierRates(
+        ModelTier tier,
+        IReadOnlyDictionary<ModelTier, string?> tierModelMap,
+        IReadOnlyList<LlmPricingRow> pricing,
+        double highTierCostFloorMultiplier)
+    {
+        var row = MatchRow(tierModelMap.GetValueOrDefault(tier), pricing);
+        if (row is null) return null;
+
+        if (tier == ModelTier.High && highTierCostFloorMultiplier > 1.0)
+        {
+            var balanced = MatchRow(tierModelMap.GetValueOrDefault(ModelTier.Balanced), pricing);
+            if (balanced is not null)
+            {
+                var m = (decimal)highTierCostFloorMultiplier;
+                return (Math.Max(row.InputPerM, balanced.InputPerM * m),
+                        Math.Max(row.OutputPerM, balanced.OutputPerM * m));
+            }
+        }
+
+        return (row.InputPerM, row.OutputPerM);
+    }
+
+    private static LlmPricingRow? MatchRow(string? modelId, IReadOnlyList<LlmPricingRow> pricing)
+    {
+        if (string.IsNullOrEmpty(modelId)) return null;
+        return pricing.FirstOrDefault(p => modelId.Contains(p.Prefix, StringComparison.OrdinalIgnoreCase));
+    }
 }