@cohortapp/agent-sdk 2.5.1 → 2.6.0

package/lib/model-router/economics.mjs

@@ -6,12 +6,16 @@
  * routing happens at dispatch/spawn time only, never mid-session (cache prefixes
  * are model-scoped; a mid-session switch silently re-bills the entire prefix, G8).
  *
- *   1. budgetLadder(spentUSD, capUSD) -> { band:0|75|90|100, degrade }
- *      A LADDER, not a cliff (§6.4):
- *        <75%  → policy as written
- *        ≥75%  → prefer cheaper tiers (downgrade one rung)
- *        ≥90%  → cheap-only + batch deferrable
- *        100%  → essential-only (still answers inbox DMs)
+ *   1. budgetLadder(spentUSD, capUSD) -> { band:0|100|125|150, degrade }
+ *      A LADDER, not a cliff (§6.4) — banded against the SEAT ENVELOPE hq
+ *      published, not a local config cap, and rung-for-rung identical to
+ *      `lib/budget-guard.postureForBand`:
+ *        <100%  → policy as written (80% is a supervisor notice, not a routing
+ *                 change — see budgetLadder)
+ *        ≥100%  → cheapest class only, batch deferrable, fan-out capped at 1,
+ *                 self-directed work stopped
+ *        ≥125%  → essential-only (still answers inbox DMs)
+ *        ≥150%  → the spawn gate refuses everything but a human reply
  *
  *   2. degradeChain(chain, band) — a resolveChain `opts` hook that TIGHTENS a
  *      candidate chain per band (drops/reorders refs). Subordinate to the gates
@@ -49,59 +53,100 @@ import { writeJsonAtomic, appendJsonl } from "../fs-atomic.mjs";
 // ---------------------------------------------------------------------------
 
 /**
- * The economics bands. Note these are the ladder's ECONOMIC bands (0/75/90/100),
- * deliberately coarser than budget-guard's notification bands ([50,75,90,100]):
- * 50% is a "you're halfway" notice, not a routing change — the first DEGRADATION
- * happens at 75% (§4.2 budget_ladder). budgetLadder collapses 50% back to band 0
- * so a caller cannot accidentally degrade routing on a mere halfway notice.
+ * The economics bands. These are now THE SAME BANDS the governance ladder uses
+ * (`lib/budget-guard.BANDS` = [80,100,125,150]) rather than a second, coarser
+ * set — two ladders with different rungs meant "degraded" in the router and
+ * "degraded" in the governor were different states, and neither matched the
+ * decision. 80% is the supervisor NOTICE rung: it is deliberately NOT a routing
+ * change, so `budgetLadder` collapses it back to band 0 for routing purposes and
+ * the first routing degradation happens at 100% — the rung where the seat has
+ * spent what the org actually funded.
  */
