pi-agent-extensions 0.2.3 → 0.3.1

package/README.md

@@ -32,6 +32,7 @@ Original repository: https://github.com/mitsuhiko/agent-stuff
 | **control** | RPC | Inter-session communication & control | ⚙️ Beta |
 | **answer** | Tool | Structured Q&A for complex queries | ⚙️ Beta |
 | **cwd_history** | Tracker | Tracks directory changes in context | ✅ Stable |
+| **nvidia-nim** | Command | Nvidia NIM auth & config | ✅ Stable |
 
 ## Install
 
@@ -295,6 +296,13 @@ RPC-based session control. Allows sessions to talk to each other (e.g., a "manag
 - Flag: `--session-control`
 - Tool: `send_to_session`
 
+**Nvidia NIM (`/nvidia-nim-auth`)**
+Authenticate and configure Nvidia NIM as an LLM provider.
+- Commands: `/nvidia-nim-auth` (alias: `/nvidia-auth`), `/nvidia-nim-models`
+- Saves provider config to `~/.pi/nvidia-nim.json`
+- Adds configured models to `~/.pi/agent/settings.json` `enabledModels` for scoped `/model` + Ctrl+P cycling
+- Model IDs must be `org/model` (exactly one `/`), e.g. `moonshotai/kimi-k2.5` (not `nvidia/moonshotai/kimi-k2.5`)
+
 ## Development
 
 ```bash

package/extensions/nvidia-nim/README.md

@@ -0,0 +1,62 @@
+# Nvidia NIM Extension
+
+Authenticate and configure the Nvidia NIM provider for the Pi coding agent. Models you add appear directly in the `/model` picker.
+
+## Commands
+
+| Command | Description |
+|---------|-------------|
+| `/nvidia-nim-auth` | Full setup — API key + model editor |
+| `/nvidia-auth` | Alias for `/nvidia-nim-auth` |
+| `/nvidia-nim-models` | Add/edit models (keeps existing API key) |
+
+## Usage
+
+1. **Get an API key** from [build.nvidia.com](https://build.nvidia.com)
+2. Run `/nvidia-nim-auth` in Pi
+3. Paste your `nvapi-...` key
+4. Add model IDs in the editor (one per line), e.g.:
+   ```
+   meta/llama-3.1-405b-instruct
+   deepseek-ai/deepseek-r1
+   moonshotai/kimi-k2.5
+   nvidia/llama-3.1-nemotron-70b-instruct
+   ```
+5. Use `/model` to switch to any registered Nvidia model (also available in scoped model list / Ctrl+P cycling)
+
+To add more models later without re-entering your key, use `/nvidia-nim-models`.
+
+### Model ID format
+
+Model IDs must be `org/model` (exactly one `/`).
+
+✅ Valid:
+- `moonshotai/kimi-k2.5`
+- `nvidia/llama-3.1-nemotron-70b-instruct`
+
+❌ Invalid:
+- `nvidia/moonshotai/kimi-k2.5` (this is provider + org + model)
+
+Invalid lines are ignored during parsing.
+
+## Configuration
+
+Config is saved to `~/.pi/nvidia-nim.json`:
+
+```json
+{
+  "apiKey": "nvapi-...",
+  "models": [
+    { "id": "meta/llama-3.1-405b-instruct", "name": "Llama 3.1 405b Instruct", "reasoning": false },
+    { "id": "deepseek-ai/deepseek-r1", "name": "Deepseek R1", "reasoning": true }
+  ]
+}
+```
+
+Models are registered via `pi.registerProvider()` on startup and after auth, so they show up in `/model` immediately.
+
+The extension also updates `~/.pi/agent/settings.json` `enabledModels` entries for provider `nvidia`, so configured models appear in scoped `/model` and Ctrl+P cycling.
+
+## Browse Models
+
+See all available Nvidia NIM models at: [build.nvidia.com/models](https://build.nvidia.com/models)

package/extensions/nvidia-nim/index.ts

@@ -0,0 +1,250 @@
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import type { OAuthCredentials, OAuthLoginCallbacks } from "@mariozechner/pi-ai/dist/utils/oauth/types.js";
+import * as fs from "node:fs/promises";
+import * as fsSync from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+
+/** Persisted model config (API key is now managed via OAuth in ~/.pi/agent/auth.json) */
+export interface NvidiaModelsConfig {
+  models: NvidiaModelEntry[];
+}
+
+export interface NvidiaModelEntry {
+  id: string;
+  name: string;
+  reasoning: boolean;
+}
+
+const NVIDIA_BASE_URL = "https://integrate.api.nvidia.com/v1";
+const NVIDIA_PROVIDER_NAME = "nvidia";
+const MODEL_EDITOR_TEMPLATE = `# Nvidia NIM Models — one model ID per line
+# Lines starting with # are ignored.
+#
+# Browse available models at: https://build.nvidia.com/models
+#
+# Examples:
+#   meta/llama-3.1-405b-instruct
+#   nvidia/llama-3.1-nemotron-70b-instruct
+#   deepseek-ai/deepseek-r1
+#   google/gemma-2-27b-it
+#   mistralai/mixtral-8x22b-instruct-v0.1
+#   qwen/qwen2.5-72b-instruct
+`;
+
+export function getConfigPath(): string {
+  return path.join(os.homedir(), ".pi", "nvidia-nim.json");
+}
+
+/** Load models config from ~/.pi/nvidia-nim.json (async).
+ *  Handles both new format (models only) and legacy format (with apiKey). */
+export async function loadModelsConfig(): Promise<NvidiaModelsConfig | null> {
+  try {
+    const content = await fs.readFile(getConfigPath(), "utf-8");
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed.models) && parsed.models.length > 0) {
+      return { models: parsed.models };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+/** Synchronous version for use during extension init (before Pi finishes loading).
+ *  Handles both new format (models only) and legacy format (with apiKey). */
+export function loadModelsConfigSync(): NvidiaModelsConfig | null {
+  try {
+    const content = fsSync.readFileSync(getConfigPath(), "utf-8");
+    const parsed = JSON.parse(content);
+    if (Array.isArray(parsed.models) && parsed.models.length > 0) {
+      return { models: parsed.models };
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+
+export async function saveModelsConfig(config: NvidiaModelsConfig): Promise<void> {
+  const configPath = getConfigPath();
+  await fs.mkdir(path.dirname(configPath), { recursive: true });
+  await fs.writeFile(configPath, JSON.stringify(config, null, 2), "utf-8");
+}
+
+/** Parse model IDs from editor text, ignoring comments and blank lines.
+ *  Model IDs must be in "org/model" format (exactly one "/").
+ *  Lines with more than one "/" are skipped (e.g. "nvidia/moonshotai/kimi-k2.5" is invalid). */
+export function parseModelLines(text: string): NvidiaModelEntry[] {
+  const seen = new Set<string>();
+  return text
+    .split("\n")
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0 && !line.startsWith("#"))
+    .filter((line) => (line.match(/\//g) || []).length === 1)
+    .reduce<NvidiaModelEntry[]>((acc, id) => {
+      if (!seen.has(id)) {
+        seen.add(id);
+        acc.push({
+          id,
+          name: formatModelName(id),
+          reasoning: /deepseek-r1|reasoning/i.test(id),
+        });
+      }
+      return acc;
+    }, []);
+}
+
+/** Turn "meta/llama-3.1-405b-instruct" → "Llama 3.1 405B Instruct" */
+function formatModelName(id: string): string {
+  const base = id.includes("/") ? id.split("/").pop()! : id;
+  return base
+    .replace(/[-_]/g, " ")
+    .replace(/\b\w/g, (c) => c.toUpperCase());
+}
+
+/**
+ * Fetch available model IDs from the Nvidia NIM API.
+ * Returns the set of valid model IDs, or null on failure.
+ */
+export async function fetchAvailableModels(apiKey: string): Promise<Set<string> | null> {
+  try {
+    const res = await fetch(`${NVIDIA_BASE_URL}/models`, {
+      headers: { Authorization: `Bearer ${apiKey}` },
+    });
+    if (!res.ok) return null;
+    const data = (await res.json()) as { data?: { id: string }[] };
+    if (!data.data) return null;
+    return new Set(data.data.map((m) => m.id));
+  } catch {
+    return null;
+  }
+}
+
+/** Build the provider model descriptors from our model entries. */
+function buildModelDescriptors(models: NvidiaModelEntry[]) {
+  return models.map((m) => ({
+    id: m.id,
+    name: m.name,
+    reasoning: m.reasoning,
+    input: ["text"] as ("text" | "image")[],
+    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+    contextWindow: 128000,
+    maxTokens: 16384,
+  }));
+}
+
+/** Build the OAuth config for Nvidia NIM API key authentication. */
+function buildOAuthConfig() {
+  return {
+    name: "Nvidia NIM",
+
+    async login(callbacks: OAuthLoginCallbacks): Promise<OAuthCredentials> {
+      const apiKey = await callbacks.onPrompt({
+        message: "Enter your Nvidia NIM API key (nvapi-... from build.nvidia.com):",
+        placeholder: "nvapi-...",
+      });
+
+      if (!apiKey?.trim()) {
+        throw new Error("API key is required. Get one at https://build.nvidia.com");
+      }
+
+      const key = apiKey.trim();
+
+      // Validate by hitting the models endpoint
+      const res = await fetch(`${NVIDIA_BASE_URL}/models`, {
+        headers: { Authorization: `Bearer ${key}` },
+      });
+      if (!res.ok) {
+        throw new Error(
+          `API key validation failed (HTTP ${res.status}). Check your key at build.nvidia.com`,
+        );
+      }
+
+      return {
+        access: key,
+        refresh: key, // API keys don't have refresh tokens
+        expires: Date.now() + 365 * 24 * 60 * 60 * 1000, // effectively never
+      };
+    },
+
+    async refreshToken(credentials: OAuthCredentials): Promise<OAuthCredentials> {
+      // Nvidia API keys don't expire — return as-is with extended expiry
+      return {
+        ...credentials,
+        expires: Date.now() + 365 * 24 * 60 * 60 * 1000,
+      };
+    },
+
+    getApiKey(credentials: OAuthCredentials): string {
+      return credentials.access;
+    },
+  };
+}
+
+export default function nvidiaNimExtension(pi: ExtensionAPI) {
+  // Load saved models synchronously at init so they're available before Pi finishes loading.
+  // The provider is always registered (even without models) so `/login nvidia` works.
+  const savedModels = loadModelsConfigSync();
+  const models = savedModels?.models ?? [];
+
+  pi.registerProvider(NVIDIA_PROVIDER_NAME, {
+    baseUrl: NVIDIA_BASE_URL,
+    api: "openai-completions",
+    models: buildModelDescriptors(models),
+    oauth: buildOAuthConfig(),
+  });
+
+  // --- /nvidia-nim-models: add/edit models ---
+  const modelsHandler = async (args: string | undefined, ctx: ExtensionCommandContext) => {
+    if (!ctx.hasUI) {
+      console.log("This command requires interactive mode.");
+      return;
+    }
+
+    const existing = await loadModelsConfig();
+    const existingModelIds = existing?.models.map((m) => m.id).join("\n") ?? "";
+    const prefill =
+      MODEL_EDITOR_TEMPLATE + "\n" + (existingModelIds || "meta/llama-3.1-405b-instruct") + "\n";
+
+    const modelText = await ctx.ui.editor("Nvidia NIM — Edit Models (one per line)", prefill);
+    if (!modelText?.trim()) {
+      ctx.ui.notify("Cancelled — models unchanged.", "info");
+      return;
+    }
+
+    const parsedModels = parseModelLines(modelText);
+    if (parsedModels.length === 0) {
+      ctx.ui.notify("No valid model IDs found. Models unchanged.", "error");
+      return;
+    }
+
+    try {
+      await saveModelsConfig({ models: parsedModels });
+
+      // Re-register provider with updated models (preserving OAuth config)
+      pi.registerProvider(NVIDIA_PROVIDER_NAME, {
+        baseUrl: NVIDIA_BASE_URL,
+        api: "openai-completions",
+        models: buildModelDescriptors(parsedModels),
+        oauth: buildOAuthConfig(),
+      });
+
+      const names = parsedModels.map((m) => m.id).join(", ");
+      ctx.ui.notify(
+        `Nvidia NIM models updated — ${parsedModels.length} model(s): ${names}. Use /login nvidia to authenticate.`,
+        "info",
+      );
+    } catch (error) {
+      ctx.ui.notify(
+        `Failed to save: ${error instanceof Error ? error.message : String(error)}`,
+        "error",
+      );
+    }
+  };
+
+  pi.registerCommand("nvidia-nim-models", {
+    description: "Add or edit Nvidia NIM models",
+    handler: modelsHandler,
+  });
+}

package/extensions/whimsical/README.md

@@ -1,59 +1,80 @@
-# Whimsical Extension
+# Whimsical Extension (Chaos Mixer)
 
-A personality engine for the [pi coding agent](https://github.com/badlogic/pi-mono/tree/main/packages/coding-agent). Adds delightful, context-aware, and humorous loading messages to make waiting for the LLM less boring.
+A stupid, nerdy, fun, Bollywood-infused loading-message extension for Pi.
 
-## Features
+## What changed
 
-- **Context-Aware Loading Messages**: Messages change based on time of day (Morning/Night) and how long the task is taking.
-- **Multiple Personality Modes**: Choose your vibe, from Bollywood drama to Geek humor.
-- **Smart Exit**: Adds `/exit` and `/bye` commands that perform a graceful shutdown with a whimsical goodbye message (and ensure your terminal is left clean!).
-- **Helpful Tips**: Occasionally shows useful Pi usage tips while you wait.
+Older separate modes (`classic`, `bollywood`, `geek`) are replaced by one chaos mixer with 7 weighted buckets:
 
-## Usage
+- **A**: Absurd Nerd Lines — grepping the void, refactoring by vibes
+- **B**: Boss Progression — phase-based messages by wait duration
+- **C**: Fake Compiler Panic — chaotic fake diagnostics
+- **D**: Terminal Meme Lines — CLI one-liners and git jokes
+- **E**: Bollywood & Hinglish — classic dialogues, movie vibes, desi dev humor
+- **F**: Whimsical Verbs — Combobulating... Skedaddling... Noodling...
+- **G**: Pi Tips — helpful tips for using Pi effectively
 
-The extension activates automatically. You can configure it using the `/whimsy` command.
+Default split is `A=10 / B=10 / C=10 / D=10 / E=30 / F=15 / G=15` (Bollywood-heavy by default).
 
-### Commands
+Context-aware overrides still apply: morning messages (5-11 AM), late night messages (12-4 AM), and long-wait reassurance (>5s).
+
+## Commands
 
 | Command | Description |
-|---------|-------------|
-| `/whimsy` | Check current status and usage. |
-| `/whimsy <mode>` | Switch mode (chaos, bollywood, geek, classic). |
-| `/whimsy on` | Enable whimsical messages. |
-| `/whimsy off` | Disable (revert to standard "Thinking..." messages). |
-| `/exit` | Exit Pi gracefully with a random goodbye message. |
-| `/bye` | Alias for `/exit`. |
-
-### Modes
-
-- **`chaos` (Default)**: A curated mix of everything!
-  - 50% Bollywood/Hinglish
-  - 30% Helpful Tips
-  - 20% Sci-Fi/Classic Gerunds
-- **`bollywood`**: 100% Bollywood dialogues and Hinglish developer memes.
-  - *"Picture abhi baaki hai mere dost..."*
-  - *"Tareekh pe tareekh..."*
-- **`geek`**: Sci-Fi, Cyberpunk, and Developer humor.
-  - *"Reticulating splines..."*
-  - *"Downloading more RAM..."*
-- **`classic`**: Simple, whimsical verbs (Claude-style).
-  - *"Schlepping..."*, *"Combobulating..."*
-
-## Examples
-
-**Long Wait (Story Mode):**
-If a task takes longer than 5 seconds, the message changes to reassure you:
-> "Abhi hum zinda hain!" (We are still alive!)
-> "Sabar ka phal meetha hota hai..." (Patience pays off...)
-
-**Late Night (12 AM - 4 AM):**
-> "Soja beta, varna Gabbar aa jayega..."
-> "Burning the midnight oil..."
-
-## Installation
-
-Included in `pi-agent-extensions`.
-
-```bash
-pi install npm:pi-agent-extensions
+|---|---|
+| `/whimsy` | Open interactive percentage tuner window |
+| `/whimsy on` | Enable whimsical messages |
+| `/whimsy off` | Disable whimsical messages |
+| `/whimsy status` | Show enabled state + current percentages + spinner preset |
+| `/whimsy reset` | Reset to default weights + default spinner preset |
+| `/exit` | Exit Pi with a weighted goodbye (uses current bucket percentages) |
+| `/bye` | Alias for `/exit` |
+
+## Interactive tuner behavior
+
+When you run `/whimsy`, you get a window where:
+
+- a live spinner preview is shown using the current weights
+- preview spinner animates at real-turn cadence and preview message rotates every 10 seconds
+
+- `↑ / ↓` moves between A-G rows and the spinner row at the bottom
+- `← / →` adjusts the selected bucket by **5** (or switches spinner preset when spinner row is selected)
+- spinner row shows a small frame sample next to each preset name
+- `Enter` saves **only if total = 100**
+- `Esc` cancels
+
+Totals are allowed to go below/above 100 while tuning, but save is blocked until total is exactly 100. A warning is shown at the bottom when invalid.
+
+Spinner presets included: Sleek Orbit, Neon Pulse, Scanline, Chevron Flow, Matrix Glyph.
+
+Selected spinner preset is applied to Pi's live loader spinner (not just preview).
+
+Goodbye messages also use A-G bucketed pools and follow the same weighted split.
+
+## Persistence
+
+Settings persist globally in:
+
+- `~/.pi/agent/settings.json` under the `whimsical` key
+
+No local project settings are used for whimsy anymore.
+
+Example:
+
+```json
+{
+  "whimsical": {
+    "enabled": true,
+    "weights": {
+      "A": 10,
+      "B": 10,
+      "C": 10,
+      "D": 10,
+      "E": 30,
+      "F": 15,
+      "G": 15
+    },
+    "spinnerPreset": "sleekOrbit"
+  }
+}
 ```

package/extensions/whimsical/index.ts

@@ -1,99 +1,480 @@
-import type { ExtensionAPI } from "@mariozechner/pi-coding-agent";
-import { BOLLYWOOD_MESSAGES, CONTEXT_MESSAGES, PI_TIPS, WHIMSICAL_VERBS, GOODBYE_MESSAGES } from "./messages.js";
+import type { ExtensionAPI, ExtensionCommandContext } from "@mariozechner/pi-coding-agent";
+import { Key, Loader, matchesKey } from "@mariozechner/pi-tui";
+import * as fs from "node:fs/promises";
+import * as os from "node:os";
+import * as path from "node:path";
+import {
+  ABSURD_NERD_LINES,
+  BOLLYWOOD_MESSAGES,
+  BOSS_PHASE_MESSAGES,
+  CONTEXT_MESSAGES,
+  FAKE_COMPILER_PANIC,
+  GOODBYE_MESSAGES_BY_BUCKET,
+  PI_TIPS,
+  TERMINAL_MEME_LINES,
+  WHIMSICAL_VERBS,
+} from "./messages.js";
 
-type WhimsyMode = 'chaos' | 'classic' | 'bollywood' | 'geek';
+type ChaosBucket = "A" | "B" | "C" | "D" | "E" | "F" | "G";
+
+const ALL_BUCKETS: ChaosBucket[] = ["A", "B", "C", "D", "E", "F", "G"];
+
+const SPINNER_PRESETS = {
+  sleekOrbit: ["◜", "◠", "◝", "◞", "◡", "◟"],
+  neonPulse: ["∙∙●∙∙", "∙●∙●∙", "●∙∙∙●", "∙●∙●∙"],
+  scanline: ["▏", "▎", "▍", "▌", "▋", "▊", "▉", "█", "▉", "▊", "▋", "▌", "▍", "▎"],
+  chevronFlow: [">>>", ">>·", ">··", "···", "·<<", "<<<"],
+  matrixGlyph: ["┆", "╎", "┊", "╏", "┋"],
+} as const;
+
+type SpinnerPresetId = keyof typeof SPINNER_PRESETS;
+
+const SPINNER_PRESET_ORDER: SpinnerPresetId[] = [
+  "sleekOrbit",
+  "neonPulse",
+  "scanline",
+  "chevronFlow",
+  "matrixGlyph",
+];
+
+const SPINNER_PRESET_LABELS: Record<SpinnerPresetId, string> = {
+  sleekOrbit: "Sleek Orbit",
+  neonPulse: "Neon Pulse",
+  scanline: "Scanline",
+  chevronFlow: "Chevron Flow",
+  matrixGlyph: "Matrix Glyph",
+};
 
 interface WhimsyState {
-  mode: WhimsyMode;
   enabled: boolean;
+  chaosWeights: Record<ChaosBucket, number>;
+  spinnerPreset: SpinnerPresetId;
+}
+
+interface PersistedWhimsyConfig {
+  enabled?: boolean;
+  weights?: Partial<Record<ChaosBucket, number>>;
+  spinnerPreset?: string;
 }
 
+interface TunerResult {
+  weights: Record<ChaosBucket, number>;
+  spinnerPreset: SpinnerPresetId;
+}
+
+const BUCKET_META: Array<{ key: ChaosBucket; title: string; description: string }> = [
+  { key: "A", title: "Absurd Nerd Lines", description: "Grepping the void, refactoring by vibes" },
+  { key: "B", title: "Boss Progression", description: "Phase-based messages by wait duration" },
+  { key: "C", title: "Fake Compiler Panic", description: "Chaotic fake diagnostics" },
+  { key: "D", title: "Terminal Meme Lines", description: "CLI one-liners and git jokes" },
+  { key: "E", title: "Bollywood & Hinglish", description: "Dialogues, movie vibes, desi dev humor" },
+  { key: "F", title: "Pi Tips", description: "Helpful tips for using Pi effectively" },
+  { key: "G", title: "Whimsical Verbs", description: "Combobulating... Skedaddling... Noodling..." },
+];
+
+const DEFAULT_WEIGHTS: Record<ChaosBucket, number> = {
+  A: 10, B: 10, C: 10, D: 10, E: 30, F: 15, G: 15,
+};
+const DEFAULT_SPINNER_PRESET: SpinnerPresetId = "sleekOrbit";
+
 const state: WhimsyState = {
-  mode: 'chaos', // Default: The mix you requested
   enabled: true,
+  chaosWeights: { ...DEFAULT_WEIGHTS },
+  spinnerPreset: DEFAULT_SPINNER_PRESET,
 };
 
-function getTimeContext(): 'morning' | 'night' | 'day' {
+let loadedGlobalState = false;
+let loaderSpinnerPatched = false;
+
+const MIN_WORKING_MESSAGE_INTERVAL_MS = 10_000;
+const SPINNER_FRAME_INTERVAL_MS = 100;
+
+let activeWhimsyTicker: ReturnType<typeof setInterval> | null = null;
+let activeTurnStartedAtMs = Date.now();
+let nextWorkingMessageAtMs = Date.now();
+let currentWorkingMessage = "";
+
+function pick<T>(arr: readonly T[]): T {
+  return arr[Math.floor(Math.random() * arr.length)];
+}
+
+function getSpinnerFrames(preset: SpinnerPresetId): readonly string[] {
+  return SPINNER_PRESETS[preset];
+}
+
+function patchGlobalLoaderSpinner(): void {
+  if (loaderSpinnerPatched) return;
+
+  const proto = Loader.prototype as any;
+  const originalUpdateDisplay = proto.updateDisplay;
+  if (typeof originalUpdateDisplay !== "function") return;
+
+  proto.updateDisplay = function patchedUpdateDisplay(this: any, ...args: unknown[]) {
+    const frames = getSpinnerFrames(state.spinnerPreset);
+    if (Array.isArray(frames) && frames.length > 0) {
+      this.frames = [...frames];
+      const current = Number(this.currentFrame ?? 0);
+      this.currentFrame = Number.isFinite(current) ? current % this.frames.length : 0;
+    }
+    return originalUpdateDisplay.apply(this, args);
+  };
+
+  loaderSpinnerPatched = true;
+}
+
+function formatWeights(weights: Record<ChaosBucket, number>): string {
+  return ALL_BUCKETS.map((k) => `${k}=${weights[k]}%`).join(" ");
+}
+
+function formatStatus(): string {
+  return `Whimsy ${state.enabled ? "on" : "off"} | ${formatWeights(state.chaosWeights)} | spinner=${SPINNER_PRESET_LABELS[state.spinnerPreset]}`;
+}
+
+function getTimeContext(): "morning" | "night" | "day" {
   const hour = new Date().getHours();
-  if (hour >= 5 && hour < 11) return 'morning';
-  if (hour >= 0 && hour < 4) return 'night';
-  return 'day';
+  if (hour >= 5 && hour < 11) return "morning";
+  if (hour >= 0 && hour < 4) return "night";
+  return "day";
 }
 
-function pickMessage(mode: WhimsyMode, durationSeconds: number = 0): string {
-  // 1. Check for Long Wait (Overrides everything else if waiting > 5s)
+function pickBossProgression(durationSeconds: number): string {
+  if (durationSeconds < 5) return pick(BOSS_PHASE_MESSAGES.early);
+  if (durationSeconds < 15) return pick(BOSS_PHASE_MESSAGES.mid);
+  return pick(BOSS_PHASE_MESSAGES.late);
+}
+
+function chooseWeightedBucket(weights: Record<ChaosBucket, number>): ChaosBucket {
+  const roll = Math.random() * 100;
+  let cumulative = 0;
+  for (const bucket of ALL_BUCKETS) {
+    cumulative += weights[bucket];
+    if (roll < cumulative) return bucket;
+  }
+  return "E"; // fallback
+}
+
+function pickMessageForBucket(bucket: ChaosBucket, durationSeconds: number): string {
+  switch (bucket) {
+    case "A": return pick(ABSURD_NERD_LINES);
+    case "B": return pickBossProgression(durationSeconds);
+    case "C": return pick(FAKE_COMPILER_PANIC);
+    case "D": return pick(TERMINAL_MEME_LINES);
+    case "E": return pick(BOLLYWOOD_MESSAGES);
+    case "F": return pick(PI_TIPS);
+    case "G": return pick(WHIMSICAL_VERBS);
+  }
+}
+
+function pickWorkingMessageFor(weights: Record<ChaosBucket, number>, durationSeconds: number): string {
+  // Context-aware overrides: time of day and long waits
   if (durationSeconds > 5 && Math.random() > 0.5) {
-     const longMsgs = CONTEXT_MESSAGES.longWait;
-     return longMsgs[Math.floor(Math.random() * longMsgs.length)];
+    return pick(CONTEXT_MESSAGES.longWait);
   }
 
-  // 2. Check for Time Context (Morning/Night special messages)
   const timeContext = getTimeContext();
-  if (timeContext !== 'day' && Math.random() > 0.7) {
-    const timeMsgs = CONTEXT_MESSAGES[timeContext];
-    return timeMsgs[Math.floor(Math.random() * timeMsgs.length)];
+  if (timeContext !== "day" && Math.random() > 0.7) {
+    return pick(CONTEXT_MESSAGES[timeContext]);
   }
 
-  // 3. Mode-based Selection
-  if (mode === 'classic') {
-    return WHIMSICAL_VERBS[Math.floor(Math.random() * WHIMSICAL_VERBS.length)];
+  const selected = chooseWeightedBucket(weights);
+  return pickMessageForBucket(selected, durationSeconds);
+}
+
+function pickGoodbyeMessage(): string {
+  const selected = chooseWeightedBucket(state.chaosWeights);
+  return pick(GOODBYE_MESSAGES_BY_BUCKET[selected]);
+}
+
+function adjustWeightsByStep(
+  weights: Record<ChaosBucket, number>,
+  selected: ChaosBucket,
+  delta: 5 | -5,
+): boolean {
+  const next = weights[selected] + delta;
+  if (next < 0) return false;
+  weights[selected] = next;
+  return true;
+}
+
+function sanitizeWeights(raw?: Partial<Record<ChaosBucket, number>>): Record<ChaosBucket, number> {
+  if (!raw) return { ...DEFAULT_WEIGHTS };
+
+  const out: Record<ChaosBucket, number> = { A: 0, B: 0, C: 0, D: 0, E: 0, F: 0, G: 0 };
+
+  for (const key of ALL_BUCKETS) {
+    const v = Number(raw[key] ?? 0);
+    if (!Number.isFinite(v) || v < 0 || v % 5 !== 0) return { ...DEFAULT_WEIGHTS };
+    out[key] = v;
   }
-  
-  if (mode === 'bollywood') {
-    return BOLLYWOOD_MESSAGES[Math.floor(Math.random() * BOLLYWOOD_MESSAGES.length)];
+
+  const total = ALL_BUCKETS.reduce((sum, k) => sum + out[k], 0);
+  if (total !== 100) return { ...DEFAULT_WEIGHTS };
+  return out;
+}
+
+function sanitizeSpinnerPreset(raw?: string): SpinnerPresetId {
+  if (!raw) return DEFAULT_SPINNER_PRESET;
+  return (SPINNER_PRESET_ORDER as string[]).includes(raw) ? (raw as SpinnerPresetId) : DEFAULT_SPINNER_PRESET;
+}
+
+function cycleSpinnerPreset(current: SpinnerPresetId, direction: -1 | 1): SpinnerPresetId {
+  const index = SPINNER_PRESET_ORDER.indexOf(current);
+  const next = (index + direction + SPINNER_PRESET_ORDER.length) % SPINNER_PRESET_ORDER.length;
+  return SPINNER_PRESET_ORDER[next];
+}
+
+function getSettingsPath(): string {
+  return path.join(os.homedir(), ".pi", "agent", "settings.json");
+}
+
+async function loadStateFromSettings(): Promise<void> {
+  const settingsPath = getSettingsPath();
+  try {
+    const text = await fs.readFile(settingsPath, "utf-8");
+    const parsed = JSON.parse(text) as Record<string, unknown>;
+    const whimsical = (parsed?.whimsical ?? {}) as PersistedWhimsyConfig;
+
+    state.enabled = typeof whimsical.enabled === "boolean" ? whimsical.enabled : true;
+    state.chaosWeights = sanitizeWeights(whimsical.weights);
+    state.spinnerPreset = sanitizeSpinnerPreset(whimsical.spinnerPreset);
+  } catch {
+    state.enabled = true;
+    state.chaosWeights = { ...DEFAULT_WEIGHTS };
+    state.spinnerPreset = DEFAULT_SPINNER_PRESET;
   }
-  
-  if (mode === 'geek') {
-    // Re-use gerunds + tips for now as "geek" substitute + some custom logic could go here
-    return PI_TIPS[Math.floor(Math.random() * PI_TIPS.length)]; 
+}
+
+async function saveStateToSettings(): Promise<void> {
+  const settingsPath = getSettingsPath();
+  const dir = path.dirname(settingsPath);
+
+  let parsed: Record<string, unknown> = {};
+  try {
+    const text = await fs.readFile(settingsPath, "utf-8");
+    parsed = text.trim() ? (JSON.parse(text) as Record<string, unknown>) : {};
+  } catch {
+    parsed = {};
   }
 
-  // CHAOS MODE (The requested 50/30/20 mix)
-  const roll = Math.random();
-  
-  if (roll < 0.5) { 
-    // 50% Bollywood
-    return BOLLYWOOD_MESSAGES[Math.floor(Math.random() * BOLLYWOOD_MESSAGES.length)];
-  } else if (roll < 0.8) { 
-    // 30% Tips
-    return PI_TIPS[Math.floor(Math.random() * PI_TIPS.length)];
-  } else { 
-    // 20% Classic/Smart (Gerunds or Context)
-    return WHIMSICAL_VERBS[Math.floor(Math.random() * WHIMSICAL_VERBS.length)];
+  parsed.whimsical = {
+    enabled: state.enabled,
+    weights: { ...state.chaosWeights },
+    spinnerPreset: state.spinnerPreset,
+  } satisfies PersistedWhimsyConfig;
+
+  await fs.mkdir(dir, { recursive: true });
+  await fs.writeFile(settingsPath, JSON.stringify(parsed, null, 2), "utf-8");
+}
+
+async function ensureStateLoaded(): Promise<void> {
+  if (loadedGlobalState) return;
+  await loadStateFromSettings();
+  loadedGlobalState = true;
+}
+
+function stopActiveTicker(): void {
+  if (activeWhimsyTicker) {
+    clearInterval(activeWhimsyTicker);
+    activeWhimsyTicker = null;
   }
 }
 
-export default function (pi: ExtensionAPI) {
-  // Register Command
+function renderWorkingLine(): string {
+  // Interactive mode already renders its own spinner glyph.
+  // Return message-only text to avoid double spinners.
+  return currentWorkingMessage;
+}
+
+async function openWeightsTuner(ctx: ExtensionCommandContext) {
+  if (!ctx.hasUI) return null;
+
+  return ctx.ui.custom<TunerResult | null>((tui, theme, _kb, done) => {
+    const workingWeights = { ...state.chaosWeights };
+    let workingSpinnerPreset: SpinnerPresetId = state.spinnerPreset;
+    let selectedRow = 0; // 0-6 buckets, 7 spinner row
+    let warning = "";
+
+    const previewStartedAt = Date.now();
+    let previewSpinnerIndex = 0;
+    let nextPreviewMessageAt = Date.now() + MIN_WORKING_MESSAGE_INTERVAL_MS;
+    let previewMessage = pickWorkingMessageFor(workingWeights, 0);
+
+    const previewTicker = setInterval(() => {
+      previewSpinnerIndex += 1;
+      const now = Date.now();
+      if (now >= nextPreviewMessageAt) {
+        const elapsed = (now - previewStartedAt) / 1000;
+        previewMessage = pickWorkingMessageFor(workingWeights, elapsed);
+        nextPreviewMessageAt = now + MIN_WORKING_MESSAGE_INTERVAL_MS;
+      }
+      tui.requestRender();
+    }, SPINNER_FRAME_INTERVAL_MS);
+
+    const finish = (result: TunerResult | null) => {
+      clearInterval(previewTicker);
+      done(result);
+    };
+
+    function totalWeight(): number {
+      return ALL_BUCKETS.reduce((sum, k) => sum + workingWeights[k], 0);
+    }
+
+    function currentPreviewFrame(): string {
+      const frames = getSpinnerFrames(workingSpinnerPreset);
+      return frames[previewSpinnerIndex % frames.length];
+    }
+
+    function render(width: number): string[] {
+      const lines: string[] = [];
+      const hr = theme.fg("accent", "─".repeat(Math.max(8, width)));
+      const add = (line: string) => lines.push(line);
+      const total = totalWeight();
+      const canSave = total === 100;
+
+      add(hr);
+      add(theme.fg("accent", theme.bold(" Whimsy Chaos Mixer")));
+      add(theme.fg("muted", " ↑/↓ move • ←/→ adjust • Enter save (only when total=100) • Esc cancel"));
+      add("");
+
+      for (let i = 0; i < BUCKET_META.length; i++) {
+        const bucket = BUCKET_META[i];
+        const focused = i === selectedRow;
+        const prefix = focused ? theme.fg("accent", "> ") : "  ";
+        const title = `${bucket.key}. ${bucket.title}`;
+        const pct = `${workingWeights[bucket.key]}%`;
+        const main = focused ? theme.fg("accent", `${title.padEnd(30)} ${pct}`) : `${title.padEnd(30)} ${pct}`;
+        add(prefix + main);
+        add(`   ${theme.fg("dim", bucket.description)}`);
+      }
+
+      add("");
+      const spinnerFocused = selectedRow === BUCKET_META.length;
+      const spinnerPrefix = spinnerFocused ? theme.fg("accent", "> ") : "  ";
+      const presetLabel = SPINNER_PRESET_LABELS[workingSpinnerPreset];
+      const sampleFrames = getSpinnerFrames(workingSpinnerPreset).slice(0, 4).join(" ");
+      const spinnerLine = `Spinner Preset: ${presetLabel}  [${sampleFrames}]`;
+      add(spinnerPrefix + (spinnerFocused ? theme.fg("accent", spinnerLine) : spinnerLine));
+      add(`   ${theme.fg("dim", "Use ←/→ on this row to switch between 5 presets")}`);
+
+      add("");
+      add(theme.fg("muted", " Preview"));
+      add(` ${theme.fg("accent", currentPreviewFrame())} ${theme.fg("text", previewMessage)}`);
+
+      add("");
+      add(canSave ? theme.fg("text", ` Total: ${total}%`) : theme.fg("warning", ` Total: ${total}%`));
+      if (!canSave) add(theme.fg("warning", " ⚠ Total must be exactly 100% to save."));
+      if (warning) add(theme.fg("warning", ` ⚠ ${warning}`));
+      add(hr);
+
+      return lines;
+    }
+
+    function handleInput(data: string) {
+      if (matchesKey(data, Key.up)) {
+        warning = "";
+        selectedRow = Math.max(0, selectedRow - 1);
+        tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, Key.down)) {
+        warning = "";
+        selectedRow = Math.min(BUCKET_META.length, selectedRow + 1);
+        tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, Key.left)) {
+        warning = "";
+        if (selectedRow < BUCKET_META.length) {
+          adjustWeightsByStep(workingWeights, BUCKET_META[selectedRow].key, -5);
+        } else {
+          workingSpinnerPreset = cycleSpinnerPreset(workingSpinnerPreset, -1);
+        }
+        tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, Key.right)) {
+        warning = "";
+        if (selectedRow < BUCKET_META.length) {
+          adjustWeightsByStep(workingWeights, BUCKET_META[selectedRow].key, 5);
+        } else {
+          workingSpinnerPreset = cycleSpinnerPreset(workingSpinnerPreset, 1);
+        }
+        tui.requestRender();
+        return;
+      }
+      if (matchesKey(data, Key.enter)) {
+        if (totalWeight() !== 100) {
+          warning = "Cannot save until total equals 100%.";
+          tui.requestRender();
+          return;
+        }
+        finish({ weights: workingWeights, spinnerPreset: workingSpinnerPreset });
+        return;
+      }
+      if (matchesKey(data, Key.escape)) {
+        finish(null);
+      }
+    }
+
+    return {
+      render,
+      invalidate: () => undefined,
+      handleInput,
+    };
+  });
+}
+
+export default function whimsicalExtension(pi: ExtensionAPI) {
+  patchGlobalLoaderSpinner();
+
   pi.registerCommand("whimsy", {
-    description: "Configure whimsical loading messages",
-    handler: async (args) => {
-      const subCommand = args[0];
-      if (subCommand === 'off') {
+    description: "Open chaos mixer + spinner tuner",
+    handler: async (args, ctx) => {
+      await ensureStateLoaded();
+      const sub = (args[0] ?? "").toLowerCase();
+
+      if (sub === "on") {
+        state.enabled = true;
+        await saveStateToSettings();
+        return "Whimsy enabled.";
+      }
+      if (sub === "off") {
         state.enabled = false;
-        return "Whimsical messages disabled.";
+        stopActiveTicker();
+        if (ctx.hasUI) ctx.ui.setWorkingMessage();
+        await saveStateToSettings();
+        return "Whimsy disabled.";
       }
-      if (subCommand === 'on') {
-        state.enabled = true;
-        return "Whimsical messages enabled.";
+      if (sub === "reset") {
+        state.chaosWeights = { ...DEFAULT_WEIGHTS };
+        state.spinnerPreset = DEFAULT_SPINNER_PRESET;
+        await saveStateToSettings();
+        return `Whimsy reset: ${formatStatus()}`;
       }
-      if (['chaos', 'classic', 'bollywood', 'geek'].includes(subCommand)) {
-        state.mode = subCommand as WhimsyMode;
-        return `Whimsy mode set to: ${state.mode}`;
+      if (sub === "status") {
+        return formatStatus();
       }
-      return "Usage: /whimsy [chaos|classic|bollywood|geek|on|off]";
-    }
+
+      if (!ctx.hasUI) {
+        return `${formatStatus()}\nUse interactive mode and run /whimsy to tune weights + spinner.`;
+      }
+
+      const tuned = await openWeightsTuner(ctx);
+      if (!tuned) return "Whimsy unchanged.";
+
+      state.chaosWeights = tuned.weights;
+      state.spinnerPreset = tuned.spinnerPreset;
+      await saveStateToSettings();
+      return `Whimsy updated: ${formatStatus()}`;
+    },
   });
 
-  // Register /exit and /bye
   pi.registerCommand("exit", {
     description: "Exit Pi with a whimsical goodbye",
     handler: async (_args, ctx) => {
-      const msg = GOODBYE_MESSAGES[Math.floor(Math.random() * GOODBYE_MESSAGES.length)];
-      if (ctx.hasUI) {
-        ctx.ui.notify(`👋 ${msg}`, "info");
-      }
-      // Use setImmediate to ensure shutdown happens after command handler completes
+      await ensureStateLoaded();
+      const msg = pickGoodbyeMessage();
+      if (ctx.hasUI) ctx.ui.notify(`👋 ${msg}`, "info");
       setImmediate(() => ctx.shutdown());
     },
   });
@@ -101,45 +482,43 @@ export default function (pi: ExtensionAPI) {
   pi.registerCommand("bye", {
     description: "Exit Pi with a whimsical goodbye (alias)",
     handler: async (_args, ctx) => {
-      const msg = GOODBYE_MESSAGES[Math.floor(Math.random() * GOODBYE_MESSAGES.length)];
-      if (ctx.hasUI) {
-        ctx.ui.notify(`👋 ${msg}`, "info");
-      }
-      // Use setImmediate to ensure shutdown happens after command handler completes
+      await ensureStateLoaded();
+      const msg = pickGoodbyeMessage();
+      if (ctx.hasUI) ctx.ui.notify(`👋 ${msg}`, "info");
       setImmediate(() => ctx.shutdown());
     },
   });
 
-  // Turn Start Logic
   pi.on("turn_start", async (_event, ctx) => {
+    await ensureStateLoaded();
     if (!state.enabled) return;
 
-    // Initial Message
-    ctx.ui.setWorkingMessage(pickMessage(state.mode));
+    stopActiveTicker();
+
+    activeTurnStartedAtMs = Date.now();
+    nextWorkingMessageAtMs = activeTurnStartedAtMs + MIN_WORKING_MESSAGE_INTERVAL_MS;
+    currentWorkingMessage = pickWorkingMessageFor(state.chaosWeights, 0);
+
+    ctx.ui.setWorkingMessage(renderWorkingLine());
 
-    // Dynamic Updates for Long Turns
-    const startTime = Date.now();
-    // Update every 10 seconds to give time to read long messages
-    const interval = setInterval(() => {
+    activeWhimsyTicker = setInterval(() => {
       if (!state.enabled) {
-        clearInterval(interval);
+        stopActiveTicker();
         return;
       }
-      
-      const elapsed = (Date.now() - startTime) / 1000;
-      ctx.ui.setWorkingMessage(pickMessage(state.mode, elapsed));
-    }, 10000);
-
-    // Store interval in a weak map or similar if we needed to clear it externally, 
-    // but turn_end is sufficient.
-    (ctx as any)._whimsyInterval = interval;
+
+      const now = Date.now();
+      if (now >= nextWorkingMessageAtMs) {
+        const elapsed = (now - activeTurnStartedAtMs) / 1000;
+        currentWorkingMessage = pickWorkingMessageFor(state.chaosWeights, elapsed);
+        nextWorkingMessageAtMs = now + MIN_WORKING_MESSAGE_INTERVAL_MS;
+        ctx.ui.setWorkingMessage(renderWorkingLine());
+      }
+    }, SPINNER_FRAME_INTERVAL_MS);
   });
 
-  // Turn End Logic
-  pi.on("turn_end", async (_event, ctx) => {
-    ctx.ui.setWorkingMessage(); // Reset
-    if ((ctx as any)._whimsyInterval) {
-      clearInterval((ctx as any)._whimsyInterval);
-    }
+  // Keep running until the next turn_start replaces cadence.
+  pi.on("turn_end", async () => {
+    // no-op by design
   });
 }

package/extensions/whimsical/messages.ts

@@ -1,5 +1,100 @@
-export type MessageCategory = 'bollywood' | 'smart' | 'tip' | 'gerund';
+// ── Bucket A: Absurd Nerd Lines ──────────────────────────────────────────────
+export const ABSURD_NERD_LINES = [
+  "Grepping the void for meaning...",
+  "Refactoring by vibes and caffeine...",
+  "Rotating the bug 90° to see if it's a feature...",
+  "Converting coffee into TypeScript...",
+  "Asking the rubber duck for architectural guidance...",
+  "Recompiling my self-esteem...",
+  "Summoning stack traces from the 8th dimension...",
+  "Debugging in prod (emotionally)...",
+  "Aligning semicolons with lunar gravity...",
+  "Optimizing for memes per second...",
+  "Upgrading brain RAM to 128MB...",
+  "Consulting the ancient scrolls of Stack Overflow...",
+  "Introducing one more abstraction layer (for science)...",
+  "Measuring latency in dog years...",
+  "Teaching recursion to fear itself...",
+  "Replacing logic with pure confidence...",
+  "Pinning blame on cosmic rays...",
+  "Calibrating keyboard clack acoustics...",
+  "Benchmarking vibes against reality...",
+  "Turning it off and on with conviction...",
+];
+
+// ── Bucket B: Boss Progression (phase-based by wait time) ────────────────────
+export const BOSS_PHASE_MESSAGES = {
+  early: [
+    "🗡️ Boss Fight: Phase 1 — Pulling aggro...",
+    "🎮 Encounter started. Dodging obvious bugs...",
+    "⚔️ Warmup round: sharpening unit tests...",
+    "🧪 Pre-buffing with logs and false confidence...",
+  ],
+  mid: [
+    "🔥 Boss Fight: Phase 2 — Enrage mechanics unlocked...",
+    "🛡️ Raid callout: spread for stack traces!",
+    "💥 The bug used Critical Confusion. It's super effective.",
+    "🎯 Parsing attack patterns and questionable commits...",
+  ],
+  late: [
+    "☠️ Final Phase — clutch mode activated...",
+    "🚨 Enrage timer active. Casting npm install...",
+    "🧠 Last stand: sacrificing sleep for victory...",
+    "🏁 1% HP left on the boss (probably)...",
+  ],
+};
 
+// ── Bucket C: Fake Compiler Panic ────────────────────────────────────────────
+export const FAKE_COMPILER_PANIC = [
+  "warning TS9999: vibes are not strongly typed",
+  "fatal: could not resolve existential dread",
+  "error: semicolon not found, hope not found",
+  "panic: undefined is not a function (of society)",
+  "warning: variable 'motivation' is declared but never used",
+  "error E420: insufficient snacks for build",
+  "linker error: could not link dreams.dll",
+  "runtime warning: coffee level below minimum threshold",
+  "type error: expected genius, received goblin",
+  "internal compiler error: lol",
+  "segfault (core dumped emotionally)",
+  "note: fixed by adding one parenthesis and prayer",
+];
+
+// ── Bucket D: Terminal Meme Lines ────────────────────────────────────────────
+export const TERMINAL_MEME_LINES = [
+  "sudo rm -rf stress && echo 'inner peace installed'",
+  "git commit -m 'fixed bug (created 4 new ones for lore)'",
+  "npm install luck --save-dev",
+  "echo 'it works' | tee production.log",
+  "./deploy.sh && run",
+  "grep -R 'WHY' .",
+  "git push --force-with-confidence",
+  "docker compose up --build --snacks",
+  "kubectl vibes --namespace=prod",
+  "chmod +x brain.sh && ./brain.sh",
+  "cat README.md | cry",
+  "top: CPU 100%, me 2%",
+  "git stash && run && panic",
+  "alias fix='turn it off && turn it on'",
+  "ping google.com for emotional support",
+  "find . -name '*bug*' -delete # legally questionable",
+  "echo 'ship it' && immediately regret it",
+  "git rebase -i destiny",
+  "curl localhost:3000 && pray",
+  "history | tail -n 5 # evidence",
+  "sudo apt install confidence",
+  "yarn add vibes",
+  "pnpm add chaos",
+  "echo 'LGTM' before reading diff",
+  "git blame . # me",
+  "kill -9 procrastination",
+  "mkdir final-final-real-v2",
+  "mv final-final-real-v2 final-final-real-v3",
+  "echo 'quick fix' > tech_debt.txt",
+  "python -c \"print('it was DNS')\"",
+];
+
+// ── Bucket E: Bollywood & Hinglish ───────────────────────────────────────────
 export const BOLLYWOOD_MESSAGES = [
   // --- CLASSIC DIALOGUES (Reimagined for Code) ---
   "Tareekh pe tareekh, tareekh pe tareekh... par result nahi mila my lord!",
@@ -1297,6 +1392,7 @@ export const BOLLYWOOD_MESSAGES = [
   "Sed...",
 ];
 
+// ── Bucket F: Pi Tips ────────────────────────────────────────────────────────
 export const PI_TIPS = [
   "💡 Tip: Use /help to see all available commands",
   "💡 Tip: Use /sessions or /resume to switch between sessions",
@@ -1348,6 +1444,7 @@ export const PI_TIPS = [
   "💡 Tip: Use /name to rename the current session",
 ];
 
+// ── Context-aware messages (time of day + long wait) ─────────────────────────
 export const CONTEXT_MESSAGES = {
   // Morning (5 AM - 11 AM)
   morning: [
@@ -1396,6 +1493,7 @@ export const CONTEXT_MESSAGES = {
   ]
 };
 
+// ── Bucket G: Whimsical Verbs (Gerunds) ──────────────────────────────────────
 // "Gerunds" / Whimsical Verbs (The classic list, kept for variety)
 export const WHIMSICAL_VERBS = [
   "Schlepping...", "Combobulating...", "Vibing...", "Concocting...", "Spelunking...",
@@ -1438,29 +1536,65 @@ export const WHIMSICAL_VERBS = [
   "Shouldering...", "Bouldering...",
 ];
 
-export const GOODBYE_MESSAGES = [
-  "Jaa Simran jaa, jee le apni zindagi...",
-  "Khatam... tata... bye bye!",
-  "Gaya... sab gaya...",
-  "Abhi hum zinda hain! (Just kidding, bye!)",
-  "Picture abhi baaki hai mere dost... (See you next time!)",
-  "Dosti ka ek usool hai madam... no sorry, no thank you... (Bye!)",
-  "Senorita, bade bade deshon mein...",
-  "Thappad se darr nahi lagta sahab, goodbye se lagta hai...",
-  "Khamosh! (Exiting...)",
-  "Mogambo khush hua! (Session ended)",
-  "Hasta la vista, baby!",
-  "I'll be back.",
-  "Live long and prosper.",
-  "May the Force be with you.",
-  "So long, and thanks for all the fish.",
-  "Exiting matrix...",
-  "Disconnecting neural link...",
-  "Powering down systems...",
-  "Shutting down core...",
-  "Deactivating shields...",
-  "Terminating process...",
-  "Closing wormhole...",
-  "Returning to base reality...",
-  "End of line.",
-];
+// ── Goodbye messages by bucket ───────────────────────────────────────────────
+export const GOODBYE_MESSAGES_BY_BUCKET = {
+  A: [
+    "🧠 Nerd goblin logged off. May your stack traces be short.",
+    "📚 Returning to the sacred docs cave. BRB.",
+    "🦆 Rubber duck has approved this exit.",
+    "⚙️ Refactor complete. Human needs snacks now.",
+    "🛰️ Leaving orbit. Keep the semicolons aligned.",
+  ],
+  B: [
+    "🏆 Boss defeated. Loot collected. Logging out.",
+    "⚔️ Raid complete. GG, no re.",
+    "🛡️ Final phase cleared. Retreating to base.",
+    "🎮 Match won. Queueing for sleep mode.",
+    "🔥 Enrage survived. Session extracted successfully.",
+  ],
+  C: [
+    "fatal: user exited with code 0",
+    "warning: goodbye may contain sarcasm",
+    "note: shutdown successful after adding one parenthesis",
+    "panic resolved: touched grass",
+    "compiler says: 'ship it and sleep'",
+  ],
+  D: [
+    "git commit -m 'bye for now' && git push",
+    "exit 0 # works on my machine",
+    "sudo shutdown -h now (emotionally)",
+    "tmux detach; coffee attach",
+    "echo 'brb' | tee /dev/terminal",
+  ],
+  E: [
+    "Jaa Simran jaa, jee le apni zindagi...",
+    "Khatam... tata... bye bye!",
+    "Gaya... sab gaya...",
+    "Abhi hum zinda hain! (Just kidding, bye!)",
+    "Picture abhi baaki hai mere dost... (See you next time!)",
+    "Dosti ka ek usool hai madam... no sorry, no thank you... (Bye!)",
+    "Senorita, bade bade deshon mein...",
+    "Thappad se darr nahi lagta sahab, goodbye se lagta hai...",
+    "Khamosh! (Exiting...)",
+    "Mogambo khush hua! (Session ended)",
+  ],
+  F: [
+    "Hasta la vista, baby!",
+    "I'll be back.",
+    "Live long and prosper.",
+    "May the Force be with you.",
+    "So long, and thanks for all the fish.",
+    "Exiting matrix...",
+    "Disconnecting neural link...",
+    "Powering down systems...",
+    "Shutting down core...",
+    "End of line.",
+  ],
+  G: [
+    "Vamoosing...",
+    "Absquatulating...",
+    "Skedaddling...",
+    "Defenestrating...",
+    "Absconding...",
+  ],
+} as const;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-agent-extensions",
-  "version": "0.2.3",
+  "version": "0.3.1",
   "description": "Collection of extensions for pi coding agent",
   "type": "module",
   "repository": {
@@ -45,7 +45,8 @@
       "./extensions/cwd-history/index.ts",
       "./extensions/session-breakdown/index.ts",
       "./extensions/todos/index.ts",
-      "./extensions/whimsical/index.ts"
+      "./extensions/whimsical/index.ts",
+      "./extensions/nvidia-nim/index.ts"
     ],
     "themes": [
       "./themes/nightowl.json",