pi-lilac-provider 1.1.0 → 1.2.1

package/README.md

@@ -77,7 +77,7 @@ pi
 | GLM 5.2 | 524K | ❌ | ✅ | $0.90 | $0.27 | $3.00 |
 | Kimi K2.6 | 262K | ✅ | ✅ | $0.70 | $0.20 | $3.50 |
 | MiniMax M2.7 | 205K | ❌ | ✅ | $0.30 | $0.06 | $1.20 |
-| MiniMax M3 | 1.0M | ❌ | ✅ | $0.28 | $0.05 | $1.10 |
+| MiniMax M3 | 1.0M | ✅ | ✅ | $0.28 | $0.05 | $1.10 |
 
 *Costs are per million tokens. Prices subject to change — check [getlilac.com](https://getlilac.com/) for current pricing.*
 

package/index.ts

@@ -304,6 +304,8 @@ function cacheModels(models: JsonModel[]): void {
   } catch {
     // Cache write failure is non-fatal
   }
+  // Base model set changed; force getListModels() to rebuild list prices.
+  listModelsCache = null;
 }
 
 function mergeWithEmbedded(liveModels: JsonModel[], embeddedModels: JsonModel[]): JsonModel[] {
@@ -398,6 +400,41 @@ function applyDiscounts(models: JsonModel[], discounts: Map<string, JsonDiscount
   });
 }
 
+/**
+ * Apply the current discount to a single model's cost IN PLACE.
+ *
+ * applyDiscounts() returns discounted COPIES for the registry; those copies
+ * cannot reach the model pi already bound for the current turn. This mutates
+ * that bound object directly so the current turn's calculateCost() (in pi-ai)
+ * reads the discounted price. Cost is always recomputed from list price — the
+ * patch-applied, pre-discount value from buildModels() — so re-applying a
+ * changed discount never compounds a factor already present on the object.
+ * cacheWrite is left untouched (Lilac does not discount it, matching
+ * applyDiscounts).
+ *
+ * Targets the object pi bound for the turn, captured before any await or
+ * registerProvider() call. registerProvider() refreshes the session model for
+ * SUBSEQUENT turns only (via prepareNextTurn); it cannot affect the current
+ * turn's cost calc, which is why the in-place mutation is required.
+ */
+function applyDiscountInPlace(
+  model: { id: string; cost: { input: number; output: number; cacheRead: number; cacheWrite: number } } | undefined,
+  listModels: JsonModel[],
+  discounts: Map<string, JsonDiscount> | null,
+): void {
+  if (!model?.cost) return;
+  const list = listModels.find(m => m.id === model.id);
+  if (!list) return;
+  // A missing discount entry means list price (factor 1) — e.g. a model whose
+  // discount was removed since it was last priced.
+  const rawFactor = discounts?.get(model.id)?.creditMultiplier;
+  const factor = Number.isFinite(rawFactor) && rawFactor !== undefined ? rawFactor : 1;
+  const applyFactor = (n: number) => n > 0 ? Math.round(n * factor * 10000) / 10000 : n;
+  model.cost.input = applyFactor(list.cost.input);
+  model.cost.output = applyFactor(list.cost.output);
+  model.cost.cacheRead = applyFactor(list.cost.cacheRead);
+}
+
 function cacheDiscounts(discounts: Map<string, JsonDiscount>): void {
   try {
     fs.mkdirSync(CACHE_DIR, { recursive: true });
@@ -442,6 +479,41 @@ function dimStatus(ctx: any, text: string): string {
   }
 }
 
+/**
+ * Paint the footer status from the LIVE session model — the single source of
+ * truth for the display. ctx.model is a lazy getter (not a snapshot), so this
+ * reflects the currently-selected model even when called from a deferred
+ * post-await callback that captured a different (stale) model at hook start.
+ *
+ * Set for lilac models, cleared for everything else. Every status paint site
+ * calls this, so whichever handler runs last wins — including after a switch
+ * to a non-lilac model, fixing a race where deferred post-await setStatus()
+ * calls re-painted a stale captured lilac model's discount over the clear
+ * that model_select had just issued.
+ *
+ * Only the DISPLAY follows the live model. Cost mutation (applyDiscountInPlace)
+ * and registerProvider() in before_provider_request still target the turn's
+ * captured in-flight model — that's the object pi bound and whose .cost
+ * calculateCost() reads, and it may legitimately differ from the live model
+ * after a mid-turn /model switch.
+ *
+ * Wrapped in try/catch: ctx.model / ctx.ui assert the extension runner is
+ * still active and throw if the session ended mid-fetch, so a late deferred
+ * callback after session_shutdown no-ops instead of throwing.
+ */
+function syncStatus(ctx: any): void {
+  try {
+    const model = ctx.model;
+    if (model?.provider === "lilac") {
+      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(model.id)));
+    } else {
+      ctx.ui.setStatus("lilac", undefined);
+    }
+  } catch {
+    // Runner stale (session ended mid-fetch) — nothing to paint.
+  }
+}
+
 function discountsChanged(
   a: Map<string, JsonDiscount> | null,
   b: Map<string, JsonDiscount> | null,
@@ -467,6 +539,10 @@ let revalidateAbort: AbortController | null = null;
 let latestDiscounts: Map<string, JsonDiscount> | null = null;
 let lastDiscountFetchTime = 0;
 const STATUS_CACHE_TTL_MS = 30000;
+// List-price (patch-applied, pre-discount) models, cached until the base set
+// changes. Reset in cacheModels() so the next getListModels() rebuilds from the
+// refreshed disk cache / embedded set.
+let listModelsCache: JsonModel[] | null = null;
 
 async function resolveApiKey(modelRegistry: ModelRegistry): Promise<void> {
   cachedApiKey = await modelRegistry.getApiKeyForProvider("lilac") ?? undefined;
@@ -479,6 +555,16 @@ export default function (pi: ExtensionAPI) {
   const customModels = customModelsData as JsonModel[];
   const patches = patchData as PatchData;
 
+  // List-price models (patch applied, pre-discount), cached at module scope and
+  // rebuilt only when the base set changes (see cacheModels). Used to recompute
+  // the in-flight model's cost without compounding an already-applied discount.
+  function getListModels(): JsonModel[] {
+    if (!listModelsCache) {
+      listModelsCache = buildModels(loadStaleModels(embeddedModels), customModels, patches);
+    }
+    return listModelsCache;
+  }
+
   const staleBase = loadStaleModels(embeddedModels);
   latestDiscounts = loadCachedDiscounts();
   const staleModels = applyDiscounts(buildModels(staleBase, customModels, patches), latestDiscounts);
@@ -521,11 +607,10 @@ export default function (pi: ExtensionAPI) {
     // Replay persisted discount state from session JSONL (synchronous, zero-latency)
     replayDiscountEvents(ctx);
 
-    // Show status immediately with replayed/cached data — don't block pi startup
-    const model = ctx.model;
-    if (model?.provider === "lilac") {
-      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(model.id)));
-    }
+    // Show status immediately with replayed/cached data — don't block pi startup.
+    // syncStatus reads the LIVE ctx.model so a switch away from lilac before the
+    // background fetch resolves never leaves a stale discount painted.
+    syncStatus(ctx);
 
     // Fire-and-forget: resolve API key, then fetch live data in background.
     // Provider and status are hot-swapped when results arrive.
@@ -562,9 +647,10 @@ export default function (pi: ExtensionAPI) {
           });
         }
 
