@pi-unipi/unipi 0.1.11 → 0.1.12

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/unipi",
-  "version": "0.1.11",
+  "version": "0.1.12",
   "description": "All-in-one extension suite for Pi coding agent",
   "type": "module",
   "license": "MIT",

package/packages/autocomplete/src/constants.ts

@@ -93,16 +93,17 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   "unipi:mcp-settings": "mcp",
   "unipi:mcp-reload":   "mcp",
 
-  // utility (6 commands)
+  // utility (10 commands)
   "unipi:continue":   "utility",
   "unipi:reload":     "utility",
   "unipi:status":     "utility",
   "unipi:cleanup":    "utility",
   "unipi:env":        "utility",
   "unipi:doctor":     "utility",
-  "unipi:name-badge": "utility",
+  "unipi:badge-name": "utility",
   "unipi:badge-gen":  "utility",
   "unipi:badge-toggle": "utility",
+  "unipi:badge-settings": "utility",
 
   // ask-user (1 command)
   "unipi:ask-user-settings": "ask-user",
@@ -136,11 +137,9 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   "unipi:notify-set-tg":    "notify",
   "unipi:notify-test":      "notify",
 
-  // kanboard (4 commands)
+  // kanboard (3 commands)
   "unipi:kanboard":          "kanboard",
   "unipi:kanboard-doctor":   "kanboard",
-  "unipi:kanboard-settings": "kanboard",
-  "unipi:name-gen":          "kanboard",
 };
 
 // ─── Description Map ─────────────────────────────────────────────────
@@ -190,11 +189,12 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:cleanup":    "Clean up old sessions and cache",
   "unipi:env":        "Show environment info",
   "unipi:doctor":     "Run diagnostics",
-  "unipi:name-badge": "Toggle session name badge overlay",
+  "unipi:badge-name": "Toggle session name badge overlay",
   "unipi:badge-gen":  "Generate session name via background agent",
   "unipi:badge-toggle": "Configure badge settings (autoGen, badgeEnabled, agentTool)",
-  "unipi:name-gen":   "Generate session name badge from kanboard context",
-  "unipi:kanboard-settings": "Configure kanboard module settings",
+  "unipi:badge-settings": "Configure badge settings via TUI overlay",
+  "unipi:kanboard":        "Start the kanboard visualization server",
+  "unipi:kanboard-doctor": "Diagnose and fix kanboard parser issues",
 
   "unipi:ask-user-settings": "Configure ask-user settings",
 
@@ -219,9 +219,6 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:notify-set-tg":    "Set up Telegram bot notifications",
   "unipi:notify-test":      "Test all enabled notification platforms",
 
-  "unipi:kanboard":        "Start the kanboard visualization server",
-  "unipi:kanboard-doctor": "Diagnose and fix kanboard parser issues",
-
   "unipi:milestone-onboard": "Create MILESTONES.md from existing workflow docs",
   "unipi:milestone-update":  "Sync MILESTONES.md with completed work",
 };

package/packages/core/index.ts

@@ -8,3 +8,4 @@ export * from "./constants.js";
 export * from "./events.js";
 export * from "./sandbox.js";
 export * from "./utils.js";
+export * from "./model-cache.js";

package/packages/subagents/src/__tests__/badge-generation.test.ts

