pi-lilac-provider 1.7.2 → 1.8.0

package/README.md

@@ -23,7 +23,7 @@ Access Kimi K2.6, GLM 5.1, MiniMax M2.7, and Gemma 4 models through Lilac's Open
 - **Reasoning Models** — Chain-of-thought via `chat_template_kwargs` (all models)
 - **Vision Support** — Image input on Kimi K2.6 and Gemma 4
 - **Context Caching** — Cache read pricing on Kimi K2.6 and GLM 5.1
-- **Flex (Discount Gating)** — Only let the LLM respond when the active model's discount meets a threshold you set (`/lilac-flex`)
+- **Flex (Discount Gating)** — Only let the LLM respond when the active model's discount meets a threshold you set (`/lilac-settings`)
 - **Idle GPU Scheduling** — Lilac leverages idle GPU capacity for cost-efficient inference
 
 ## Installation
@@ -220,7 +220,7 @@ Create `~/.pi/agent/extensions/lilac.json` (auto-populated with defaults on firs
 ```jsonc
 {
   // Only respond when the active model's discount is >= this percent. null = off.
-  // See "Flex (Discount Gating)" below. Set interactively with /lilac-flex.
+  // See "Flex (Discount Gating)" below. Set via /lilac-settings.
   "flexThreshold": null,
   "modelOverrides": {
     // Disable full-history reasoning for kimi-k2.6 (e.g. to save tokens):
@@ -239,16 +239,13 @@ The full set of overridable fields matches the model schema (`compat`, `thinking
 
 Lilac's per-model discount fluctuates with idle-GPU supply. **Flex** lets you set a discount threshold so pi **only sends a prompt to the LLM when the active model's current discount is at or above it** — e.g. "only respond when the discount is ≥ 75%". Below the threshold, the prompt is blocked (dropped with a warning) until the next discount poll brings the discount back up. This is a spend-control feature: you only spend when supply is cheap.
 
-Set it interactively with the `/lilac-flex` command:
+Set it via the **Flex threshold** row in [`/lilac-settings`](#settings-ui) — cycle `off` / `50` / `75`:
 
 ```
-/lilac-flex          # picker: Off / ≥50% / ≥75% / Custom…
-/lilac-flex 75       # set threshold directly (only respond at ≥75% discount)
-/lilac-flex 50%      # trailing % accepted on the command line
-/lilac-flex off      # disable flex (allow all discounts)
+/lilac-settings     # open the settings panel → Flex threshold row
 ```
 
-The threshold persists in `~/.pi/agent/extensions/lilac.json` as `flexThreshold` (a number `0`–`100`, or `null` for off) alongside `modelOverrides`, so it survives restarts. `/lilac-flex` updates it live — no restart needed.
+The threshold persists in `~/.pi/agent/extensions/lilac.json` as `flexThreshold` (a number `0`–`100`, or `null` for off) alongside `modelOverrides`, so it survives restarts. `/lilac-settings` updates it live — no restart needed. For a custom value (e.g. 60), edit `flexThreshold` in that file directly.
 
 Behavior notes:
 
@@ -258,6 +255,17 @@ Behavior notes:
 - **Freshness:** when a prompt is blocked, the extension triggers an immediate `/status` refresh (throttled to once per ~5s) so you're not stuck on a stale low value from the 5-minute idle poll. The next submission sees the fresh discount. The footer status reflects the gate: `… · flex ≥75% ok` or `… · flex ≥75% blocked`.
 - **Discount lock-in:** per Lilac, a discount is locked in when a request starts. Flex gates on the best-known discount at submit time, which is what gets locked in for that turn.
 
+### Settings UI
+
+`/lilac-settings` opens an interactive settings panel (mirrors pi core's `/settings` — bordered `SettingsList`, Esc to go back) to configure Lilac without editing JSON by hand:
+
+- **Flex threshold** (`off` / `50` / `75`) — the spend-control gate from [Flex (Discount Gating)](#flex-discount-gating); custom values via `lilac.json`.
+- **Preserved thinking** (nested submenu, one row per model) — toggles `clear_thinking` (GLM-5.2 / GLM-5.1) / `preserve_thinking` (Kimi K2.6) in `modelOverrides` between **Preserve Thinking** (keep full reasoning history across turns; the default, `clear_thinking: false` / `preserve_thinking: true`) and **Clear Thinking** (let the template drop older reasoning; saves tokens, but can degrade multi-turn recall / cause overthinking).
+
+Changes write to `~/.pi/agent/extensions/lilac.json`, refresh the in-memory config, and re-register the provider, so they take effect immediately — no restart needed.
+
+When you switch to — or start pi on — a Lilac model that carries a preserved-thinking flag (e.g. GLM-5.2 / GLM-5.1, Kimi K2.6), an info notification reports the state and how to change it, e.g. `Preserved thinking ON for glm-5.2 (clear_thinking: false) — suited for coding, but not for prose. Open /lilac-settings to change.` (OFF reads `... reasoning trimmed each turn (lighter; better for prose) ...`). It's an ordinary info notification (not a warning), so it doesn't paint bright yellow.
+
 ## Updating Models
 
 Run the update script to fetch the latest models from Lilac's API:

package/index.ts

@@ -193,7 +193,7 @@ interface LilacConfig {
   modelOverrides?: Record<string, ModelOverride>;
   // Flex discount threshold: only allow interactive prompts to reach the LLM
   // when the active lilac model's discountPercent is >= this. null/undefined =
-  // off (allow all). Set via /lilac-flex; persisted in lilac.json.
+  // off (allow all). Set via /lilac-settings; persisted in lilac.json.
   flexThreshold?: number | null;
 }
 
@@ -312,12 +312,12 @@ function getConfig(): LilacConfig {
 }
 
 // Read-modify-write the config file and refresh the in-memory cache. Used by
-// /lilac-flex so a threshold change takes effect immediately (the input gate and
+// /lilac-settings so a threshold change takes effect immediately (the input gate and
 // footer read getConfig()) without a restart, and without clobbering the user's
 // modelOverrides. Reads via loadConfig (which validates), so modelOverrides the
 // user hand-edited since startup survive the spread. The file is normalized to a
 // discoverable shape (modelOverrides: {}, flexThreshold: null always present) so
-// /lilac-flex never strips the modelOverrides scaffold from the file.
+// /lilac-settings never strips the modelOverrides scaffold from the file.
 function updateConfig(mutator: (cfg: LilacConfig) => LilacConfig): LilacConfig {
   const next = mutator(loadConfig());
   const toWrite: LilacConfig = {
@@ -760,20 +760,9 @@ function syncStatus(ctx: any): void {
   }
 }
 
-// Parse a /lilac-flex argument or custom-threshold input: "off"/"none"/"" → null
-// (disabled), a number in [0,100] (optionally with a trailing %) → that number,
-// anything else → undefined (invalid).
-function parseFlexArg(raw: string): number | null | undefined {
-  const s = raw.trim().toLowerCase().replace(/%$/, "");
-  if (s === "" || s === "off" || s === "none") return null;
-  const n = Number(s);
-  if (!Number.isFinite(n) || n < 0 || n > 100) return undefined;
-  return Math.round(n);
-}
-
 // Persist a flex threshold via updateConfig and report the resulting state against
 // the live model's current discount. The footer is re-painted (syncStatus) so the
-// flex indicator appears immediately. Used by the /lilac-flex command.
+// flex indicator appears immediately. Used by the /lilac-settings flex row.
 function applyFlexThreshold(value: number | null, ctx: any): void {
   updateConfig((cfg) => ({ ...cfg, flexThreshold: value }));
   const threshold = getConfig().flexThreshold ?? null;
@@ -784,16 +773,16 @@ function applyFlexThreshold(value: number | null, ctx: any): void {
   let msg: string;
   let level: "info" | "warning";
   if (threshold == null) {
-    msg = "lilac-flex: off — all discounts allowed";
+    msg = "Flex: off — all discounts allowed";
     level = "info";
   } else if (pct == null) {
-    msg = `lilac-flex: ≥ ${threshold}% — no discount data yet; will block until the next poll`;
+    msg = `Flex: ≥ ${threshold}% — no discount data yet; will block until the next poll`;
     level = "warning";
   } else if (pct >= threshold) {
-    msg = `lilac-flex: ≥ ${threshold}% — current ${pct}% discount allowed`;
+    msg = `Flex: ≥ ${threshold}% — current ${pct}% discount allowed`;
     level = "info";
   } else {
-    msg = `lilac-flex: ≥ ${threshold}% — current ${pct}% discount blocked until it improves`;
+    msg = `Flex: ≥ ${threshold}% — current ${pct}% discount blocked until it improves`;
     level = "warning";
   }
   try {
@@ -862,6 +851,31 @@ export default function (pi: ExtensionAPI) {
   const customModels = customModelsData as JsonModel[];
   const patches = patchData as PatchData;
 
+  // Deferred model_select notify timer — see the model_select handler. Cleared on
+  // rapid re-switch and on session_shutdown so only the latest switch notifies.
+  let modelSelectNotifyTimer: ReturnType<typeof setTimeout> | null = null;
+  const MODEL_SELECT_NOTIFY_DELAY_MS = 250;
+
+  // Notify preserved-thinking state for a preserve-flag model. Computed from the
+  // build pipeline (config as source of truth, not event.model.compat), deferred
+  // so pi core's (and other extensions') notifications land first, and cancelled
+  // on re-switch/shutdown so only the latest shows. Always level "info" (not a
+  // warning) — the text conveys the coding/prose tradeoff.
+  function notifyPreservedThinkingFor(model: any, ctx: any): void {
+    if (!model || model.provider !== PROVIDER_ID) return;
+    const entry = collectPreserveState().find((e: any) => e.id === model.id);
+    if (!entry) return;
+    const flagValue = entry.flag === "clear_thinking" ? !entry.preserved : entry.preserved;
+    const msg = entry.preserved
+      ? `Preserved thinking ON for ${entry.name} (${entry.flag}: ${flagValue}) — suited for coding, but not for prose. Open /lilac-settings to change.`
+      : `Preserved thinking OFF for ${entry.name} (${entry.flag}: ${flagValue}) — reasoning trimmed each turn (lighter; better for prose). Open /lilac-settings to change.`;
+    if (modelSelectNotifyTimer) clearTimeout(modelSelectNotifyTimer);
+    modelSelectNotifyTimer = setTimeout(() => {
+      modelSelectNotifyTimer = null;
+      try { ctx.ui.notify(msg, "info"); } catch { /* notify is a no-op without a UI runner */ }
+    }, MODEL_SELECT_NOTIFY_DELAY_MS);
+  }
+
   // 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.
@@ -981,6 +995,9 @@ export default function (pi: ExtensionAPI) {
     // 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);
+    // Show the preserved-thinking notification on first load / resume if the
+    // active model carries a preserve flag (model_select may not fire on startup).
+    notifyPreservedThinkingFor(ctx.model, ctx);
 
     // Fire-and-forget: resolve API key, then fetch live data in background.
     // Provider and status are hot-swapped when results arrive.
@@ -1110,11 +1127,12 @@ export default function (pi: ExtensionAPI) {
     syncStatus(ctx);
   });
 
-  pi.on("model_select", async (_event, ctx) => {
+  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);
+    notifyPreservedThinkingFor(event.model ?? ctx.model, ctx);
   });
 
   pi.on("session_tree", async (_event, ctx) => {
@@ -1153,7 +1171,7 @@ export default function (pi: ExtensionAPI) {
     };
   });
 
-  // lilac-flex: gate interactive prompts on the active lilac model's discount.
+  // Flex: gate interactive prompts on the active lilac model's discount.
   // Only interactive prompts are gated — extension-injected messages are skipped
   // (programmatic; would loop) and rpc/print are skipped (a silent block would be
   // a confusing failure in automation). A missing discount entry or no data yet
@@ -1177,62 +1195,153 @@ export default function (pi: ExtensionAPI) {
       ? `${discountPercent}% discount`
       : (latestDiscounts ? "no discount on this model (list price)" : "no discount data yet");
     ctx.ui.notify(
-      `lilac-flex: ${desc} < ${threshold}% threshold — blocked until the next poll. Re-submit once the discount improves, or run /lilac-flex to adjust.`,
+      `Flex: ${desc} < ${threshold}% threshold — blocked until the next poll. Re-submit once the discount improves, or open /lilac-settings to adjust.`,
       "warning",
     );
     triggerDiscountRefresh(ctx);
     return { action: "handled" };
   });
 
-  pi.registerCommand("lilac-flex", {
-    description: "Set lilac flex discount threshold — only respond at/above this discount",
-    async handler(args, ctx) {
-      if (!ctx.hasUI) {
-        ctx.ui.notify("/lilac-flex requires interactive mode.", "error");
-        return;
+  // ─── /lilac-settings: settings UI (mirrors pi core /settings) ──────────────
+  // Opens a SettingsList (lazy-imported from pi-tui) via ctx.ui.custom(). Toggles
+  // write to ~/.pi/agent/extensions/lilac.json (modelOverrides for preserved
+  // thinking; flexThreshold via the shared applyFlexThreshold helper), refresh
+  // the in-memory config, bust the list-price model cache, and re-register the
+  // provider so the change takes effect immediately.
+  function collectPreserveState(): Array<{ id: string; name: string; flag: "clear_thinking" | "preserve_thinking"; preserved: boolean }> {
+    const resolved = buildModels(loadStaleModels(embeddedModels), customModels, patches, activeOverrides());
+    const out: Array<{ id: string; name: string; flag: "clear_thinking" | "preserve_thinking"; preserved: boolean }> = [];
+    for (const m of resolved) {
+      const kwargs = (m as any).compat?.chatTemplateKwargs;
+      if (!kwargs || typeof kwargs !== "object") continue;
+      if (typeof kwargs.clear_thinking === "boolean") {
+        out.push({ id: m.id, name: (m as any).name || m.id, flag: "clear_thinking", preserved: kwargs.clear_thinking === false });
+      } else if (typeof kwargs.preserve_thinking === "boolean") {
+        out.push({ id: m.id, name: (m as any).name || m.id, flag: "preserve_thinking", preserved: kwargs.preserve_thinking === true });
       }
+    }
+    return out;
+  }
 
-      const arg = (args ?? "").trim();
-      if (arg) {
-        const value = parseFlexArg(arg);
-        if (value === undefined) {
-          ctx.ui.notify("Usage: /lilac-flex [off | 0-100]", "warning");
-          return;
-        }
-        applyFlexThreshold(value, ctx);
+  pi.registerCommand("lilac-settings", {
+    description: "Configure Lilac: flex discount threshold + preserved thinking per model",
+    async handler(_args, ctx) {
+      if (ctx.mode !== "tui") {
+        ctx.ui.notify("/lilac-settings requires TUI mode.", "error");
         return;
       }
-
-      const current = getConfig().flexThreshold ?? null;
-      const labels = [
-        "Off — allow all discounts",
-        "≥ 50% discount",
-        "≥ 75% discount",
-        "Custom…",
-      ];
-      const choice = await ctx.ui.select("Lilac flex: only respond at/above this discount", labels);
-      if (choice === undefined) return; // cancelled
-
-      let value: number | null;
-      if (choice === labels[0]) value = null;
-      else if (choice === labels[1]) value = 50;
-      else if (choice === labels[2]) value = 75;
-      else {
-        const input = await ctx.ui.input("Threshold (0–100, or 'off'):", String(current ?? ""));
-        if (input === undefined) return; // cancelled
-        const parsed = parseFlexArg(input);
-        if (parsed === undefined) {
-          ctx.ui.notify("Invalid threshold. Use a number 0–100 or 'off'.", "warning");
-          return;
-        }
-        value = parsed;
-      }
-      applyFlexThreshold(value, ctx);
+      const { SettingsList, Container } = await import("@earendil-works/pi-tui");
+      const { getSettingsListTheme, DynamicBorder } = await import("@earendil-works/pi-coding-agent");
+
+      const currentFlex = getConfig().flexThreshold ?? null;
+
+      await ctx.ui.custom((_tui, theme, _kb, done) => {
+        const border = () => new DynamicBorder((s: string) => theme.fg("border", s));
+        // SettingsList left-aligns the value column after the widest label (capped
+        // at 30 cols). A label wider than 30 shifts that row's value out of
+        // alignment, so cap model-name labels.
+        const truncateLabel = (s: string) => (s.length > 30 ? s.slice(0, 27) + "..." : s);
+
+        const items: any[] = [
+          {
+            id: "flex",
+            label: "Flex threshold",
+            description: "Only respond when the active model's discount is at/above this. 'off' allows all. (Custom values: edit ~/.pi/agent/extensions/lilac.json.)",
+            currentValue: currentFlex == null ? "off" : String(currentFlex),
+            values: ["off", "50", "75"],
+          },
+          {
+            id: "preserved-thinking",
+            label: "Preserved thinking",
+            description: "Per-model Preserve Thinking / Clear Thinking (full-history reasoning). Preserve Thinking keeps all turns' reasoning; Clear Thinking lets the template drop older reasoning (saves tokens, can hurt multi-turn recall / cause overthinking).",
+            currentValue: "configure",
+            submenu: (_currentValue: string, subDone: (v?: string) => void) => {
+              // Re-read state on each open so toggles from a previous visit (which
+              // wrote lilac.json + refreshed config) are reflected — a snapshot
+              // captured at panel-open time would show stale values after a toggle.
+              const fresh = collectPreserveState();
+              const subItems = fresh.map((e) => ({
+                id: `preserve:${e.id}`,
+                label: truncateLabel(e.name),
+                description: `${e.id} — Preserve Thinking keeps full reasoning history across turns; Clear Thinking lets the template drop older reasoning (saves tokens, can hurt multi-turn recall / cause overthinking).`,
+                currentValue: e.preserved ? "Preserve Thinking" : "Clear Thinking",
+                values: ["Preserve Thinking", "Clear Thinking"],
+              }));
+              const subList = new SettingsList(
+                subItems,
+                Math.min(subItems.length + 2, 15),
+                getSettingsListTheme(),
+                (id: string, newValue: string) => {
+                  const modelId = id.slice("preserve:".length);
+                  const entry = fresh.find((p) => p.id === modelId);
+                  if (!entry) return;
+                  const preservedOn = newValue === "Preserve Thinking";
+                  const flagValue = entry.flag === "clear_thinking" ? !preservedOn : preservedOn;
+                  updateConfig((cfg) => {
+                    const overrides = cfg.modelOverrides ?? (cfg.modelOverrides = {});
+                    const ov = overrides[modelId] ?? (overrides[modelId] = {});
+                    const compat = ov.compat ?? (ov.compat = {});
+                    const kwargs = compat.chatTemplateKwargs ?? (compat.chatTemplateKwargs = {});
+                    kwargs[entry.flag] = flagValue;
+                    return cfg;
+                  });
+                  listModelsCache = null;
+                  pi.registerProvider("lilac", {
+                    baseUrl: BASE_URL,
+                    apiKey: "$LILAC_API_KEY",
+                    api: "openai-completions",
+                    models: applyDiscounts(getListModels(), latestDiscounts),
+                  });
+                  syncStatus(ctx);
+                  ctx.ui.notify(`Preserved thinking ${preservedOn ? "on" : "off"} for ${entry.name} — takes effect now.`, "info");
+                },
+                () => subDone(),
+                { enableSearch: true },
+              );
+              // The outer container's borders already frame the panel; return the
+              // list directly so we don't render a second border pair.
+              return subList;
+            },
+          },
+        ];
+
+        const container = new Container();
+        container.addChild(border());
+
+        const settingsList = new SettingsList(
+          items,
+          Math.min(items.length + 2, 15),
+          getSettingsListTheme(),
+          (id: string, newValue: string) => {
+            if (id === "flex") {
+              const value = newValue === "off" ? null : Number(newValue);
+              applyFlexThreshold(value, ctx);
+            }
+          },
+          () => done(undefined),
+          { enableSearch: true },
+        );
+        container.addChild(settingsList);
+        container.addChild(border());
+
+        return {
+          render(width: number) {
+            return container.render(width);
+          },
+          invalidate() {
+            container.invalidate();
+          },
+          handleInput(data: string) {
+            settingsList.handleInput?.(data);
+          },
+        };
+      });
     },
   });
 
   pi.on("session_shutdown", () => {
     revalidateAbort?.abort();
+    if (modelSelectNotifyTimer) { clearTimeout(modelSelectNotifyTimer); modelSelectNotifyTimer = null; }
     if (pollInterval) {
       clearInterval(pollInterval);
       pollInterval = null;
@@ -1240,5 +1349,5 @@ export default function (pi: ExtensionAPI) {
   });
 }
 
-export { fetchStatusDiscounts, applyDiscounts, applyDiscountInPlace, loadCachedDiscounts, cacheDiscounts, buildModels, applyModelOverride, parseModelOverrides, parseFlexThreshold, updateConfig, loadConfig, getConfig };
+export { fetchStatusDiscounts, applyDiscounts, applyDiscountInPlace, loadCachedDiscounts, cacheDiscounts, buildModels, applyModelOverride, parseModelOverrides, parseFlexThreshold, updateConfig, loadConfig, getConfig, applyFlexThreshold };
 export type { JsonDiscount, JsonModel, PatchEntry, PatchData, ModelOverride, LilacConfig };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-lilac-provider",
-  "version": "1.7.2",
+  "version": "1.8.0",
   "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-flex.ts

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 /**
- * Tests for the lilac-flex feature: discount-threshold gating.
+ * Tests for the Lilac flex feature: discount-threshold gating.
  *
  * Verifies, against the REAL exported helpers and registered handlers/commands
  * from index.ts (not a re-implementation):
@@ -14,9 +14,9 @@
  *     discount < threshold; allows (continue) when >= threshold, when flex is
  *     off, for non-lilac models, for non-interactive sources, and for models
  *     with no discount entry (treated as 0% -> blocked when flex on).
- *   - /lilac-flex command (integration via the registered handler): direct arg
- *     ("/lilac-flex 75", "off", "50%"), picker presets, custom input, cancel,
- *     invalid arg, and non-interactive guard.
+ *   - applyFlexThreshold (flex configuration, now driven by the /lilac-settings
+ *     flex row): sets flexThreshold, persists to disk, reports state against the
+ *     live model's discount, and is visible to the input gate.
  *
  * Config FS + discount cache are isolated to a temp HOME so nothing touches the
  * real ~/.pi.
@@ -29,7 +29,7 @@ import { getAgentDir, type ExtensionAPI } from "@earendil-works/pi-coding-agent"
 // Isolate config + cache to a temp agent dir so loadConfig/cacheDiscounts never touch
 // the real ~/.pi. Must be set before importing index.ts, which computes
 // CONFIG_PATH / CACHE_PATH at module scope.
-const tmpHome = `/tmp/pi-lilac-flex-test-${Date.now()}`;
+const tmpHome = `/tmp/pi-lilac-test-${Date.now()}`;
 fs.mkdirSync(tmpHome, { recursive: true });
 process.env.HOME = tmpHome;
 process.env.PI_CODING_AGENT_DIR = path.join(tmpHome, ".pi", "agent");
@@ -41,6 +41,7 @@ const {
   getConfig,
   updateConfig,
   cacheDiscounts,
+  applyFlexThreshold,
 } = await import("../index.ts");
 
 let passed = 0;
@@ -167,7 +168,6 @@ cacheDiscounts(new Map([
 ]));
 
 const handlers = new Map<string, ((...args: any[]) => any)[]>();
-const commands = new Map<string, { handler: (...args: any[]) => any }>();
 
 const mockApi: ExtensionAPI = {
   registerProvider: () => {},
@@ -175,9 +175,7 @@ const mockApi: ExtensionAPI = {
     if (!handlers.has(event)) handlers.set(event, []);
     handlers.get(event)!.push(handler);
   },
-  registerCommand: (name: string, opts: any) => {
-    commands.set(name, opts);
-  },
+  registerCommand: () => {},
   appendEntry: () => {},
   exec: async () => ({ exitCode: 0, stdout: "", stderr: "" }),
 } as any;
@@ -266,102 +264,59 @@ updateConfig((c) => ({ ...c, flexThreshold: 25 }));
   eq(result, { action: "continue" }, "25% >= 25% threshold (inclusive) -> continue");
 }
 
-// ─── /lilac-flex command ──────────────────────────────────────────────────────
-
-console.log("\n--- /lilac-flex command ---");
+// ─── applyFlexThreshold (flex configuration, driven by the /lilac-settings row) ─
 
-assert(commands.has("lilac-flex"), "/lilac-flex command registered");
-const cmd = commands.get("lilac-flex")!;
+console.log("\n--- applyFlexThreshold ---");
 
-function runCmd(args: string, opts: { select?: string; input?: string; hasUI?: boolean; model?: any } = {}) {
+function runApply(value: number | null, model: any = { id: KIMI, provider: "lilac" }) {
   const notifications: { msg: string; level: string }[] = [];
   const ctx = {
-    hasUI: opts.hasUI ?? true,
-    model: opts.model ?? { id: KIMI, provider: "lilac" },
+    model,
     ui: {
       notify: (msg: string, level: string) => notifications.push({ msg, level }),
       setStatus: () => {},
       theme: { fg: (_c: string, t: string) => t },
-      select: async (_title: string, _labels: string[]) => opts.select,
-      input: async (_title: string, _placeholder: string) => opts.input,
     },
   };
-  return cmd.handler(args, ctx).then(() => ({ notifications, flexThreshold: getConfig().flexThreshold ?? null }));
-}
-
-// direct numeric arg
-{
-  const { flexThreshold } = await runCmd("75");
-  assert(flexThreshold === 75, "/lilac-flex 75 -> flexThreshold 75");
-  assert(JSON.parse(fs.readFileSync(cfgPath, "utf8")).flexThreshold === 75, "/lilac-flex 75 persisted to disk");
-}
-
-// trailing % accepted
-{
-  const { flexThreshold } = await runCmd("50%");
-  assert(flexThreshold === 50, "/lilac-flex 50% -> flexThreshold 50");
-}
-
-// off keyword
-{
-  const { flexThreshold } = await runCmd("off");
-  assert(flexThreshold === null, "/lilac-flex off -> flexThreshold null");
-}
-
-// invalid arg -> no change, usage notify
-{
-  const { flexThreshold, notifications } = await runCmd("bogus");
-  assert(flexThreshold === null, "/lilac-flex bogus -> no change (still off)");
-  assert(notifications.some((n) => n.msg.includes("Usage")), "/lilac-flex bogus -> usage notify");
-}
-
-// picker: "≥ 75% discount" preset
-{
-  const { flexThreshold } = await runCmd("", { select: "≥ 75% discount" });
-  assert(flexThreshold === 75, "picker '≥ 75% discount' -> 75");
-}
-
-// picker: "Off" preset
-{
-  const { flexThreshold } = await runCmd("", { select: "Off — allow all discounts" });
-  assert(flexThreshold === null, "picker 'Off' -> null");
+  applyFlexThreshold(value, ctx);
+  return { notifications, flexThreshold: getConfig().flexThreshold ?? null };
 }
 
-// picker: "Custom…" then input "60"
+// set 75 (kimi seeded at 25% -> below threshold -> blocked-warning message)
 {
-  const { flexThreshold } = await runCmd("", { select: "Custom…", input: "60" });
-  assert(flexThreshold === 60, "picker Custom + input 60 -> 60");
+  const { flexThreshold, notifications } = runApply(75);
+  assert(flexThreshold === 75, "applyFlexThreshold(75) -> flexThreshold 75");
+  assert(JSON.parse(fs.readFileSync(cfgPath, "utf8")).flexThreshold === 75, "persisted to disk");
+  assert(notifications.some((n) => n.msg.includes("75%") && n.level === "warning"), "75 with kimi@25% -> warning, mentions threshold");
 }
 
-// picker: custom input invalid -> no change, warning
+// off
 {
-  const { flexThreshold, notifications } = await runCmd("", { select: "Custom…", input: "abc" });
-  assert(flexThreshold === 60, "invalid custom input -> no change (still 60)");
-  assert(notifications.some((n) => n.level === "warning" && n.msg.includes("Invalid")), "invalid custom input -> warning notify");
+  const { flexThreshold, notifications } = runApply(null);
+  assert(flexThreshold === null, "applyFlexThreshold(null) -> null");
+  assert(notifications.some((n) => n.msg.includes("off")), "off -> notify mentions off");
 }
 
-// picker cancelled (select returns undefined) -> no change, no notify
+// threshold below current discount -> allowed (info)
 {
-  const { flexThreshold, notifications } = await runCmd("", { select: undefined });
-  assert(flexThreshold === 60, "picker cancelled -> no change (still 60)");
-  assert(notifications.length === 0, "picker cancelled -> no notify");
+  const { notifications } = runApply(20);
+  assert(notifications.some((n) => n.level === "info" && n.msg.includes("allowed")), "20 with kimi@25% -> info, allowed");
 }
 
-// non-interactive guard -> error notify, no change
+// no discount data for model -> warning
 {
-  const { flexThreshold, notifications } = await runCmd("75", { hasUI: false });
-  assert(flexThreshold === 60, "non-interactive -> no change (still 60)");
-  assert(notifications.some((n) => n.level === "error" && n.msg.includes("interactive")), "non-interactive -> error notify");
+  const { notifications } = runApply(75, { id: "zai-org/glm-5.1", provider: "lilac" });
+  assert(notifications.some((n) => n.level === "warning" && n.msg.includes("no discount data")), "uncached model + threshold -> warning, no discount data");
 }
 
-// setting flex via command is visible to the gate (config cache in sync)
+// setting flex via applyFlexThreshold is visible to the gate (config cache in sync)
 {
-  await runCmd("75");
+  runApply(75);
   const { result } = await runInput("interactive", { id: KIMI, provider: "lilac" });
-  eq(result, { action: "handled" }, "after /lilac-flex 75, gate blocks kimi@25%");
-  await runCmd("off");
+  eq(result, { action: "handled" }, "after applyFlexThreshold(75), gate blocks kimi@25%");
+  runApply(null);
   const { result: afterOff } = await runInput("interactive", { id: KIMI, provider: "lilac" });
-  eq(afterOff, { action: "continue" }, "after /lilac-flex off, gate allows kimi@25%");
+  eq(afterOff, { action: "continue" }, "after applyFlexThreshold(null), gate allows kimi@25%");
 }
 
 // ─── Summary ───────────────────────────────────────────────────────────────────