-        if (model?.provider === "lilac") {
-          ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(model.id)));
-        }
+        // Re-paint from the LIVE model: if the user switched to a non-lilac
+        // model (or a different lilac model) during the fetch, this reflects
+        // the new selection instead of re-showing the stale captured model.
+        syncStatus(ctx);
       }).catch(() => { /* network errors are non-fatal */ });
     });
   });
@@ -582,10 +668,29 @@ export default function (pi: ExtensionAPI) {
   });
 
   pi.on("before_provider_request", async (_event, ctx) => {
-    if (ctx.model?.provider !== "lilac") return;
-
-    // Always show status for active lilac model
-    ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(ctx.model.id)));
+    // Capture the in-flight model BEFORE any await or registerProvider() call.
+    // ctx.model is a lazy getter to the live session model; at hook start (before
+    // any refresh) it is the same object pi's agent loop bound as the model for
+    // THIS turn — the exact object whose .cost calculateCost() reads when the
+    // response arrives. registerProvider() can only refresh the session model
+    // for SUBSEQUENT turns (prepareNextTurn), so to affect the current turn's
+    // cost we mutate this object in place. Capturing before the await also guards
+    // against a concurrent session_start /status sync swapping the reference
+    // mid-hook.
+    const inFlightModel = ctx.model;
+    if (!inFlightModel || inFlightModel.provider !== "lilac") return;
+
+    const listModels = getListModels();
+
+    // Align the in-flight model with the best-known discount right away. This
+    // covers turns that don't trigger a fresh fetch (within TTL, or the fetch
+    // returned unchanged) and recomputes from list price so it never compounds
+    // a previously-applied factor.
+    applyDiscountInPlace(inFlightModel, listModels, latestDiscounts);
+    // Display follows the LIVE model (clears if the user switched away during
+    // this turn); the cost mutation above still targets the captured in-flight
+    // model pi bound for this turn.
+    syncStatus(ctx);
 
     if (!cachedApiKey) return;
 
