pi-powerline-footer 0.2.14 → 0.2.17

package/CHANGELOG.md

@@ -2,6 +2,37 @@
 
 ## [Unreleased]
 
+## [0.2.17] - 2026-01-28
+
+### Added
+- **Working Vibes** — AI-generated themed loading messages that match your preferred style
+  - Set a theme with `/vibe star trek` and loading messages become "Running diagnostics..." instead of "Working..."
+  - Configure via `settings.json`: `"workingVibe": "pirate"` for nautical-themed messages
+  - Supports any theme: star trek, pirate, zen, noir, cowboy, etc.
+  - Shows "Channeling {theme}..." placeholder, then updates when AI responds (within 3s timeout)
+  - **Auto-refresh on tool calls** — Generates new vibes during long tasks (rate-limited, default 30s)
+  - Configurable refresh interval via `workingVibeRefreshInterval` (in seconds)
+  - Custom prompt templates via `workingVibePrompt` with `{theme}` and `{task}` variables
+  - Uses claude-haiku-4-5 by default (~$0.000015/generation), configurable via `/vibe model` or `workingVibeModel` setting
+
+### Fixed
+- **Event handlers now use correct events** — Replaced non-existent `stream_start`/`stream_end` with `agent_start`/`agent_end`
+- **Removed duplicate powerline bar** — Footer no longer renders redundant status during streaming
+
+## [0.2.16] - 2026-01-28
+
+### Fixed
+- **Model and path colors restored** — Fixed color regression from v0.2.13 theme refactor:
+  - Model segment now uses original pink (`#d787af`) instead of white/gray (`text`)
+  - Path segment now uses original cyan (`#00afaf`) instead of muted gray
+
+## [0.2.15] - 2026-01-27
+
+### Added
+- **Status notifications above editor** — Extension status messages that look like notifications (e.g., `[pi-annotate] Received: CANCEL`) now appear on a separate line above the editor input
+- Notification-style statuses (starting with `[`) appear above editor
+- Compact statuses (e.g., `MCP: 6 servers`) remain in the powerline bar
+
 ## [0.2.14] - 2026-01-26
 
 ### Fixed

package/README.md