-export const LADDER_BANDS = Object.freeze([0, 75, 90, 100]);
+export const LADDER_BANDS = Object.freeze([0, 100, 125, 150]);
 
 /** Map a spend percentage onto an economics band. */
 function ladderBandForPct(pct) {
+  if (pct >= 150) return 150;
+  if (pct >= 125) return 125;
   if (pct >= 100) return 100;
-  if (pct >= 90) return 90;
-  if (pct >= 75) return 75;
   return 0;
 }
 
 /**
  * Compute the budget degradation for the day's spend. PURE. NEVER throws.
  *
- * `degrade` is the structured instruction the resolver / dispatcher consume:
- *   - band 0   → { preferCheaper:false, cheapOnly:false, batchDeferrable:false,
- *                  essentialOnly:false, downgradeTiers:0 }
- *   - band 75  → preferCheaper (downgrade one tier)
- *   - band 90  → cheapOnly + batchDeferrable (defer batch-eligible work)
- *   - band 100 → essentialOnly (inbox DMs answered on the cheapest qualifying
- *                row; everything else DEFER)
+ * `degrade` is the structured instruction the resolver / dispatcher consume, and
+ * it mirrors `lib/budget-guard.postureForBand` rung for rung:
+ *   - band 0   → nothing. (80% is a supervisor notice, not a routing change.)
+ *   - band 100 → cheapOnly + batchDeferrable + fan-out capped at 1 + no
+ *                self-directed work. THE DEGRADE RUNG: inbox DMs are still
+ *                answered, on the cheapest qualifying row.
+ *   - band 125 → essentialOnly on top (OUTCOME obligations are suspended
+ *                elsewhere; here it means non-inbox work stops being routed).
+ *   - band 150 → the spawn gate refuses anything that is not a human reply;
+ *                routing stays cheap-only for what does get through.
+ *
+ * `preferCheaper` (the old one-tier downgrade at 75%) is retained as the band-100
+ * behaviour's companion rather than a rung of its own: there is no longer a band
+ * between "fine" and "spent the envelope", because the old 75/90 rungs were
+ * measured against a local config file rather than the org's funding.
  *
  * @param {number} spentUSD  today's spend (>= 0)
- * @param {number} capUSD    the daily cap (> 0; <= 0 ⇒ no cap ⇒ band 0)
- * @returns {{ band:0|75|90|100, pct:number, spentUSD:number, capUSD:number,
+ * @param {number} capUSD    the binding daily allowance (> 0; <= 0 ⇒ band 0)
+ * @returns {{ band:0|100|125|150, pct:number, spentUSD:number, capUSD:number,
  *             degrade:{ preferCheaper:boolean, cheapOnly:boolean,
  *                       batchDeferrable:boolean, essentialOnly:boolean,
+ *                       maxFanout:number|null, selfDirected:boolean,
  *                       downgradeTiers:number } }}
  */