@@ -0,0 +1,244 @@
+/**
+ * Test: Badge Generation Flow
+ *
+ * Tests the full badge name generation flow to identify and verify
+ * fixes for "Generating session name..." getting stuck.
+ *
+ * BUG 1 — Tool mismatch:
+ * Background agent was told to "Call the set_session_name tool" but the tool
+ * doesn't exist in the agent's session (only builtin tools available).
+ * FIX: Changed prompt to output title directly, parse in onComplete callback.
+ *
+ * BUG 2 — Wrong event bus:
+ * Cross-module events emitted via pi.events.emit() but listeners used pi.on()
+ * (extension lifecycle events) — completely different event bus.
+ * FIX: Changed all cross-module listeners to pi.events.on().
+ */
+
+import { describe, it } from "node:test";
+import assert from "node:assert/strict";
+import { readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+
+const ROOT = join(import.meta.dirname, "../../../..");
+
+// ─── Helpers ────────────────────────────────────────────────────────
+
+function readSource(relativePath: string): string {
+  const fullPath = join(ROOT, relativePath);
+  if (!existsSync(fullPath)) throw new Error(`File not found: ${fullPath}`);
+  return readFileSync(fullPath, "utf-8");
+}
+
+// ─── Test: Tool availability in spawned agent ──────────────────────
+
+describe("Badge generation — tool availability", () => {
+  it("agent-runner uses only builtin tools, NOT extension-registered tools", () => {
+    const src = readSource("packages/subagents/src/agent-runner.ts");
+
+    const builtinMatch = src.match(
+      /const BUILTIN_TOOL_NAMES\s*=\s*(\[.*?\])/s,
+    );
+    assert.ok(builtinMatch, "BUILTIN_TOOL_NAMES should be defined");
+
+    const builtinTools: string[] = eval(builtinMatch[1]);
+    assert.deepStrictEqual(builtinTools, [
+      "read", "bash", "edit", "write", "grep", "find", "ls",
+    ]);
+  });
+
+  it("set_session_name is NOT in the agent's tool list", () => {
+    const src = readSource("packages/subagents/src/agent-runner.ts");
+    const builtinMatch = src.match(
+      /const BUILTIN_TOOL_NAMES\s*=\s*(\[.*?\])/s,
+    );
+    const tools: string[] = eval(builtinMatch![1]);
+    assert.ok(!tools.includes("set_session_name"));
+  });
+});
+
+// ─── Test: Prompt no longer references non-existent tool ───────────
+
+describe("Badge generation — prompt fix", () => {
+  it("prompt asks agent to OUTPUT the title directly (not call a tool)", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(
+      src.includes("Reply with ONLY the title"),
+      "Prompt should ask agent to reply with only the title",
+    );
+
+    assert.ok(
+      !src.includes("Call the set_session_name tool"),
+      "Prompt should NOT tell agent to call set_session_name",
+    );
+  });
+});
+
+// ─── Test: onComplete extracts name from result ────────────────────
+
+describe("Badge generation — onComplete callback", () => {
+  it("onComplete extracts name from agent result and calls pi.setSessionName", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(
+      src.includes('record.description === "Generate session name"'),
+      "Should detect badge generation agents by description",
+    );
+
+    assert.ok(
+      src.includes("pi.setSessionName(name)"),
+      "Should call pi.setSessionName with extracted name",
+    );
+  });
+});
+
+// ─── Test: Cross-module event bus — the critical fix ───────────────
+
+describe("Badge generation — event bus (CRITICAL FIX)", () => {
+  it("emitEvent uses pi.events.emit (not pi.on)", () => {
+    const src = readSource("packages/core/utils.ts");
+
+    assert.ok(
+      src.includes("pi.events.emit(eventName, payload)"),
+      "emitEvent should use pi.events.emit()",
+    );
+  });
+
+  it("subagents listens via pi.events.on (NOT pi.on)", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    // Must use pi.events.on for cross-module events
+    assert.ok(
+      src.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
+      "Subagents should listen via pi.events.on",
+    );
+
+    // Should NOT use pi.on for custom events
+    const piOnMatch = src.match(/pi\.on\(UNIPI_EVENTS\.BADGE_GENERATE_REQUEST/g);
+    assert.ok(!piOnMatch, "Should NOT use pi.on() for cross-module events");
+  });
+
+  it("utility BADGE_GENERATE_REQUEST listener is removed (input handler already shows overlay)", () => {
+    const src = readSource("packages/utility/src/index.ts");
+
+    // Should NOT have a separate BADGE_GENERATE_REQUEST listener
+    // The input handler already shows the overlay and emits the event
+    assert.ok(
+      !src.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
+      "Utility should NOT have a separate BADGE_GENERATE_REQUEST listener",
+    );
+  });
+
+  it("workflow listens for MODULE_READY via pi.events.on (NOT pi.on)", () => {
+    const src = readSource("packages/workflow/index.ts");
+
+    assert.ok(
+      src.includes("pi.events.on(UNIPI_EVENTS.MODULE_READY"),
+      "Workflow should listen via pi.events.on",
+    );
+
+    const piOnMatch = src.match(/pi\.on\(UNIPI_EVENTS\.MODULE_READY/g);
+    assert.ok(!piOnMatch, "Should NOT use pi.on() for cross-module events");
+  });
+
+  it("pi.on() is ONLY used for known lifecycle events", () => {
+    const subagentsSrc = readSource("packages/subagents/src/index.ts");
+    const utilitySrc = readSource("packages/utility/src/index.ts");
+
+    // These are valid lifecycle events that should use pi.on()
+    const validLifecycleEvents = [
+      "session_start", "session_shutdown", "input",
+      "tool_call", "tool_execution_start",
+    ];
+
+    // Check that pi.on() is only used with lifecycle events
+    const piOnPattern = /pi\.on\("([^"]+)"/g;
+    let match;
+    while ((match = piOnPattern.exec(subagentsSrc)) !== null) {
+      assert.ok(
+        validLifecycleEvents.includes(match[1]),
+        `subagents: pi.on("${match[1]}") should be a lifecycle event, use pi.events.on() for custom events`,
+      );
+    }
+    while ((match = piOnPattern.exec(utilitySrc)) !== null) {
+      assert.ok(
+        validLifecycleEvents.includes(match[1]),
+        `utility: pi.on("${match[1]}") should be a lifecycle event`,
+      );
+    }
+  });
+});
+
+// ─── Test: Event flow ──────────────────────────────────────────────
+
+describe("Badge generation — event flow", () => {
+  it("utility emits BADGE_GENERATE_REQUEST on first input", () => {
+    const src = readSource("packages/utility/src/index.ts");
+
+    assert.ok(src.includes("BADGE_GENERATE_REQUEST"));
+    assert.ok(src.includes('source: "input-hook"'));
+  });
+
+  it("BADGE_GENERATE_REQUEST event is defined in core", () => {
+    const src = readSource("packages/core/events.ts");
+    assert.ok(src.includes("BADGE_GENERATE_REQUEST"));
+  });
+});
+
+// ─── Test: Model resolution ────────────────────────────────────────
+
+describe("Badge generation — model resolution", () => {
+  it("reads generationModel from badge.json instead of hardcoding", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(!src.includes('"openai/gpt-oss-20b"'));
+    assert.ok(src.includes(".unipi/config/badge.json"));
+    assert.ok(src.includes("parsed.generationModel"));
+  });
+});
+
+// ─── Summary ───────────────────────────────────────────────────────
+
+describe("Badge generation — ROOT CAUSE SUMMARY", () => {
+  it("BUG 1 FIXED: prompt no longer references non-existent tool", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(!src.includes("Call the set_session_name tool"),
+      "FIXED: prompt no longer tells agent to call set_session_name");
+    assert.ok(src.includes("Reply with ONLY the title"),
+      "FIXED: prompt asks agent to reply with only the title");
+  });
+
+  it("BUG 1 FIXED: onComplete extracts name and sets it directly", () => {
+    const src = readSource("packages/subagents/src/index.ts");
+
+    assert.ok(src.includes('record.description === "Generate session name"'),
+      "FIXED: onComplete detects badge generation agents");
+    assert.ok(src.includes("pi.setSessionName(name)"),
+      "FIXED: onComplete calls pi.setSessionName directly");
+  });
+
+  it("BUG 2 FIXED: cross-module events use pi.events.on, not pi.on", () => {
+    const subagentsSrc = readSource("packages/subagents/src/index.ts");
+    const utilitySrc = readSource("packages/utility/src/index.ts");
+    const workflowSrc = readSource("packages/workflow/index.ts");
+
+    // Subagents: correct event bus
+    assert.ok(
+      subagentsSrc.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
+      "subagents: must use pi.events.on for BADGE_GENERATE_REQUEST",
+    );
+
+    // Utility: no duplicate listener (input handler already handles it)
+    assert.ok(
+      !utilitySrc.includes("pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST"),
+      "utility: no duplicate BADGE_GENERATE_REQUEST listener",    );
+
+    // Workflow: correct event bus
+    assert.ok(
+      workflowSrc.includes("pi.events.on(UNIPI_EVENTS.MODULE_READY"),
+      "workflow: must use pi.events.on for MODULE_READY",
+    );
+  });
+});