@@ -6,6 +6,8 @@ A powerline-style status bar and welcome header extension for [pi](https://githu
 
 ## Features
 
+**Working Vibes** — AI-generated themed loading messages. Set `/vibe star trek` and your "Working..." becomes "Running diagnostics..." or "Engaging warp drive...". Supports any theme: pirate, zen, noir, cowboy, etc.
+
 **Welcome overlay** — Branded splash screen shown as centered overlay on startup. Shows gradient logo, model info, keyboard tips, loaded AGENTS.md/extensions/skills/templates counts, and recent sessions. Auto-dismisses after 30 seconds or on any key press.
 
 **Rounded box design** — Status renders directly in the editor's top border, not as a separate footer.
@@ -23,10 +25,10 @@ A powerline-style status bar and welcome header extension for [pi](https://githu
 ## Installation
 
 ```bash
-npx pi-powerline-footer
+pi install npm:pi-powerline-footer
 ```
 
-This copies the extension to `~/.pi/agent/extensions/powerline-footer/`. Restart pi to activate.
+Restart pi to activate.
 
 ## Usage
 
@@ -43,6 +45,46 @@ Activates automatically. Toggle with `/powerline`, switch presets with `/powerli
 
 **Environment:** `POWERLINE_NERD_FONTS=1` to force Nerd Fonts, `=0` for ASCII.
 
+## Working Vibes
+
+Transform boring "Working..." messages into themed phrases that match your style:
+
+```
+/vibe star trek    → "Running diagnostics...", "Engaging warp drive..."
+/vibe pirate       → "Hoisting the sails...", "Charting course..."
+/vibe zen          → "Breathing deeply...", "Finding balance..."
+/vibe noir         → "Following the trail...", "Checking the angles..."
+/vibe              → Shows current theme and model
+/vibe off          → Disables (back to "Working...")
+/vibe model        → Shows current model
+/vibe model openai/gpt-4o-mini → Use a different model for generation
+```
+
+### Configuration
+
+In `~/.pi/agent/settings.json`:
+
+```json
+{
+  "workingVibe": "star trek",                              // Theme phrase
+  "workingVibeModel": "anthropic/claude-haiku-4-5",        // Optional: model to use (default)
+  "workingVibeFallback": "Working",                        // Optional: fallback message
+  "workingVibeRefreshInterval": 30,                        // Optional: seconds between refreshes (default 30)
+  "workingVibePrompt": "Generate a {theme} loading message for: {task}"  // Optional: custom prompt template
+}
+```
+
+**Prompt template variables:**
+- `{theme}` — the current vibe theme (e.g., "star trek", "mafia")
+- `{task}` — the current task hint (user prompt or tool action, truncated to 100 chars)
+
+**How it works:**
+1. When you send a message, shows "Channeling {theme}..." placeholder
+2. AI generates a themed message in the background (3s timeout)
+3. Message updates to the themed version (e.g., "Engaging warp drive...")
+4. During long tasks, refreshes on tool calls (rate-limited, default 30s)
+5. Cost: ~$0.000015 per generation (60 tokens @ haiku pricing)
+
 ## Thinking Level Display
 
 The thinking segment shows live updates when you change thinking level:

package/index.ts

@@ -12,6 +12,17 @@ import { getGitStatus, invalidateGitStatus, invalidateGitBranch } from "./git-st
 import { ansi, getFgAnsiCode } from "./colors.js";
 import { WelcomeComponent, WelcomeHeader, discoverLoadedCounts, getRecentSessions } from "./welcome.js";
 import { getDefaultColors } from "./theme.js";
+import { 
+  initVibeManager, 
+  onVibeBeforeAgentStart, 
+  onVibeAgentStart, 
+  onVibeAgentEnd,
+  onVibeToolCall,
+  getVibeTheme,
+  setVibeTheme,
+  getVibeModel,
+  setVibeModel,
+} from "./working-vibes.js";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Configuration
@@ -56,33 +67,6 @@ function renderSegmentWithWidth(
   return { content: rendered.content, width: visibleWidth(rendered.content), visible: true };
 }
 
-/** Build status content from a list of segment IDs */
-function buildStatusContentFromSegments(
-  segmentIds: StatusLineSegmentId[],
-  ctx: SegmentContext,
-  presetDef: ReturnType<typeof getPreset>
-): string {
-  const separatorDef = getSeparator(presetDef.separator);
-  const sepAnsi = getFgAnsiCode("sep");
-
-  // Collect visible segment contents
-  const parts: string[] = [];
-  for (const segId of segmentIds) {
-    const rendered = renderSegment(segId, ctx);
-    if (rendered.visible && rendered.content) {
-      parts.push(rendered.content);
-    }
-  }
-
-  if (parts.length === 0) {
-    return "";
-  }
-
-  // Build content with powerline separators (no background)
-  const sep = separatorDef.left;
-  return " " + parts.join(` ${sepAnsi}${sep}${ansi.reset} `) + ansi.reset + " ";
-}
-
 /** Build content string from pre-rendered parts */
 function buildContentFromParts(
   parts: string[],
@@ -156,12 +140,6 @@ function computeResponsiveLayout(
   };
 }
 
-/** Build primary status content (for top border) - legacy, used during streaming */
-function buildStatusContent(ctx: SegmentContext, presetDef: ReturnType<typeof getPreset>): string {
-  const allSegments = [...presetDef.leftSegments, ...presetDef.rightSegments];
-  return buildStatusContentFromSegments(allSegments, ctx, presetDef);
-}
-
 // ═══════════════════════════════════════════════════════════════════════════
 // Extension
 // ═══════════════════════════════════════════════════════════════════════════
@@ -193,6 +171,9 @@ export default function powerlineFooter(pi: ExtensionAPI) {
       getThinkingLevelFn = () => ctx.getThinkingLevel();
     }
     
+    // Initialize vibe manager (needs modelRegistry from ctx)
+    initVibeManager(ctx);
+    
     if (enabled && ctx.hasUI) {
       setupCustomEditor(ctx);
       // quietStartup: true → compact header, otherwise → full overlay
@@ -246,16 +227,27 @@ export default function powerlineFooter(pi: ExtensionAPI) {
     }
   });
 
+  // Generate themed working message before agent starts (has access to user's prompt)
+  pi.on("before_agent_start", async (event, ctx) => {
+    if (ctx.hasUI) {
+      onVibeBeforeAgentStart(event.prompt, ctx.ui.setWorkingMessage);
+    }
+  });
+
   // Track streaming state (footer only shows status during streaming)
   // Also dismiss welcome when agent starts responding (handles `p "command"` case)
-  pi.on("stream_start", async (_event, ctx) => {
+  pi.on("agent_start", async (_event, ctx) => {
     isStreaming = true;
+    onVibeAgentStart();
     dismissWelcome(ctx);
   });
 
-  // Also dismiss on tool calls (agent is working)
-  pi.on("tool_call", async (_event, ctx) => {
+  // Also dismiss on tool calls (agent is working) + refresh vibe if rate limit allows
+  pi.on("tool_call", async (event, ctx) => {
     dismissWelcome(ctx);
+    if (ctx.hasUI) {
+      onVibeToolCall(event.toolName, event.input, ctx.ui.setWorkingMessage);
+    }
   });
 
   // Helper to dismiss welcome overlay/header
@@ -273,8 +265,11 @@ export default function powerlineFooter(pi: ExtensionAPI) {
     }
   }
 
-  pi.on("stream_end", async () => {
+  pi.on("agent_end", async (_event, ctx) => {
     isStreaming = false;
+    if (ctx.hasUI) {
+      onVibeAgentEnd(ctx.ui.setWorkingMessage); // working-vibes internal state + reset message
+    }
   });
 
   // Dismiss welcome overlay/header on first user message
@@ -301,6 +296,7 @@ export default function powerlineFooter(pi: ExtensionAPI) {
           ctx.ui.setFooter(undefined);
           ctx.ui.setHeader(undefined);
           ctx.ui.setWidget("powerline-secondary", undefined);
+          ctx.ui.setWidget("powerline-status", undefined);
           footerDataRef = null;
           tuiRef = null;
           // Clear layout cache
@@ -329,6 +325,51 @@ export default function powerlineFooter(pi: ExtensionAPI) {
     },
   });
 
+  // Command to set working message theme
+  pi.registerCommand("vibe", {
+    description: "Set working message theme. Usage: /vibe [theme|off|model [provider/model]]",
+    handler: async (args, ctx) => {
+      const parts = args?.trim().split(/\s+/) || [];
+      const subcommand = parts[0]?.toLowerCase();
+      
+      // No args: show current status
+      if (!args || !args.trim()) {
+        const theme = getVibeTheme();
+        const model = getVibeModel();
+        ctx.ui.notify(`Vibe: ${theme || "off"} | Model: ${model}`, "info");
+        return;
+      }
+      
+      // /vibe model [spec] - show or set model
+      if (subcommand === "model") {
+        const modelSpec = parts.slice(1).join(" ");
+        if (!modelSpec) {
+          ctx.ui.notify(`Current vibe model: ${getVibeModel()}`, "info");
+          return;
+        }
+        // Validate format (provider/modelId)
+        if (!modelSpec.includes("/")) {
+          ctx.ui.notify("Invalid model format. Use: provider/modelId (e.g., anthropic/claude-haiku-4-5)", "error");
+          return;
+        }
+        setVibeModel(modelSpec);
+        ctx.ui.notify(`Vibe model set to: ${modelSpec}`, "info");
+        return;
+      }
+      
+      // /vibe off - disable
+      if (subcommand === "off") {
+        setVibeTheme(null);
+        ctx.ui.notify("Vibe disabled", "info");
+        return;
+      }
+      
+      // /vibe <theme> - set theme (preserve original casing)
+      setVibeTheme(args.trim());
+      ctx.ui.notify(`Vibe set to: ${args.trim()}`, "info");
+    },
+  });
+
   function buildSegmentContext(ctx: any, width: number, theme: Theme): SegmentContext {
     const presetDef = getPreset(config.preset);
     const colors: ColorScheme = presetDef.colors ?? getDefaultColors();
@@ -519,66 +560,25 @@ export default function powerlineFooter(pi: ExtensionAPI) {
         return editor;
       });
 
-      // Set up footer data provider access via a minimal footer
-      ctx.ui.setFooter((tui: any, theme: Theme, footerData: ReadonlyFooterDataProvider) => {
+      // Set up footer data provider access (needed for git branch, extension statuses)
+      // Note: We don't render status here - it's already in the editor's top border
+      ctx.ui.setFooter((tui: any, _theme: Theme, footerData: ReadonlyFooterDataProvider) => {
         footerDataRef = footerData;
         tuiRef = tui; // Store TUI reference for re-renders on git branch changes
         const unsub = footerData.onBranchChange(() => tui.requestRender());
 
         return {
           dispose: unsub,
-          invalidate() {
-            // No cache to clear - render is always fresh
-          },
-          render(width: number): string[] {
-            if (!currentCtx) return [];
-            
-            const presetDef = getPreset(config.preset);
-            const segmentCtx = buildSegmentContext(currentCtx, width, theme);
-            const lines: string[] = [];
-            
-            // During streaming, show primary status in footer (editor hidden)
-            if (isStreaming) {
-              const statusContent = buildStatusContent(segmentCtx, presetDef);
-              if (statusContent) {
-                const statusWidth = visibleWidth(statusContent);
-                if (statusWidth <= width) {
-                  lines.push(statusContent + " ".repeat(width - statusWidth));
-                } else {
-                  // Truncate by removing segments until it fits
-                  // Start from leftSegments.length to try "just leftSegments" when rightSegments exists
-                  let truncatedContent = "";
-                  let foundFit = false;
-                  for (let numSegments = presetDef.leftSegments.length; numSegments >= 1; numSegments--) {
-                    const limitedPreset = {
-                      ...presetDef,
-                      leftSegments: presetDef.leftSegments.slice(0, numSegments),
-                      rightSegments: [],
-                    };
-                    truncatedContent = buildStatusContent(segmentCtx, limitedPreset);
-                    const truncWidth = visibleWidth(truncatedContent);
-                    if (truncWidth <= width - 1) {
-                      truncatedContent += "…";
-                      foundFit = true;
-                      break;
-                    }
-                  }
-                  // Only push if we found a fit, otherwise skip (don't crash on very narrow terminals)
-                  if (foundFit) {
-                    lines.push(truncatedContent);
-                  }
-                }
-              }
-            }
-            
-            return lines;
+          invalidate() {},
+          render(): string[] {
+            return []; // Status is in editor top border, not footer
           },
         };
       });
 
       // Set up secondary row as a widget below editor (above sub bar)
       // Shows overflow segments when top bar is too narrow
-      ctx.ui.setWidget("powerline-secondary", (tui: any, theme: Theme) => {
+      ctx.ui.setWidget("powerline-secondary", (_tui: any, theme: Theme) => {
         return {
           dispose() {},
           invalidate() {},
@@ -601,6 +601,37 @@ export default function powerlineFooter(pi: ExtensionAPI) {
           },
         };
       }, { placement: "belowEditor" });
+
+      // Set up status notifications widget above editor
+      // Shows extension status messages that look like notifications (e.g., "[pi-annotate] Received: CANCEL")
+      // Compact statuses (e.g., "MCP: 6 servers") stay in the powerline bar via extension_statuses segment
+      ctx.ui.setWidget("powerline-status", () => {
+        return {
+          dispose() {},
+          invalidate() {},
+          render(width: number): string[] {
+            if (!currentCtx || !footerDataRef) return [];
+            
+            const statuses = footerDataRef.getExtensionStatuses();
+            if (!statuses || statuses.size === 0) return [];
+            
+            // Collect notification-style statuses (those starting with "[extensionName]")
+            const notifications: string[] = [];
+            for (const value of statuses.values()) {
+              if (value && value.trimStart().startsWith('[')) {
+                // Account for leading space when checking width
+                const lineContent = ` ${value}`;
+                const contentWidth = visibleWidth(lineContent);
+                if (contentWidth <= width) {
+                  notifications.push(lineContent);
+                }
+              }
+            }
+            
+            return notifications;
+          },
+        };
+      }, { placement: "aboveEditor" });
     });
   }
 
@@ -634,7 +665,7 @@ export default function powerlineFooter(pi: ExtensionAPI) {
     // Small delay to let pi-mono finish initialization
     setTimeout(() => {
       // Skip overlay if:
-      // 1. Dismissal was explicitly requested (stream_start/user_message fired)
+      // 1. Dismissal was explicitly requested (agent_start/user_message fired)
       // 2. Agent is already streaming
       // 3. Session already has assistant messages (agent already responded)
       if (welcomeOverlayShouldDismiss || isStreaming) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "pi-powerline-footer",
-  "version": "0.2.14",
+  "version": "0.2.17",
   "description": "Powerline-style status bar extension for pi coding agent",
   "type": "module",
   "bin": {

package/segments.ts

@@ -389,10 +389,13 @@ const extensionStatusesSegment: StatusLineSegment = {
     const statuses = ctx.extensionStatuses;
     if (!statuses || statuses.size === 0) return { content: "", visible: false };
 
-    // Join all extension statuses with a separator
+    // Join compact statuses with a separator
+    // Notification-style statuses (starting with "[") are shown above the editor instead
     const parts: string[] = [];
-    for (const [_key, value] of statuses) {
-      if (value) parts.push(value);
+    for (const value of statuses.values()) {
+      if (value && !value.trimStart().startsWith('[')) {
+        parts.push(value);
+      }
     }
 
     if (parts.length === 0) return { content: "", visible: false };

package/theme.ts

@@ -16,8 +16,8 @@ import type { ColorScheme, ColorValue, SemanticColor } from "./types.js";
 // Default color scheme (uses pi theme colors)
 const DEFAULT_COLORS: Required<ColorScheme> = {
   pi: "accent",
-  model: "text",
-  path: "muted",
+  model: "#d787af",  // Pink/mauve (matching original colors.ts)
+  path: "#00afaf",  // Teal/cyan (matching original colors.ts)
   git: "success",
   gitDirty: "warning",
   gitClean: "success",

package/working-vibes.ts

@@ -0,0 +1,348 @@
+// working-vibes.ts
+// AI-generated contextual working messages that match a user's preferred theme/vibe.
+// Uses module-level state (matching powerline-footer pattern).
+
+import { complete, type Context } from "@mariozechner/pi-ai";
+import type { ExtensionContext } from "@mariozechner/pi-coding-agent";
+import { existsSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Constants
+// ═══════════════════════════════════════════════════════════════════════════
+
+const DEFAULT_MODEL = "anthropic/claude-haiku-4-5";
+
+const DEFAULT_PROMPT = `Generate a 2-4 word "{theme}" themed loading message ending in "...".
+
+Task: {task}
+
+The message should hint at what's being done, but in theme vocabulary.
+Examples for "mafia" theme: "Checking the ledger...", "Consulting the family...", "Making arrangements..."
+Examples for "star trek" theme: "Scanning sensors...", "Analyzing data...", "Running diagnostics..."
+
+Output only the message, nothing else.`;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Types
+// ═══════════════════════════════════════════════════════════════════════════
+
+interface VibeConfig {
+  theme: string | null;        // null = disabled
+  modelSpec: string;           // default: "anthropic/claude-haiku-4-5"
+  fallback: string;            // default: "Working"
+  timeout: number;             // default: 3000ms
+  refreshInterval: number;     // default: 30000ms (30s)
+  promptTemplate: string;      // template with {theme} and {task} placeholders
+}
+
+interface VibeGenContext {
+  theme: string;
+  userPrompt: string;          // from event.prompt in before_agent_start
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Module-level State
+// ═══════════════════════════════════════════════════════════════════════════
+
+let config: VibeConfig = loadConfig();
+let extensionCtx: ExtensionContext | null = null;
+let currentGeneration: AbortController | null = null;
+let isStreaming = false;
+let lastVibeTime = 0;
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Configuration Management
+// ═══════════════════════════════════════════════════════════════════════════
+
+function getSettingsPath(): string {
+  const homeDir = process.env.HOME || process.env.USERPROFILE || "";
+  return join(homeDir, ".pi", "agent", "settings.json");
+}
+
+function loadConfig(): VibeConfig {
+  const settingsPath = getSettingsPath();
+  
+  let settings: Record<string, unknown> = {};
+  try {
+    if (existsSync(settingsPath)) {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    }
+  } catch {}
+  
+  // Handle "off" in settings.json (same as null/disabled)
+  const rawTheme = typeof settings.workingVibe === "string" ? settings.workingVibe : null;
+  const theme = rawTheme?.toLowerCase() === "off" ? null : rawTheme;
+  
+  return {
+    theme,
+    modelSpec: typeof settings.workingVibeModel === "string" ? settings.workingVibeModel : DEFAULT_MODEL,
+    fallback: typeof settings.workingVibeFallback === "string" ? settings.workingVibeFallback : "Working",
+    timeout: 3000,
+    refreshInterval: typeof settings.workingVibeRefreshInterval === "number" 
+      ? settings.workingVibeRefreshInterval * 1000  // config is in seconds
+      : 30000, // default 30s
+    promptTemplate: typeof settings.workingVibePrompt === "string" ? settings.workingVibePrompt : DEFAULT_PROMPT,
+  };
+}
+
+function saveConfig(): void {
+  const settingsPath = getSettingsPath();
+  
+  try {
+    let settings: Record<string, unknown> = {};
+    if (existsSync(settingsPath)) {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    }
+    
+    if (config.theme === null) {
+      delete settings.workingVibe;
+    } else {
+      settings.workingVibe = config.theme;
+    }
+    
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  } catch (error) {
+    console.debug("[working-vibes] Failed to save settings:", error);
+  }
+}
+
+function saveModelConfig(): void {
+  const settingsPath = getSettingsPath();
+  
+  try {
+    let settings: Record<string, unknown> = {};
+    if (existsSync(settingsPath)) {
+      settings = JSON.parse(readFileSync(settingsPath, "utf-8"));
+    }
+    
+    // Only save if different from default
+    if (config.modelSpec === DEFAULT_MODEL) {
+      delete settings.workingVibeModel;
+    } else {
+      settings.workingVibeModel = config.modelSpec;
+    }
+    
+    writeFileSync(settingsPath, JSON.stringify(settings, null, 2));
+  } catch (error) {
+    console.debug("[working-vibes] Failed to save model settings:", error);
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Prompt Building & Response Parsing (Pure Functions)
+// ═══════════════════════════════════════════════════════════════════════════
+
+function buildVibePrompt(ctx: VibeGenContext): string {
+  // Truncate user prompt to save tokens (most context in first 100 chars)
+  const task = ctx.userPrompt.slice(0, 100);
+  
+  // Use configured template with variable substitution
+  return config.promptTemplate
+    .replace(/\{theme\}/g, ctx.theme)
+    .replace(/\{task\}/g, task);
+}
+
+function parseVibeResponse(response: string, fallback: string): string {
+  if (!response) return `${fallback}...`;
+  
+  // Take only the first line (AI sometimes adds explanations)
+  let vibe = response.trim().split('\n')[0].trim();
+  
+  // Remove quotes if model wrapped the response
+  vibe = vibe.replace(/^["']|["']$/g, "");
+  
+  // Ensure ellipsis
+  if (!vibe.endsWith("...")) {
+    vibe = vibe.replace(/\.+$/, "") + "...";
+  }
+  
+  // Enforce length limit (50 chars max)
+  if (vibe.length > 50) {
+    vibe = vibe.slice(0, 47) + "...";
+  }
+  
+  // Final validation
+  if (!vibe || vibe === "...") {
+    return `${fallback}...`;
+  }
+  
+  return vibe;
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// AI Generation
+// ═══════════════════════════════════════════════════════════════════════════
+
+async function generateVibe(
+  ctx: VibeGenContext,
+  signal: AbortSignal,
+): Promise<string> {
+  if (!extensionCtx) {
+    return `${config.fallback}...`;
+  }
+  
+  // Parse model spec (provider/modelId format, where modelId may contain slashes)
+  const slashIndex = config.modelSpec.indexOf("/");
+  if (slashIndex === -1) {
+    return `${config.fallback}...`;
+  }
+  const provider = config.modelSpec.slice(0, slashIndex);
+  const modelId = config.modelSpec.slice(slashIndex + 1);
+  if (!provider || !modelId) {
+    return `${config.fallback}...`;
+  }
+  
+  // Resolve model from registry
+  const model = extensionCtx.modelRegistry.find(provider, modelId);
+  if (!model) {
+    console.debug(`[working-vibes] Model not found: ${config.modelSpec}`);
+    return `${config.fallback}...`;
+  }
+  
+  // Get API key
+  const apiKey = await extensionCtx.modelRegistry.getApiKey(model);
+  if (!apiKey) {
+    console.debug(`[working-vibes] No API key for provider: ${provider}`);
+    return `${config.fallback}...`;
+  }
+  
+  // Build minimal context (just a user message, no system prompt or tools)
+  const aiContext: Context = {
+    messages: [{
+      role: "user",
+      content: [{ type: "text", text: buildVibePrompt(ctx) }],
+      timestamp: Date.now(),
+    }],
+  };
+  
+  // Call model with timeout
+  const response = await complete(model, aiContext, { apiKey, signal });
+  
+  // Extract and parse response
+  const textContent = response.content.find(c => c.type === "text");
+  return parseVibeResponse(textContent?.text || "", config.fallback);
+}
+
+async function generateAndUpdate(
+  prompt: string, 
+  setWorkingMessage: (msg?: string) => void,
+): Promise<void> {
+  // Cancel any in-flight generation
+  currentGeneration?.abort();
+  currentGeneration = new AbortController();
+  
+  // Create timeout signal (3 seconds)
+  const timeoutSignal = AbortSignal.timeout(config.timeout);
+  const combinedSignal = AbortSignal.any([
+    currentGeneration.signal,
+    timeoutSignal,
+  ]);
+  
+  try {
+    const vibe = await generateVibe(
+      { theme: config.theme!, userPrompt: prompt },
+      combinedSignal,
+    );
+    
+    // Only update if still streaming and not aborted
+    if (isStreaming && !currentGeneration.signal.aborted) {
+      setWorkingMessage(vibe);
+    }
+  } catch (error) {
+    // AbortError is expected on timeout/cancel - don't log as error
+    if (error instanceof Error && error.name === "AbortError") {
+      console.debug("[working-vibes] Generation aborted");
+    } else {
+      console.debug("[working-vibes] Generation failed:", error);
+    }
+    // Fallback already showing, no action needed
+  }
+}
+
+// ═══════════════════════════════════════════════════════════════════════════
+// Exported Functions (called from index.ts)
+// ═══════════════════════════════════════════════════════════════════════════
+
+export function initVibeManager(ctx: ExtensionContext): void {
+  extensionCtx = ctx;
+  config = loadConfig(); // Refresh config in case settings changed
+}
+
+export function getVibeTheme(): string | null {
+  return config.theme;
+}
+
+export function setVibeTheme(theme: string | null): void {
+  config = { ...config, theme };
+  saveConfig();
+}
+
+export function getVibeModel(): string {
+  return config.modelSpec;
+}
+
+export function setVibeModel(modelSpec: string): void {
+  config = { ...config, modelSpec };
+  saveModelConfig();
+}
+
+export function onVibeBeforeAgentStart(
+  prompt: string, 
+  setWorkingMessage: (msg?: string) => void,
+): void {
+  // Skip if no theme configured or no extensionCtx
+  if (!config.theme || !extensionCtx) return;
+  
+  // Queue themed placeholder BEFORE agent_start creates the loader
+  // This sets pendingWorkingMessage which is applied when loader is created
+  setWorkingMessage(`Channeling ${config.theme}...`);
+  
+  // Mark vibe generation time for rate limiting
+  lastVibeTime = Date.now();
+  
+  // Async: generate and update (fire-and-forget, don't await)
+  generateAndUpdate(prompt, setWorkingMessage);
+}
+
+export function onVibeAgentStart(): void {
+  isStreaming = true;
+}
+
+export function onVibeToolCall(
+  toolName: string,
+  toolInput: Record<string, unknown>,
+  setWorkingMessage: (msg?: string) => void,
+): void {
+  // Skip if no theme, not streaming, or no extensionCtx
+  if (!config.theme || !extensionCtx || !isStreaming) return;
+  
+  // Rate limit: skip if not enough time has passed
+  const now = Date.now();
+  if (now - lastVibeTime < config.refreshInterval) return;
+  
+  // Build context hint from tool name and input
+  let hint = `using ${toolName} tool`;
+  if (toolName === "read" && toolInput.path) {
+    hint = `reading file: ${toolInput.path}`;
+  } else if (toolName === "write" && toolInput.path) {
+    hint = `writing file: ${toolInput.path}`;
+  } else if (toolName === "edit" && toolInput.path) {
+    hint = `editing file: ${toolInput.path}`;
+  } else if (toolName === "bash" && toolInput.command) {
+    const cmd = String(toolInput.command).slice(0, 40);
+    hint = `running command: ${cmd}`;
+  }
+  
+  // Update time and generate new vibe
+  lastVibeTime = now;
+  generateAndUpdate(hint, setWorkingMessage);
+}
+
+export function onVibeAgentEnd(setWorkingMessage: (msg?: string) => void): void {
+  isStreaming = false;
+  // Cancel any in-flight generation
+  currentGeneration?.abort();
+  // Reset to pi's default working message
+  setWorkingMessage(undefined);
+}