-export function budgetLadder(spentUSD, capUSD) {
+export function budgetLadder(spentUSD, capUSD, opts = {}) {
   const spent = numOr0(spentUSD);
   const cap = Number(capUSD);
   const hasCap = Number.isFinite(cap) && cap > 0;
-  const pct = hasCap ? round2((spent / cap) * 100) : 0;
-  const band = hasCap ? ladderBandForPct(pct) : 0;
+
+  // ── THE GOVERNOR'S BAND WINS, WHEN IT IS SUPPLIED ─────────────────────────
+  // Callers used to re-derive the band here from (spent, cap), which silently
+  // INVERTED the ladder once `dailyAllowance` started returning 0 for a seat
+  // whose monthly envelope was spent out: cap<=0 collapsed to band 0, so the
+  // further past its envelope a seat was, the LESS the router degraded. A seat
+  // at 200 % of its monthly envelope still routed the full frontier chain.
+  // `lib/budget-guard.dailyStatus` has already reconciled day vs month vs
+  // blindness; when it hands us its band we use it verbatim.
+  const supplied = Number(opts && opts.band);
+  if (Number.isFinite(supplied)) {
+    const band = ladderBandForPct(supplied);
+    return buildLadder(band, hasCap ? round2((spent / cap) * 100) : (spent > 0 ? 100 : 0), spent, hasCap ? cap : 0);
+  }
+
+  // No cap AND money already spent is not "no ceiling" — it is a ceiling of
+  // zero, i.e. fully consumed. Band 0 there is the same "a zero that means
+  // unmeasured" defect in percentage form.
+  const pct = hasCap ? round2((spent / cap) * 100) : (spent > 0 ? Infinity : 0);
+  const band = hasCap ? ladderBandForPct(pct) : (spent > 0 ? 150 : 0);
+  return buildLadder(band, Number.isFinite(pct) ? pct : 100, spent, hasCap ? cap : 0);
+}
+
+/** Shared tail of `budgetLadder` — the structured instruction for a band. */
+function buildLadder(band, pct, spent, cap) {
 
   const degrade = {
-    preferCheaper: band >= 75,
-    cheapOnly: band >= 90,
-    batchDeferrable: band >= 90,
-    essentialOnly: band >= 100,
-    // band 75 downgrades one tier; band 90+ collapses to cheap/fast directly
-    // (degradeChain drops the frontier/default head), so the tier count is the
-    // explain-string figure rather than a second knob.
-    downgradeTiers: band >= 90 ? 99 : band >= 75 ? 1 : 0,
+    preferCheaper: band >= 100,
+    cheapOnly: band >= 100,
+    batchDeferrable: band >= 100,
+    essentialOnly: band >= 125,
+    // 100%: sub-agent fan-out capped at 1 (the `team` rung becomes unavailable)
+    // and self-directed D3 work stops. Both are read by the daemon, not by the
+    // chain resolver, but they belong to the same instruction so a caller cannot
+    // apply half the rung.
+    maxFanout: band >= 100 ? 1 : null,
+    selfDirected: band < 100,
+    // band 100+ collapses to cheap/fast directly (degradeChain drops the
+    // frontier/default head), so the tier count is the explain-string figure
+    // rather than a second knob.
+    downgradeTiers: band >= 100 ? 99 : 0,
   };
 
-  return { band, pct, spentUSD: round6(spent), capUSD: hasCap ? cap : 0, degrade };
+  return { band, pct, spentUSD: round6(spent), capUSD: cap, degrade };
 }
 
 // ---------------------------------------------------------------------------
@@ -132,72 +177,58 @@ function inferTier(member) {
  * Tighten a resolved candidate chain for a budget band. PURE. NEVER throws.
  *
  * Contract (the `band` argument is the economics band from budgetLadder):
- *   - band  < 75 → the chain is returned unchanged.
- *   - band ≥ 75  → each tier-tagged member is downgraded ONE rung toward cheap
- *                  (frontier→default→fast→cheap); the rest pass through. The
- *                  resulting chain is de-duplicated, preserving order.
- *   - band ≥ 90  → frontier+default head members are DROPPED entirely (cheap/fast
+ *   - band  < 100 → the chain is returned unchanged (80 % is a notice rung).
+ *   - band ≥ 100 → frontier+default head members are DROPPED entirely (cheap/fast
  *                  only); a chain that would empty out keeps its cheapest member
  *                  so the caller always has at least one candidate.
- *   - `exempt` (pin or critical) → unchanged at any band below 100.
+ *   - `exempt` (pin or critical) → unchanged at any band below 125.
  *
  * Members are `{ ref, alias?, ... }` (resolveChain's chain shape) or bare ref
  * strings. The returned members keep their original shape, only `ref`/`alias`
  * shift on a downgrade. A `rules`/sentinel member is always preserved as a tail.
  *
  * @param {Array<object|string>} chain   resolved chain (alias-tagged members)
- * @param {0|75|90|100} band
+ * @param {0|100|125|150} band
  * @param {object} [opts]
  *   @param {boolean} [opts.exempt]   pin / critical — bypass degradation
- *   @param {Record<string,string>} [opts.aliases]  alias → ref, for retargeting a
- *                                    downgraded member to the cheaper alias's ref
+ *   @param {Record<string,string>} [opts.aliases]  accepted and ignored — kept so
+ *                                    callers built for the old one-rung downgrade
+ *                                    do not have to change shape
  * @returns {Array<object|string>} the tightened chain
  */
 export function degradeChain(chain, band, opts = {}) {
   const members = Array.isArray(chain) ? chain : [];
   if (!members.length) return members;
   const b = Number(band) || 0;
-  if (b < 75 || opts.exempt) return members.slice();
-
-  const aliases = (opts && opts.aliases && typeof opts.aliases === "object") ? opts.aliases : {};
+  if (b < 100 || opts.exempt) return members.slice();
 
   const isSentinel = (m) =>
     (typeof m === "object" && m && (m.isRules || m.ref === "rules")) ||
     m === "rules";
 
-  if (b >= 90) {
-    // cheap/fast only — drop the frontier/default head.
-    const kept = members.filter((m) => {
-      if (isSentinel(m)) return true;
-      const tier = inferTier(m);
-      return tier == null || TIER_RANK[tier] >= TIER_RANK.fast;
-    });
-    if (kept.length) return dedupeByRef(kept);
-    // Everything was frontier/default: keep the single cheapest as a safety net.
-    const cheapest = members
-      .filter((m) => !isSentinel(m))
-      .sort((a, z) => (TIER_RANK[inferTier(z)] ?? -1) - (TIER_RANK[inferTier(a)] ?? -1))[0];
-    return cheapest ? [cheapest] : members.slice();
-  }
-
-  // band >= 75: downgrade each tier-tagged member one rung.
-  const next = members.map((m) => {
-    if (isSentinel(m)) return m;
+  // Cheap/fast only — drop the frontier/default head.
+  //
+  // There is no longer a one-rung "prefer cheaper" step below this. It existed
+  // for the old 75% rung, which was measured against a local config cap; on the
+  // funded-envelope ladder the band below this one is 80%, which is a supervisor
+  // NOTICE and deliberately changes no routing. Keeping a branch no band can
+  // reach would be worse than not having the rung: it reads as enforcement that
+  // is in fact dead code.
+  const kept = members.filter((m) => {
+    if (isSentinel(m)) return true;
     const tier = inferTier(m);
-    if (tier == null) return m;
-    const i = TIER_RANK[tier];
-    const downAlias = TIER_ORDER[Math.min(TIER_ORDER.length - 1, i + 1)];
-    if (downAlias === tier) return m; // already cheapest
-    // Retarget to the cheaper alias's ref when the caller supplied the alias map.
-    if (typeof m === "object" && m) {
-      const ref = aliases[downAlias] || m.ref;
-      return { ...m, ref, alias: downAlias };
-    }
-    return aliases[downAlias] || m;
+    return tier == null || TIER_RANK[tier] >= TIER_RANK.fast;
   });
-  return dedupeByRef(next);
+  if (kept.length) return dedupeByRef(kept);
+  // Everything was frontier/default: keep the single cheapest as a safety net,
+  // because a caller with an empty chain has no candidate at all.
+  const cheapest = members
+    .filter((m) => !isSentinel(m))
+    .sort((a, z) => (TIER_RANK[inferTier(z)] ?? -1) - (TIER_RANK[inferTier(a)] ?? -1))[0];
+  return cheapest ? [cheapest] : members.slice();
 }
 
+/** Collapse chain members that resolved onto the same ref, preserving order. */
 function dedupeByRef(members) {
   const seen = new Set();
   const out = [];

package/lib/model-router/economics.test.mjs

@@ -1,6 +1,7 @@
 /**
  * Tests for lib/model-router/economics.mjs — the router economics levers:
- *   - budgetLadder transitions at 75 / 90 / 100 (a ladder, not a cliff)
+ *   - budgetLadder transitions at 100 / 125 / 150 (a ladder, not a cliff) —
+ *     the SAME rungs lib/budget-guard bands the seat envelope on
  *   - degradeChain tightens a candidate chain per band
  *   - batchLaneFor classifies deferrable vs realtime work
  *   - cacheAffinity pin / lookupPin / resolvePin override (+ pin_overridden audit)
@@ -24,11 +25,11 @@ import {
 } from "./economics.mjs";
 
 // ---------------------------------------------------------------------------
-// budgetLadder — transitions at 75/90/100
+// budgetLadder — transitions at 100/125/150 (the governance ladder's rungs)
 // ---------------------------------------------------------------------------
 
-test("budgetLadder: below 75% is band 0, no degradation", () => {
-  for (const spent of [0, 10, 37, 74.9]) {
+test("budgetLadder: below 100% is band 0, no degradation", () => {
+  for (const spent of [0, 10, 37, 80, 99.9]) {
     const r = budgetLadder(spent, 100);
     assert.equal(r.band, 0, `spent ${spent} → band 0`);
     assert.equal(r.degrade.preferCheaper, false);
@@ -37,45 +38,65 @@ test("budgetLadder: below 75% is band 0, no degradation", () => {
   }
 });
 
-test("budgetLadder: 50% notice does NOT degrade routing (band 0)", () => {
-  // budget-guard notifies at 50%, but the economics ladder's first rung is 75%.
-  const r = budgetLadder(50, 100);
+test("budgetLadder: the 80% supervisor notice does NOT degrade routing (band 0)", () => {
+  // budget-guard notifies the SUPERVISOR at 80%, but a notice is not a routing
+  // change — the first degradation is at 100%, where the seat has spent what the
+  // org actually funded.
+  const r = budgetLadder(80, 100);
   assert.equal(r.band, 0);
   assert.equal(r.degrade.downgradeTiers, 0);
+  assert.equal(r.degrade.selfDirected, true);
 });
 
-test("budgetLadder: 75% → prefer cheaper (downgrade one tier)", () => {
-  const r = budgetLadder(75, 100);
-  assert.equal(r.band, 75);
-  assert.equal(r.degrade.preferCheaper, true);
-  assert.equal(r.degrade.cheapOnly, false);
-  assert.equal(r.degrade.batchDeferrable, false);
-  assert.equal(r.degrade.essentialOnly, false);
-  assert.equal(r.degrade.downgradeTiers, 1);
-});
-
-test("budgetLadder: 90% → cheap-only + batch deferrable", () => {
-  const r = budgetLadder(90, 100);
-  assert.equal(r.band, 90);
+test("budgetLadder: 100% → cheapest class, fan-out 1, no self-directed work", () => {
+  const r = budgetLadder(100, 100);
+  assert.equal(r.band, 100);
   assert.equal(r.degrade.preferCheaper, true);
   assert.equal(r.degrade.cheapOnly, true);
   assert.equal(r.degrade.batchDeferrable, true);
-  assert.equal(r.degrade.essentialOnly, false);
+  assert.equal(r.degrade.maxFanout, 1);
+  assert.equal(r.degrade.selfDirected, false, "D3 stops here");
+  assert.equal(r.degrade.essentialOnly, false, "inbox + obligations still run — this rung is not a cliff");
 });
 
-test("budgetLadder: 100% → essential-only", () => {
-  const r = budgetLadder(100, 100);
-  assert.equal(r.band, 100);
+test("budgetLadder: 125% → essential-only on top of the degrade rung", () => {
+  const r = budgetLadder(125, 100);
+  assert.equal(r.band, 125);
   assert.equal(r.degrade.essentialOnly, true);
   assert.equal(r.degrade.cheapOnly, true);
-  // over-cap also stays band 100
-  assert.equal(budgetLadder(250, 100).band, 100);
 });
 
-test("budgetLadder: no cap (cap<=0) collapses to band 0", () => {
-  assert.equal(budgetLadder(500, 0).band, 0);
-  assert.equal(budgetLadder(500, -1).band, 0);
-  assert.equal(budgetLadder(500, NaN).band, 0);
+test("budgetLadder: past 150% stays band 150", () => {
+  assert.equal(budgetLadder(150, 100).band, 150);
+  assert.equal(budgetLadder(250, 100).band, 150);
+  assert.equal(budgetLadder(250, 100).degrade.essentialOnly, true);
+});
+
+test("budgetLadder: a cap of ZERO with money spent is EXHAUSTED, not uncapped", () => {
+  // This test used to assert band 0 for every cap<=0, and it was correct when
+  // capUSD could only be a local config number > 0. `dailyAllowance` now returns
+  // 0 for a seat whose MONTHLY envelope is spent out — so cap===0 became a
+  // reachable production value meaning "there is no room at all", and collapsing
+  // it to band 0 inverted the ladder: the further past its envelope a seat was,
+  // the less the router degraded.
+  assert.equal(budgetLadder(500, 0).band, 150, "$500 spent against a $0 allowance is fully over");
+  assert.equal(budgetLadder(500, -1).band, 150);
+  assert.equal(budgetLadder(500, NaN).band, 150);
+  // Nothing spent and no cap is genuinely unknown — do not degrade on it.
+  assert.equal(budgetLadder(0, 0).band, 0);
+  assert.equal(budgetLadder(0, NaN).band, 0);
+});
+
+test("budgetLadder: the governor's band wins over any re-derivation", () => {
+  // The dispatcher and the cadence consumer pass `dailyStatus().band`, which has
+  // already reconciled day vs month vs blindness. Re-deriving from (spent, cap)
+  // is what let a seat at 109% of its MONTH route the full frontier chain
+  // because today happened to look quiet.
+  const r = budgetLadder(3, 30, { band: 125 });
+  assert.equal(r.band, 125);
+  assert.equal(r.degrade.cheapOnly, true);
+  assert.equal(r.degrade.essentialOnly, true);
+  assert.equal(budgetLadder(3, 30).band, 0, "and without it, the local reading still applies");
 });
 
 test("budgetLadder: pct is rounded and exposed", () => {
@@ -99,35 +120,33 @@ function aliasChain(...names) {
   return names.map((n) => ({ ref: ALIASES[n] || n, alias: ALIASES[n] ? n : null }));
 }
 
-test("degradeChain: band < 75 returns the chain unchanged", () => {
+test("degradeChain: band < 100 returns the chain unchanged", () => {
   const chain = aliasChain("frontier", "default");
   const out = degradeChain(chain, 0, { aliases: ALIASES });
   assert.deepEqual(out, chain);
   assert.notEqual(out, chain, "returns a copy, not the same reference");
 });
 
-test("degradeChain: band 75 downgrades each tier one rung", () => {
+test("degradeChain: the 80% notice rung changes no routing at all", () => {
+  // There is deliberately no one-rung "prefer cheaper" step any more: the band
+  // below the drop rung is a supervisor NOTICE, and a notice must not silently
+  // re-route the seat onto a worse model.
   const chain = aliasChain("frontier", "default");
-  const out = degradeChain(chain, 75, { aliases: ALIASES });
-  // frontier→default, default→fast
-  assert.equal(out[0].alias, "default");
-  assert.equal(out[0].ref, ALIASES.default);
-  assert.equal(out[1].alias, "fast");
-  assert.equal(out[1].ref, ALIASES.fast);
+  assert.deepEqual(degradeChain(chain, 80, { aliases: ALIASES }), chain);
 });
 
-test("degradeChain: band 90 drops frontier/default head, keeps cheap/fast", () => {
+test("degradeChain: band 100 drops frontier/default head, keeps cheap/fast", () => {
   const chain = aliasChain("frontier", "default", "fast", "cheap");
-  const out = degradeChain(chain, 90, { aliases: ALIASES });
+  const out = degradeChain(chain, 100, { aliases: ALIASES });
   const aliasesOut = out.map((m) => m.alias);
   assert.ok(!aliasesOut.includes("frontier"));
   assert.ok(!aliasesOut.includes("default"));
   assert.deepEqual(aliasesOut, ["fast", "cheap"]);
 });
 
-test("degradeChain: band 90 with an all-frontier chain keeps the single cheapest as a safety net", () => {
+test("degradeChain: band 100 with an all-frontier chain keeps the single cheapest as a safety net", () => {
   const chain = aliasChain("frontier", "default");
-  const out = degradeChain(chain, 90, { aliases: ALIASES });
+  const out = degradeChain(chain, 100, { aliases: ALIASES });
   assert.equal(out.length, 1);
   // 'default' is cheaper than 'frontier', so it's the safety-net survivor.
   assert.equal(out[0].alias, "default");
@@ -141,22 +160,21 @@ test("degradeChain: exempt (pin/critical) bypasses degradation", () => {
 
 test("degradeChain: preserves a rules sentinel as a tail at any band", () => {
   const chain = [...aliasChain("frontier"), { ref: "rules", isRules: true }];
-  const out90 = degradeChain(chain, 90, { aliases: ALIASES });
+  const out90 = degradeChain(chain, 100, { aliases: ALIASES });
   assert.ok(out90.some((m) => m.ref === "rules"));
 });
 
 test("degradeChain: infers tier from literal refs without alias tags", () => {
   const chain = [{ ref: "anthropic/claude-opus-4-8" }, { ref: "anthropic/claude-haiku-4-5" }];
-  const out = degradeChain(chain, 90, { aliases: ALIASES });
+  const out = degradeChain(chain, 100, { aliases: ALIASES });
   // opus (frontier) dropped; haiku (fast) kept.
   assert.equal(out.length, 1);
   assert.match(out[0].ref, /haiku/);
 });
 
 test("degradeChain: de-dupes refs that collapse onto the same model", () => {
-  // default + fast at band 75 → fast + cheap; but if both map to fast they dedupe.
   const chain = aliasChain("fast", "fast");
-  const out = degradeChain(chain, 75, { aliases: ALIASES });
+  const out = degradeChain(chain, 100, { aliases: ALIASES });
   assert.equal(out.length, 1);
 });
 

package/lib/model-router/integration-coverage.test.mjs

@@ -440,38 +440,42 @@ test("2b. context_overflow NEVER fails over (terminal, opens no breaker) inside
 });
 
 // ===========================================================================
-// 3. budgetLadder: band 75 degrades to cheaper tiers; band 100 essential-only;
-//    degradeChain tightens the resolved chain.
+// 3. budgetLadder: band 100 forces the cheapest class; band 125 essential-only;
+//    degradeChain tightens the resolved chain. The bands are the governance
+//    ladder's own rungs (lib/budget-guard.BANDS), measured against the seat's
+//    hq-funded envelope rather than a local config cap.
 // ===========================================================================
 
 test("3. budgetLadder bands + degradeChain tighten the resolved chain", () => {
   // ── budgetLadder maps spend% onto the economics bands. ───────────────────
-  assert.deepEqual(LADDER_BANDS, [0, 75, 90, 100]);
+  assert.deepEqual(LADDER_BANDS, [0, 100, 125, 150]);
 
   const low = budgetLadder(40, 100); // 40%
-  assert.equal(low.band, 0, "below 75% is band 0 (policy as written)");
+  assert.equal(low.band, 0, "below 100% is band 0 (policy as written)");
   assert.equal(low.degrade.preferCheaper, false);
 
-  // 50% is a budget-guard NOTICE, not a routing change — collapses to band 0.
-  assert.equal(budgetLadder(50, 100).band, 0, "50% halfway notice does not degrade routing");
+  // 80% is a budget-guard SUPERVISOR NOTICE, not a routing change.
+  assert.equal(budgetLadder(80, 100).band, 0, "the 80% notice does not degrade routing");
 
-  const b75 = budgetLadder(80, 100); // 80%
-  assert.equal(b75.band, 75, "≥75% is band 75");
-  assert.equal(b75.degrade.preferCheaper, true, "band 75 prefers cheaper tiers");
-  assert.equal(b75.degrade.downgradeTiers, 1, "band 75 downgrades one tier");
-  assert.equal(b75.degrade.essentialOnly, false);
+  const b100 = budgetLadder(100, 100);
+  assert.equal(b100.band, 100, "≥100% — the seat has spent what the org funded");
+  assert.equal(b100.degrade.cheapOnly, true, "band 100 is cheapest-class only");
+  assert.equal(b100.degrade.batchDeferrable, true);
+  assert.equal(b100.degrade.maxFanout, 1, "sub-agent fan-out capped at 1");
+  assert.equal(b100.degrade.selfDirected, false, "self-directed D3 work stops");
+  assert.equal(b100.degrade.essentialOnly, false, "but inbox + obligations still run");
 
-  const b90 = budgetLadder(95, 100);
-  assert.equal(b90.band, 90, "≥90% is band 90");
-  assert.equal(b90.degrade.cheapOnly, true, "band 90 is cheap/fast only");
-  assert.equal(b90.degrade.batchDeferrable, true, "band 90 defers batch-eligible work");
+  const b125 = budgetLadder(130, 100);
+  assert.equal(b125.band, 125, "≥125% suspends the obligations");
+  assert.equal(b125.degrade.essentialOnly, true, "essential-only (still answers inbox DMs)");
 
-  const b100 = budgetLadder(110, 100); // over cap
-  assert.equal(b100.band, 100, "at/over cap is band 100");
-  assert.equal(b100.degrade.essentialOnly, true, "band 100 is essential-only (still answers inbox DMs)");
+  const b150 = budgetLadder(200, 100);
+  assert.equal(b150.band, 150, "past 150% the spawn gate refuses non-human-reply work");
 
-  // No cap (≤0) → band 0 (never degrade on an unknown cap).
-  assert.equal(budgetLadder(500, 0).band, 0, "no cap ⇒ band 0");
+  // A cap of 0 with money already spent is an EXHAUSTED envelope, not an unknown
+  // one — see economics.test.mjs for why this assertion flipped.
+  assert.equal(budgetLadder(500, 0).band, 150, "spend against a $0 allowance is fully over");
+  assert.equal(budgetLadder(0, 0).band, 0, "but nothing spent under no cap stays band 0");
 
   // ── degradeChain tightens the alias-tagged chain that resolveChain built. ──
   const aliases = {
@@ -486,38 +490,36 @@ test("3. budgetLadder bands + degradeChain tighten the resolved chain", () => {
     { ref: aliases.default, alias: "default" },
   ];
 
-  // band < 75 → unchanged.
+  // Below the drop rung → unchanged. Includes the 80% notice band.
   assert.deepEqual(degradeChain(chain, 0, { aliases }).map((m) => m.ref), [aliases.frontier, aliases.default]);
+  assert.deepEqual(degradeChain(chain, 80, { aliases }).map((m) => m.ref), [aliases.frontier, aliases.default]);
 
-  // band 75 → each tier-tagged member downgrades ONE rung (frontier→default,
-  // default→fast), de-duped preserving order.
-  const tightened75 = degradeChain(chain, 75, { aliases });
-  assert.deepEqual(
-    tightened75.map((m) => m.alias),
-    ["default", "fast"],
-    "band 75 downgrades frontier→default and default→fast"
-  );
-  assert.deepEqual(tightened75.map((m) => m.ref), [aliases.default, aliases.fast]);
-
-  // band 90 → cheap/fast only: the frontier/default head is DROPPED.
-  const tightened90 = degradeChain(
+  // band 100 → cheap/fast only: the frontier/default head is DROPPED. An
+  // all-frontier chain keeps its single cheapest member so the caller is never
+  // left with no candidate at all.
+  const tightened100 = degradeChain(
     [
       { ref: aliases.frontier, alias: "frontier" },
       { ref: aliases.default, alias: "default" },
       { ref: aliases.fast, alias: "fast" },
       { ref: aliases.cheap, alias: "cheap" },
     ],
-    90,
+    100,
     { aliases }
   );
   assert.deepEqual(
-    tightened90.map((m) => m.alias),
+    tightened100.map((m) => m.alias),
     ["fast", "cheap"],
-    "band 90 drops the frontier/default head, keeps cheap/fast"
+    "band 100 drops the frontier/default head, keeps cheap/fast"
+  );
+  assert.deepEqual(
+    degradeChain(chain, 100, { aliases }).map((m) => m.alias),
+    ["default"],
+    "a frontier+default chain keeps its CHEAPEST member as a safety net"
   );
 
   // exempt (pin / critical) → unchanged even at a degrading band.
-  const exempt = degradeChain(chain, 90, { aliases, exempt: true });
+  const exempt = degradeChain(chain, 100, { aliases, exempt: true });
   assert.deepEqual(exempt.map((m) => m.ref), [aliases.frontier, aliases.default], "pin/critical is exempt from degradation");
 
   // batchLaneFor + spawnKnobsFor (the other §8 economics levers) are wired too.