@@ -596,40 +701,46 @@ export default function (pi: ExtensionAPI) {
 
     const discounts = await fetchStatusDiscounts(cachedApiKey);
     if (!discounts) return;
+
+    lastDiscountFetchTime = now;
+
     if (!discountsChanged(latestDiscounts, discounts)) {
-      lastDiscountFetchTime = now;
-      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(ctx.model.id)));
+      syncStatus(ctx);
       return;
     }
 
-    lastDiscountFetchTime = now;
     cacheDiscounts(discounts);
     latestDiscounts = discounts;
 
-    const base = loadStaleModels(embeddedModels);
+    // Re-read list prices in case a concurrent /models sync (session_start)
+    // invalidated the list-price cache during the await above. Then re-apply the
+    // freshly-fetched discount so THIS turn (not just later ones) is costed at
+    // the new price, and re-register so other lilac models pick it up on their
+    // next request.
+    const freshList = getListModels();
+    applyDiscountInPlace(inFlightModel, freshList, discounts);
     pi.registerProvider("lilac", {
       baseUrl: BASE_URL,
       apiKey: "$LILAC_API_KEY",
       api: "openai-completions",
-      models: applyDiscounts(buildModels(base, customModels, patches), discounts),
+      models: applyDiscounts(freshList, discounts),
     });
-    ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(ctx.model.id)));
+    // Display reflects the LIVE model: post-await the user may have switched to
+    // a non-lilac model, so syncStatus clears instead of re-painting the stale
+    // captured in-flight lilac model's discount.
+    syncStatus(ctx);
   });
 
-  pi.on("model_select", async (event, ctx) => {
-    if (event.model.provider === "lilac") {
-      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(event.model.id)));
-    } else {
-      ctx.ui.setStatus("lilac", undefined);
-    }
+  pi.on("model_select", async (_event, ctx) => {
+    // ctx.model is the live session model (pi sets state.model before emitting
+    // this event), so syncStatus paints/clears consistently with every other
+    // handler — one source of truth for the footer.
+    syncStatus(ctx);
   });
 
   pi.on("session_tree", async (_event, ctx) => {
     replayDiscountEvents(ctx);
-    const model = ctx.model;
-    if (model?.provider === "lilac") {
-      ctx.ui.setStatus("lilac", dimStatus(ctx, formatDiscountStatus(model.id)));
-    }
+    syncStatus(ctx);
   });
 
   // vLLM's streaming parser intermittently emits finish_reason: "tool_calls" without
@@ -668,5 +779,5 @@ export default function (pi: ExtensionAPI) {
   });
 }
 
-export { fetchStatusDiscounts, applyDiscounts, loadCachedDiscounts, cacheDiscounts };
+export { fetchStatusDiscounts, applyDiscounts, applyDiscountInPlace, loadCachedDiscounts, cacheDiscounts };
 export type { JsonDiscount, JsonModel, PatchEntry, PatchData };

package/models.json

@@ -119,7 +119,8 @@
     "name": "MiniMax M3",
     "reasoning": true,
     "input": [
-      "text"
+      "text",
+      "image"
     ],
     "cost": {
       "input": 0.28,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lilac-provider",
-  "version": "1.1.0",
+  "version": "1.2.1",
   "description": "Lilac provider extension for pi - Access Kimi K2.6, GLM 5.1, and Gemma 4 models through Lilac's OpenAI-compatible API on idle GPUs",
   "type": "module",
   "main": "index.ts",

package/scripts/test-discounts.ts

@@ -13,6 +13,10 @@
  * 7. turn_end appends discount entry to session JSONL.
  * 8. before_provider_request refreshes discounts with a 30s cache.
  * 9. formatDiscountStatus returns fallbacks when data is missing.
+ * 10. applyDiscountInPlace mutates the in-flight model's cost in place,
+ *     recomputed from list price so re-applied discounts never compound.
+ * 11. before_provider_request mutates the bound (in-flight) model object so the
+ *     current turn's cost calc sees the discount in real time.
  */
 
 import type { ExtensionAPI, ModelRegistry } from "@earendil-works/pi-coding-agent";
@@ -43,6 +47,7 @@ const {
   default: registerLilac,
   fetchStatusDiscounts,
   applyDiscounts,
+  applyDiscountInPlace,
   loadCachedDiscounts,
   cacheDiscounts,
 } = await import("../index.ts");
@@ -281,7 +286,7 @@ for (const handler of handlers.get("model_select") || []) {
       previousModel: undefined,
       source: "set",
     },
-    { ui: mockUi }
+    { ui: mockUi, model: { id: "moonshotai/kimi-k2.6", provider: "lilac" } }
   );
 }
 assert(statuses.get("lilac") === "supply: healthy · sub-discount: 25%", "model_select keeps status for lilac model");