package/packages/subagents/src/index.ts

@@ -179,6 +179,16 @@ export default function (pi: ExtensionAPI) {
         );
       }
 
+      // Badge generation: extract name from agent result and set directly
+      if (record.description === "Generate session name" && record.result && record.status === "completed") {
+        const name = record.result.split("\n")[0]?.trim().slice(0, 50) ?? "";
+        if (name && !name.startsWith("Error") && !name.includes("error")) {
+          try {
+            pi.setSessionName(name);
+          } catch { /* best effort */ }
+        }
+      }
+
       pi.events.emit("subagents:completed", {
         id: record.id,
         type: record.type,
@@ -339,20 +349,31 @@ export default function (pi: ExtensionAPI) {
   });
 
   // Listen for badge generation requests — spawn background agent
-  pi.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST as any, async (event: any) => {
+  pi.events.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST, async (event: any) => {
     if (!sessionCtx) return;
 
     const summary = event?.conversationSummary ?? "";
     const prompt = summary
-      ? `Generate a concise session title (MAX 5 WORDS) for this conversation:\n\n"${summary}"\n\nCall the set_session_name tool with the name. Do not explain.`
-      : `Generate a concise session title (MAX 5 WORDS) for the current session. Call the set_session_name tool. Do not explain.`;
-
-    // Try with openai/gpt-oss-20b, fallback to inherit
-    const modelInput = "openai/gpt-oss-20b";
+      ? `Generate a concise session title (MAX 5 WORDS) for this conversation:\n\n"${summary}"\n\nReply with ONLY the title. No quotes, no explanation, no punctuation.`
+      : `Generate a concise session title (MAX 5 WORDS) for the current session. Reply with ONLY the title. No quotes, no explanation, no punctuation.`;
+
+    // Try with configured model, fallback to inherit
+    let modelInput: string | undefined = undefined;
+    try {
+      const fs = await import("node:fs");
+      const path = await import("node:path");
+      const configPath = path.resolve(process.cwd(), ".unipi/config/badge.json");
+      if (fs.existsSync(configPath)) {
+        const parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+        if (typeof parsed.generationModel === "string" && parsed.generationModel !== "inherit") {
+          modelInput = parsed.generationModel;
+        }
+      }
+    } catch { /* ignore — inherit parent model */ }
     let resolvedModel: any = undefined;
 
     // Check if model is available
-    if (sessionCtx.modelRegistry) {
+    if (modelInput && sessionCtx.modelRegistry) {
       const { resolveModel } = await import("./model-resolver.js");
       const result = resolveModel(modelInput, sessionCtx.modelRegistry);
       if (typeof result !== "string") {

package/packages/utility/src/commands.ts

@@ -22,6 +22,7 @@ import { runDiagnostics, formatDiagnosticsReport } from "./diagnostics/engine.js
 import { getEnvironmentInfo, formatEnvironmentInfo } from "./tools/env.js";
 import type { NameBadgeState } from "./tui/name-badge-state.js";
 import { readBadgeSettings, updateBadgeSetting, formatBadgeSettings } from "./tui/badge-settings.js";
+import { BadgeSettingsTui } from "./tui/badge-settings-tui.js";
 
 /** Send a markdown response via pi.sendMessage */
 function sendResponse(pi: ExtensionAPI, markdown: string): void {
@@ -36,14 +37,14 @@ function sendResponse(pi: ExtensionAPI, markdown: string): void {
 }
 
 /**
- * Register name badge commands: /unipi:name-badge, /unipi:badge-gen.
+ * Register name badge commands: /unipi:badge-name, /unipi:badge-gen.
  */
 export function registerNameBadgeCommands(
   pi: ExtensionAPI,
   state: NameBadgeState,
 ): void {
-  // ─── /unipi:name-badge — toggle badge overlay ───────────────────────────
-  pi.registerCommand(`${UNIPI_PREFIX}${UTILITY_COMMANDS.NAME_BADGE}`, {
+  // ─── /unipi:badge-name — toggle badge overlay ───────────────────────────
+  pi.registerCommand(`${UNIPI_PREFIX}${UTILITY_COMMANDS.BADGE_NAME}`, {
     description: "Toggle session name badge overlay",
     handler: async (_args: string, ctx: ExtensionContext) => {
       if (!ctx.hasUI) {
@@ -95,6 +96,42 @@ export function registerNameBadgeCommands(
       sendResponse(pi, formatBadgeSettings(settings));
     },
   });
+
+  // ─── /unipi:badge-settings — TUI settings overlay ──────────────────────
+  pi.registerCommand(`${UNIPI_PREFIX}${UTILITY_COMMANDS.BADGE_SETTINGS}`, {
+    description: "Configure badge settings via TUI overlay",
+    handler: async (_args: string, ctx: ExtensionContext) => {
+      if (!ctx.hasUI) {
+        ctx.ui.notify("Badge settings require an interactive UI.", "warning");
+        return;
+      }
+
+      ctx.ui.custom(
+        (tui: any, _theme: any, _keybindings: any, done: any) => {
+          const overlay = new BadgeSettingsTui();
+          overlay.onClose = () => done(undefined);
+          overlay.requestRender = () => tui.requestRender();
+          return {
+            render: (w: number) => overlay.render(w),
+            invalidate: () => overlay.invalidate(),
+            handleInput: (data: string) => {
+              overlay.handleInput(data);
+              tui.requestRender();
+            },
+          };
+        },
+        {
+          overlay: true,
+          overlayOptions: {
+            width: "80%",
+            minWidth: 50,
+            anchor: "center",
+            margin: 2,
+          },
+        },
+      );
+    },
+  });
 }
 
 /**

package/packages/utility/src/index.ts

@@ -29,6 +29,9 @@ import { getLifecycle } from "./lifecycle/process.js";
 import { getAnalyticsCollector } from "./analytics/collector.js";
 import { registerInfoScreen } from "./info-screen.js";
 
+/** Re-export readBadgeSettings for cross-package use */
+export { readBadgeSettings } from "./tui/badge-settings.js";
+
 /** Package version */
 const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
 
@@ -43,9 +46,10 @@ const ALL_COMMANDS = [
   UTILITY_COMMANDS.CLEANUP,
   UTILITY_COMMANDS.ENV,
   UTILITY_COMMANDS.DOCTOR,
-  UTILITY_COMMANDS.NAME_BADGE,
+  UTILITY_COMMANDS.BADGE_NAME,
   UTILITY_COMMANDS.BADGE_GEN,
   UTILITY_COMMANDS.BADGE_TOGGLE,
+  UTILITY_COMMANDS.BADGE_SETTINGS,
 ].map((cmd) => `unipi:${cmd}`);
 
 /** All tools registered by this module */
@@ -66,6 +70,8 @@ export default function (pi: ExtensionAPI) {
   // Initialize name badge state
   const nameBadgeState = new NameBadgeState();
 
+  // Capture session context for cross-event use (not needed if BADGE_GENERATE_REQUEST removed)
+
   // Register commands
   registerUtilityCommands(pi);
   registerNameBadgeCommands(pi, nameBadgeState);
@@ -89,6 +95,15 @@ export default function (pi: ExtensionAPI) {
 
     // Restore name badge if it was visible in previous session
     await nameBadgeState.restore(pi, ctx);
+
+    // Write model cache for TUI components
+    if ((ctx as any).modelRegistry) {
+      const { writeModelCache } = await import("@pi-unipi/core");
+      const registry = (ctx as any).modelRegistry;
+      const models = (registry.getAvailable?.() ?? registry.getAll())
+        .map((m: any) => ({ provider: m.provider, id: m.id, name: m.name }));
+      writeModelCache(models);
+    }
   });
 
   // First-message hook: auto-generate session name on first user message
@@ -127,14 +142,6 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // Listen for badge generation requests from other modules (e.g., kanboard)
-  pi.on(UNIPI_EVENTS.BADGE_GENERATE_REQUEST as any, async (_event: any, ctx: any) => {
-    // Show badge overlay if not already visible
-    if (!nameBadgeState.isVisible() && ctx?.hasUI) {
-      await nameBadgeState.show(pi, ctx);
-    }
-  });
-
   // Track command usage
   pi.on("tool_call", async (event) => {
     if (event.toolName.startsWith("unipi:")) {

package/packages/utility/src/tui/badge-settings-tui.ts

@@ -0,0 +1,388 @@
+/**
+ * @pi-unipi/utility — Badge Settings TUI Overlay
+ *
+ * Interactive settings overlay for badge configuration.
+ * Three settings: auto-generate toggle, badge-enabled toggle, generation model selector.
+ * Model list loaded from shared model cache (~/.unipi/config/models-cache.json).
+ */
+
+import type { Component } from "@mariozechner/pi-tui";
+import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
+import type { CachedModel } from "@pi-unipi/core";
+import { readModelCache } from "@pi-unipi/core";
+import {
+  readBadgeSettings,
+  writeBadgeSettings,
+  type BadgeSettings,
+} from "./badge-settings.js";
+
+/** ANSI escape codes */
+const ansi = {
+  reset: "\x1b[0m",
+  bold: "\x1b[1m",
+  dim: "\x1b[2m",
+  cyan: "\x1b[36m",
+  green: "\x1b[32m",
+  yellow: "\x1b[33m",
+  red: "\x1b[31m",
+  gray: "\x1b[90m",
+  white: "\x1b[37m",
+};
+
+/** Toggle symbols */
+const TOGGLE_ON = `${ansi.green}●${ansi.reset}`;
+const TOGGLE_OFF = `${ansi.dim}○${ansi.reset}`;
+
+/** Active mode */
+type Mode = "settings" | "model-picker";
+
+/** Setting row types */
+interface BooleanSetting {
+  type: "boolean";
+  key: keyof BadgeSettings;
+  label: string;
+  description: string;
+  getValue: (s: BadgeSettings) => boolean;
+}
+
+interface ModelSetting {
+  type: "model";
+  key: "generationModel";
+  label: string;
+  description: string;
+}
+
+type SettingItem = BooleanSetting | ModelSetting;
+
+/** Settings list */
+const SETTINGS: SettingItem[] = [
+  {
+    type: "boolean",
+    key: "autoGen",
+    label: "Auto generate",
+    description: "Generate session name on first user message",
+    getValue: (s) => s.autoGen,
+  },
+  {
+    type: "boolean",
+    key: "badgeEnabled",
+    label: "Badge enabled",
+    description: "Show the name badge overlay",
+    getValue: (s) => s.badgeEnabled,
+  },
+  {
+    type: "model",
+    key: "generationModel",
+    label: "Generation model",
+    description: "Model to use for badge name generation",
+  },
+];
+
+/**
+ * Badge Settings TUI overlay.
+ * Implements the Component interface for use with ctx.ui.custom().
+ */
+export class BadgeSettingsTui implements Component {
+  private settings: BadgeSettings;
+  private mode: Mode = "settings";
+  private selectedIndex = 0;
+  private modelScrollOffset = 0;
+  private models: CachedModel[] = [];
+
+  /** Theme reference for rendering (set externally) */
+  private _theme: any = null;
+
+  /** Callback when overlay should close */
+  onClose?: () => void;
+
+  /** Callback to request a re-render */
+  requestRender?: () => void;
+
+  constructor() {
+    this.settings = readBadgeSettings();
+    this.models = readModelCache();
+  }
+
+  /**
+   * Set the pi-tui theme for styled rendering.
+   */
+  setTheme(theme: any): void {
+    this._theme = theme;
+  }
+
+  /**
+   * Invalidate cached render state.
+   */
+  invalidate(): void {
+    // No cached state to invalidate
+  }
+
+  /**
+   * Handle keyboard input.
+   */
+  handleInput(data: string): void {
+    if (this.mode === "settings") {
+      this.handleSettingsInput(data);
+    } else {
+      this.handleModelPickerInput(data);
+    }
+  }
+
+  /**
+   * Handle input in settings mode.
+   */
+  private handleSettingsInput(data: string): void {
+    switch (data) {
+      case "\x1b[A": // Up arrow
+      case "k":
+        this.selectedIndex =
+          (this.selectedIndex - 1 + SETTINGS.length) % SETTINGS.length;
+        break;
+      case "\x1b[B": // Down arrow
+      case "j":
+        this.selectedIndex = (this.selectedIndex + 1) % SETTINGS.length;
+        break;
+      case " ": // Space — toggle boolean settings
+        this.toggleCurrentSetting();
+        break;
+      case "\r": // Enter — open model picker or toggle
+        if (SETTINGS[this.selectedIndex].type === "model") {
+          this.enterModelPicker();
+        } else {
+          this.toggleCurrentSetting();
+        }
+        break;
+      case "\x1b": // Escape — close and save
+        this.save();
+        this.onClose?.();
+        break;
+    }
+  }
+
+  /**
+   * Handle input in model picker mode.
+   */
+  private handleModelPickerInput(data: string): void {
+    const allModels = this.getModelList();
+
+    switch (data) {
+      case "\x1b[A": // Up arrow
+      case "k":
+        this.selectedIndex =
+          (this.selectedIndex - 1 + allModels.length) % allModels.length;
+        this.adjustModelScroll(allModels.length);
+        break;
+      case "\x1b[B": // Down arrow
+      case "j":
+        this.selectedIndex = (this.selectedIndex + 1) % allModels.length;
+        this.adjustModelScroll(allModels.length);
+        break;
+      case "\r": // Enter — select model
+        this.selectModel();
+        break;
+      case "\x1b": // Escape — cancel picker
+        this.mode = "settings";
+        this.selectedIndex = SETTINGS.findIndex(
+          (s) => s.key === "generationModel",
+        );
+        break;
+    }
+  }
+
+  /**
+   * Toggle the currently selected boolean setting.
+   */
+  private toggleCurrentSetting(): void {
+    const item = SETTINGS[this.selectedIndex];
+    if (item.type !== "boolean") return;
+
+    const current = item.getValue(this.settings);
+    (this.settings as any)[item.key] = !current;
+    this.save();
+  }
+
+  /**
+   * Enter model picker mode.
+   */
+  private enterModelPicker(): void {
+    this.mode = "model-picker";
+    const allModels = this.getModelList();
+    const currentModel = this.settings.generationModel;
+    this.selectedIndex = allModels.findIndex((m) => m.id === currentModel);
+    if (this.selectedIndex < 0) this.selectedIndex = 0;
+    this.modelScrollOffset = 0;
+    this.adjustModelScroll(allModels.length);
+  }
+
+  /**
+   * Select the current model in the picker.
+   */
+  private selectModel(): void {
+    const allModels = this.getModelList();
+    const selected = allModels[this.selectedIndex];
+    if (selected) {
+      this.settings.generationModel = selected.id;
+      this.save();
+    }
+    this.mode = "settings";
+    this.selectedIndex = SETTINGS.findIndex((s) => s.key === "generationModel");
+  }
+
+  /**
+   * Get model list with "inherit" as first entry.
+   */
+  private getModelList(): Array<{ id: string; label: string }> {
+    const list: Array<{ id: string; label: string }> = [
+      { id: "inherit", label: "inherit (use parent model)" },
+    ];
+    for (const m of this.models) {
+      const fullId = `${m.provider}/${m.id}`;
+      list.push({
+        id: fullId,
+        label: m.name ? `${fullId} (${m.name})` : fullId,
+      });
+    }
+    return list;
+  }
+
+  /**
+   * Adjust scroll offset so the selected item is visible.
+   */
+  private adjustModelScroll(totalItems: number): void {
+    // Reserve ~10 lines for visible model list
+    const visibleLines = 10;
+    if (this.selectedIndex < this.modelScrollOffset) {
+      this.modelScrollOffset = this.selectedIndex;
+    } else if (this.selectedIndex >= this.modelScrollOffset + visibleLines) {
+      this.modelScrollOffset = this.selectedIndex - visibleLines + 1;
+    }
+    // Clamp
+    this.modelScrollOffset = Math.max(
+      0,
+      Math.min(this.modelScrollOffset, totalItems - visibleLines),
+    );
+  }
+
+  /**
+   * Save settings to disk.
+   */
+  private save(): void {
+    writeBadgeSettings(this.settings);
+  }
+
+  /**
+   * Render the overlay.
+   */
+  render(width: number): string[] {
+    const lines: string[] = [];
+    const innerWidth = Math.max(44, width - 2);
+
+    const padVisible = (content: string, targetWidth: number): string => {
+      const vw = visibleWidth(content);
+      const pad = Math.max(0, targetWidth - vw);
+      return content + " ".repeat(pad);
+    };
+
+    const add = (s: string) =>
+      lines.push(
+        `${ansi.cyan}│${ansi.reset}` +
+          padVisible(truncateToWidth(s, innerWidth), innerWidth) +
+          `${ansi.cyan}│${ansi.reset}`,
+      );
+
+    const addEmpty = () =>
+      lines.push(
+        `${ansi.cyan}│${ansi.reset}` +
+          " ".repeat(innerWidth) +
+          `${ansi.cyan}│${ansi.reset}`,
+      );
+
+    // Top border
+    lines.push(`${ansi.cyan}╭${"─".repeat(innerWidth)}╮${ansi.reset}`);
+
+    // Header
+    add(`${ansi.bold}${ansi.cyan}Badge Settings${ansi.reset}`);
+    add(`${ansi.dim}Configure badge generation behavior${ansi.reset}`);
+    addEmpty();
+
+    // Settings list
+    for (let i = 0; i < SETTINGS.length; i++) {
+      const item = SETTINGS[i];
+      const isSelected = i === this.selectedIndex && this.mode === "settings";
+      const selector = isSelected ? `${ansi.cyan}▸${ansi.reset}` : " ";
+
+      if (item.type === "boolean") {
+        const value = item.getValue(this.settings);
+        const toggle = value ? TOGGLE_ON : TOGGLE_OFF;
+        const labelColor = isSelected ? ansi.bold : ansi.dim;
+
+        add(
+          `${selector} ${toggle} ${labelColor}${item.label}${ansi.reset}`,
+        );
+        add(`   ${ansi.gray}${item.description}${ansi.reset}`);
+      } else if (item.type === "model") {
+        const labelColor = isSelected ? ansi.bold : ansi.dim;
+        const modelDisplay = this.settings.generationModel;
+
+        add(
+          `${selector} ${ansi.yellow}⚙${ansi.reset} ${labelColor}${item.label}${ansi.reset}: ${ansi.white}${modelDisplay}${ansi.reset}`,
+        );
+        add(`   ${ansi.gray}${item.description}${ansi.reset}`);
+        add(`   ${ansi.dim}Enter to select model${ansi.reset}`);
+      }
+    }
+
+    // Model picker (inline)
+    if (this.mode === "model-picker") {
+      addEmpty();
+      add(`${ansi.bold}${ansi.cyan}── Available Models ──${ansi.reset}`);
+
+      const allModels = this.getModelList();
+      const visibleLines = 10;
+      const start = this.modelScrollOffset;
+      const end = Math.min(start + visibleLines, allModels.length);
+
+      // Scroll indicator up
+      if (start > 0) {
+        add(`  ${ansi.dim}▲ ${start} more above${ansi.reset}`);
+      }
+
+      for (let i = start; i < end; i++) {
+        const m = allModels[i];
+        const isSelected = i === this.selectedIndex;
+        const selector = isSelected ? `${ansi.cyan}▸${ansi.reset}` : " ";
+        const labelColor = isSelected ? ansi.bold + ansi.white : ansi.dim;
+
+        add(
+          `${selector} ${labelColor}${m.label}${ansi.reset}`,
+        );
+      }
+
+      // Scroll indicator down
+      if (end < allModels.length) {
+        add(
+          `  ${ansi.dim}▼ ${allModels.length - end} more below${ansi.reset}`,
+        );
+      }
+    }
+
+    // Footer
+    addEmpty();
+
+    if (this.mode === "model-picker") {
+      add(
+        `${ansi.dim}↑↓ navigate • Enter select • Esc cancel${ansi.reset}`,
+      );
+    } else {
+      add(
+        `${ansi.dim}↑↓ navigate • Space toggle • Enter select model • Esc close${ansi.reset}`,
+      );
+      add(`${ansi.dim}Config: .unipi/config/badge.json${ansi.reset}`);
+    }
+
+    // Bottom border
+    lines.push(`${ansi.cyan}╰${"─".repeat(innerWidth)}╯${ansi.reset}`);
+
+    return lines;
+  }
+}

package/packages/utility/src/tui/badge-settings.ts

@@ -16,6 +16,8 @@ export interface BadgeSettings {
   badgeEnabled: boolean;
   /** Enable the set_session_name tool for agents */
   agentTool: boolean;
+  /** Model to use for badge name generation. "inherit" = parent model, or "provider/model-id" */
+  generationModel: string;
 }
 
 /** Default badge settings */
@@ -23,6 +25,7 @@ const DEFAULT_SETTINGS: BadgeSettings = {
   autoGen: true,
   badgeEnabled: true,
   agentTool: true,
+  generationModel: "inherit",
 };
 
 /** Badge settings file name */
@@ -48,6 +51,7 @@ export function readBadgeSettings(): BadgeSettings {
       autoGen: typeof parsed.autoGen === "boolean" ? parsed.autoGen : DEFAULT_SETTINGS.autoGen,
       badgeEnabled: typeof parsed.badgeEnabled === "boolean" ? parsed.badgeEnabled : DEFAULT_SETTINGS.badgeEnabled,
       agentTool: typeof parsed.agentTool === "boolean" ? parsed.agentTool : DEFAULT_SETTINGS.agentTool,
+      generationModel: typeof parsed.generationModel === "string" ? parsed.generationModel : DEFAULT_SETTINGS.generationModel,
     };
   } catch {
     return { ...DEFAULT_SETTINGS };
@@ -97,6 +101,7 @@ export function formatBadgeSettings(settings: BadgeSettings): string {
     `| Auto Generate | ${toggle(settings.autoGen)} | Generate name on first message |`,
     `| Badge Enabled | ${toggle(settings.badgeEnabled)} | Show badge overlay |`,
     `| Agent Tool | ${toggle(settings.agentTool)} | Allow agents to call set_session_name |`,
+    `| Generation Model | ${settings.generationModel} | Model for badge name generation |`,
     "",
     `Config: \`${BADGE_CONFIG_FILE}\``,
   ].join("\n");

package/packages/workflow/index.ts

@@ -149,7 +149,7 @@ export default function (pi: ExtensionAPI) {
   });
 
   // Listen for ralph module ready event
-  pi.on(UNIPI_EVENTS.MODULE_READY as any, (event: any) => {
+  pi.events.on(UNIPI_EVENTS.MODULE_READY, (event: any) => {
     if (event?.name === MODULES.RALPH) {
       ralphDetected = true;
     }