@@ -297,7 +302,7 @@ for (const handler of handlers.get("model_select") || []) {
       previousModel: undefined,
       source: "set",
     },
-    { ui: mockUi }
+    { ui: mockUi, model: { id: "claude-sonnet-4", provider: "anthropic" } }
   );
 }
 assert(statuses.get("lilac") === undefined, "model_select clears status for non-lilac model");
@@ -354,7 +359,7 @@ for (const handler of handlers.get("model_select") || []) {
       previousModel: undefined,
       source: "set",
     },
-    { ui: mockUi },
+    { ui: mockUi, model: { id: "some/unknown-model", provider: "lilac" } },
   );
 }
 assert(statuses.get("lilac") === "supply: —", "unknown model shows fallback dash");
@@ -368,7 +373,7 @@ for (const handler of handlers.get("model_select") || []) {
       previousModel: undefined,
       source: "set",
     },
-    { ui: mockUi },
+    { ui: mockUi, model: { id: "moonshotai/kimi-k2.6", provider: "lilac" } },
   );
 }
 assert(
@@ -446,6 +451,252 @@ const kimiFinal = afterSecond.config.models.find((m: any) => m.id === "moonshota
 assert(kimiFinal.discount.discountPercent === 25, "final registration uses correct discount (not stale from first re-register)");
 assert(kimiFinal.cost.input === 0.525, "final registration uses correct cost (0.70 * 0.75)");
 
+// ─── Test 12: applyDiscountInPlace mutates the in-flight model ───────────────
+
+console.log("\n--- Test 12: applyDiscountInPlace (in-flight mutation) ---");
+
+// applyDiscountInPlace closes the one-turn gap: registerProvider() refreshes
+// the registry for LATER turns, but the model pi already bound for the current
+// turn is a separate object whose .cost calculateCost() reads. We mutate THAT
+// object in place, recomputed from list price so a changed discount never
+// compounds on top of an already-applied factor.
+
+const listModels = [
+  { id: "moonshotai/kimi-k2.6", name: "Kimi K2.6", cost: { input: 0.70, output: 3.50, cacheRead: 0.20, cacheWrite: 0 } },
+] as any[];
+
+// A model object that is "already bound" for the turn — the same reference pi's
+// agent loop holds. It currently carries an OLD discount (factor 0.75).
+const inFlight = {
+  id: "moonshotai/kimi-k2.6",
+  cost: { input: 0.525, output: 2.625, cacheRead: 0.15, cacheWrite: 0 },
+};
+const inFlightRef = inFlight;
+
+// New discount: factor 0.50 (changed). Must recompute from LIST price (0.70),
+// NOT compound on top of the already-applied 0.75 (which would give 0.2625).
+const newDiscounts = new Map([
+  ["moonshotai/kimi-k2.6", { supplyState: "high", discountPercent: 50, creditMultiplier: 0.50 }],
+]);
+applyDiscountInPlace(inFlight, listModels, newDiscounts);
+assert(inFlight === inFlightRef, "mutates the same object in place (no new object created)");
+assert(inFlight.cost.input === 0.35, "recomputed from list price: 0.70 * 0.50 = 0.35 (not compounded 0.2625)");
+assert(inFlight.cost.output === 1.75, "output = 3.50 * 0.50 = 1.75");
+assert(inFlight.cost.cacheRead === 0.1, "cacheRead = 0.20 * 0.50 = 0.1");
+assert(inFlight.cost.cacheWrite === 0, "cacheWrite left untouched (Lilac does not discount it)");
+
+// Idempotency + no-compounding: applying the same factor again yields the same
+// values (always recomputed from list price, never compounding).
+applyDiscountInPlace(inFlight, listModels, newDiscounts);
+assert(inFlight.cost.input === 0.35, "re-applying same factor is idempotent (no compounding)");
+
+// Discount removed (model no longer in /status) → reverts to list price.
+const emptyDiscounts = new Map();
+applyDiscountInPlace(inFlight, listModels, emptyDiscounts);
+assert(inFlight.cost.input === 0.70, "removed discount reverts to list price (factor 1)");
+assert(inFlight.cost.output === 3.50, "removed discount: output reverts to list price");
+
+// null discounts → list price, no throw.
+applyDiscountInPlace(inFlight, listModels, null);
+assert(inFlight.cost.input === 0.70, "null discounts → list price");
+
+// Unknown model id (not in listModels) → no-op, no throw.
+const unknown = { id: "some/unknown-model", cost: { input: 9.99, output: 9.99, cacheRead: 9.99, cacheWrite: 0 } };
+applyDiscountInPlace(unknown, listModels, newDiscounts);
+assert(unknown.cost.input === 9.99, "unknown model id → no mutation (no list-price match)");
+
+// undefined model → no throw.
+applyDiscountInPlace(undefined, listModels, newDiscounts);
+assert(true, "undefined model does not throw");
+
+// ─── Test 13: before_provider_request mutates the bound (in-flight) model ────
+
+console.log("\n--- Test 13: before_provider_request mutates the bound model ---");
+
+// Simulate the object pi's agent loop bound for the turn. It holds an OUTDATED
+// cost (list price, as if no discount had been applied yet). This same reference
+// is what calculateCost() reads for the current turn — so the handler MUST mutate
+// it in place, not replace it. latestDiscounts currently holds kimi at 0.75 (from
+// Test 4), and the TTL is fresh, so the handler takes the within-TTL path (which
+// previously did NOT touch the in-flight model at all).
+const boundModel = {
+  id: "moonshotai/kimi-k2.6",
+  provider: "lilac",
+  cost: { input: 0.70, output: 3.50, cacheRead: 0.20, cacheWrite: 0 }, // list price (stale)
+};
+const boundRef = boundModel;
+
+for (const handler of handlers.get("before_provider_request") || []) {
+  await handler(
+    { type: "before_provider_request", payload: {} },
+    {
+      ui: mockUi,
+      model: boundModel,
+    }
+  );
+}
+
+assert(boundModel === boundRef, "handler did not replace the bound model object (same reference)");
+assert(boundModel.cost.input === 0.525, "bound model cost mutated in place to 0.70 * 0.75 = 0.525");
+assert(boundModel.cost.output === 2.625, "bound model output mutated to 3.50 * 0.75 = 2.625");
+assert(boundModel.cost.cacheRead === 0.15, "bound model cacheRead mutated to 0.20 * 0.75 = 0.15");
+
+// ─── Test 14: session_start clears status after switch during fetch ─────────
+
+console.log("\n--- Test 14: session_start clears status after switch ---");
+
+// Regression: the session_start background fetch resolves up to ~8s after hook
+// start. If the user switches to a non-lilac model during that window, the
+// deferred callback must NOT re-paint the stale captured lilac model's discount
+// over the clear that model_select issued. syncStatus() reads the LIVE ctx.model
+// (a lazy getter in production), so mutating startCtx.model mid-flight mimics
+// the session model changing and the deferred paint clears instead.
+globalThis.fetch = mockFetch({
+  "/models": { body: { data: [] } }, // no live models → liveModels null
+  "/status": {
+    body: {
+      models: [{
+        id: "moonshotai/kimi-k2.6",
+        current_subscription_supply_state: "healthy",
+        current_subscription_discount_percent: 25,
+        current_subscription_credit_multiplier: "0.75",
+      }],
+    },
+  },
+}) as any;
+
+statuses.clear();
+const startCtx: any = {
+  modelRegistry: mockRegistry,
+  ui: mockUi,
+  model: { id: "moonshotai/kimi-k2.6", provider: "lilac" }, // start on lilac
+  sessionManager: { getBranch: () => [] },
+};
+for (const handler of handlers.get("session_start") || []) {
+  await handler({}, startCtx);
+}
+// Immediate paint reflects the lilac model (still selected at hook start).
+assert(
+  statuses.get("lilac") === "supply: healthy · sub-discount: 25%",
+  "immediate session_start paint shows lilac discount",
+);
+
+// While the background fetch is in flight, the user switches to a non-lilac model.
+startCtx.model = { id: "claude-sonnet-4", provider: "anthropic" };
+
+// Flush the deferred .then() chain (resolveApiKey → fetch → syncStatus).
+await new Promise((r) => setTimeout(r, 100));
+
+assert(
+  statuses.get("lilac") === undefined,
+  "deferred session_start clears status after switch to non-lilac (no stale re-paint)",
+);
+
+// ─── Test 15: before_provider_request clears status after switch ─────────────
+
+console.log("\n--- Test 15: before_provider_request clears status after switch ---");
+
+// Regression: every 30s (when the discount TTL expires) before_provider_request
+// awaits a fresh /status fetch. If the user switches to a non-lilac model during
+// that await, the post-await paint must clear (live model) instead of re-painting
+// the stale captured in-flight lilac model. Cost mutation still targets the
+// captured in-flight model (Tests 12-13); only the DISPLAY follows the live model.
+
+// Force the 30s TTL to look expired so the fetch path executes.
+const realDateNow = Date.now;
+Date.now = () => realDateNow.call(Date) + 60000;
+try {
+  globalThis.fetch = mockFetch({
+    "/status": {
+      body: {
+        // CHANGED discount (low/10%) vs the cached healthy/25% → exercises the
+        // registerProvider + syncStatus path, not just the unchanged early-return.
+        models: [{
+          id: "moonshotai/kimi-k2.6",
+          current_subscription_supply_state: "low",
+          current_subscription_discount_percent: 10,
+          current_subscription_credit_multiplier: "0.90",
+        }],
+      },
+    },
+  }) as any;
+
+  statuses.clear();
+  // Live model holder; reassigning .model mid-await mimics ctx.model being a
+  // lazy getter to the session model.
+  const bprCtx: any = {
+    ui: mockUi,
+    model: { id: "moonshotai/kimi-k2.6", provider: "lilac" },
+  };
+
+  // Kick off before_provider_request; it captures inFlightModel=lilac, mutates
+  // cost, paints, then awaits the fetch (TTL expired).
+  const bprPromise = (async () => {
+    for (const handler of handlers.get("before_provider_request") || []) {
+      await handler({ type: "before_provider_request", payload: {} }, bprCtx);
+    }
+  })();
+
+  // Switch to non-lilac while the fetch is in flight (before the await resumes).
+  bprCtx.model = { id: "claude-sonnet-4", provider: "anthropic" };
+
+  await bprPromise;
+
+  assert(
+    statuses.get("lilac") === undefined,
+    "post-await syncStatus clears after switch to non-lilac (no stale re-paint)",
+  );
+} finally {
+  Date.now = realDateNow;
+}
+
+// ─── Test 16: session_start shows new lilac model after switch ───────────────
+
+console.log("\n--- Test 16: session_start shows new lilac model after switch ---");
+
+// Companion to Test 14: switching to a DIFFERENT lilac model during the fetch
+// must paint the NEW model's discount, proving syncStatus reads the live model
+// (not a stale capture that would show the old model's discount).
+globalThis.fetch = mockFetch({
+  "/models": { body: { data: [] } },
+  "/status": {
+    body: {
+      models: [
+        {
+          id: "moonshotai/kimi-k2.6",
+          current_subscription_supply_state: "healthy",
+          current_subscription_discount_percent: 25,
+          current_subscription_credit_multiplier: "0.75",
+        },
+        {
+          id: "zai-org/glm-5.1",
+          current_subscription_supply_state: "high",
+          current_subscription_discount_percent: 50,
+          current_subscription_credit_multiplier: "0.50",
+        },
+      ],
+    },
+  },
+}) as any;
+
+statuses.clear();
+const startCtx2: any = {
+  modelRegistry: mockRegistry,
+  ui: mockUi,
+  model: { id: "moonshotai/kimi-k2.6", provider: "lilac" }, // start on kimi
+  sessionManager: { getBranch: () => [] },
+};
+for (const handler of handlers.get("session_start") || []) {
+  await handler({}, startCtx2);
+}
+// Switch to a different lilac model (glm) during the in-flight fetch.
+startCtx2.model = { id: "zai-org/glm-5.1", provider: "lilac" };
+await new Promise((r) => setTimeout(r, 100));
+assert(
+  statuses.get("lilac") === "supply: high · sub-discount: 50%",
+  "deferred session_start paints the NEW lilac model's discount (glm), not the stale kimi capture",
+);
+
 // ─── Cleanup ──────────────────────────────────────────────────────────────────
 
 globalThis.fetch = originalFetch;