@pi-unipi/unipi 0.1.13 → 0.1.14

package/README.md

@@ -41,7 +41,7 @@ pi install npm:@pi-unipi/kanboard
 | `@pi-unipi/btw` | Parallel side conversations with `/btw` |
 | `@pi-unipi/web-api` | Web search, read, and summarize with provider selection |
 | `@pi-unipi/compactor` | Session compaction, context management, batch execution |
-| `@pi-unipi/notify` | Cross-platform notifications (native, Gotify, Telegram) |
+| `@pi-unipi/notify` | Cross-platform notifications (native, Gotify, Telegram, ntfy) |
 | `@pi-unipi/utility` | Environment info, diagnostics, settings inspector, cleanup |
 | `@pi-unipi/mcp` | MCP server discovery, connection, and tool integration |
 | `@pi-unipi/ask-user` | Structured user input with options and freeform text |
@@ -145,6 +145,8 @@ pi install npm:@pi-unipi/kanboard
 | `/unipi:notify-settings` | Configure notification platforms |
 | `/unipi:notify-set-gotify` | Set Gotify server config |
 | `/unipi:notify-set-tg` | Set Telegram bot config |
+| `/unipi:notify-set-ntfy` | Set ntfy topic and server |
+| `/unipi:notify-recap-model` | Set model for notification recaps |
 | `/unipi:notify-test` | Test notification delivery |
 
 ### Utility (`/unipi:*`)

package/package.json

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

package/packages/autocomplete/src/constants.ts

@@ -132,11 +132,13 @@ export const COMMAND_REGISTRY: Record<string, string> = {
   "unipi:milestone-onboard": "milestone",
   "unipi:milestone-update":  "milestone",
 
-  // notify (4 commands)
+  // notify (6 commands)
   "unipi:notify-settings":  "notify",
   "unipi:notify-set-gotify": "notify",
   "unipi:notify-set-tg":    "notify",
+  "unipi:notify-set-ntfy":  "notify",
   "unipi:notify-test":      "notify",
+  "unipi:notify-recap-model": "notify",
 
   // kanboard (3 commands)
   "unipi:kanboard":          "kanboard",
@@ -219,7 +221,9 @@ export const COMMAND_DESCRIPTIONS: Record<string, string> = {
   "unipi:notify-settings":  "Configure notification platforms and events",
   "unipi:notify-set-gotify": "Set up Gotify push notifications",
   "unipi:notify-set-tg":    "Set up Telegram bot notifications",
+  "unipi:notify-set-ntfy":  "Set up ntfy push notifications",
   "unipi:notify-test":      "Test all enabled notification platforms",
+  "unipi:notify-recap-model": "Select model for notification recaps",
 
   "unipi:milestone-onboard": "Create MILESTONES.md from existing workflow docs",
   "unipi:milestone-update":  "Sync MILESTONES.md with completed work",

package/packages/autocomplete/src/provider.ts

@@ -274,16 +274,54 @@ export function createEnchantedProvider(
         descriptionOverrides,
       );
 
-      // If no unipi items match, just return non-unipi (or null if empty)
+      // If no unipi items match, handle skill vs system items
       if (enhancedUnipiItems.length === 0) {
-        return nonUnipiItems.length > 0
-          ? { items: nonUnipiItems, prefix: effectivePrefix }
+        if (nonUnipiItems.length === 0) return null;
+
+        // Check if user explicitly typed /skill: prefix
+        const isSkillQuery = effectivePrefix.replace(/^\//, "").toLowerCase().startsWith("skill:");
+        
+        if (isSkillQuery) {
+          // User wants skill commands — return them
+          return { items: nonUnipiItems, prefix: effectivePrefix };
+        }
+
+        // Otherwise, filter out skill commands from suggestions
+        const systemOnly = nonUnipiItems.filter(item => !item.value.startsWith("skill:"));
+        return systemOnly.length > 0
+          ? { items: systemOnly, prefix: effectivePrefix }
           : null;
       }
 
-      // Merge: system commands first, then enhanced unipi (sorted by package)
+      // Separate non-unipi items into system commands and skill commands
+      const systemItems: AutocompleteItem[] = [];
+      const skillItems: AutocompleteItem[] = [];
+
+      for (const item of nonUnipiItems) {
+        if (item.value.startsWith("skill:")) {
+          skillItems.push(item);
+        } else {
+          systemItems.push(item);
+        }
+      }
+
+      // Check if user explicitly typed /skill: prefix
+      const isExplicitSkillQuery = effectivePrefix.replace(/^\//, "").toLowerCase().startsWith("skill:");
+
+      // Build final list based on query context
+      let finalItems: AutocompleteItem[];
+
+      if (isExplicitSkillQuery) {
+        // User explicitly wants skill commands — show them first
+        finalItems = [...skillItems, ...enhancedUnipiItems, ...systemItems];
+      } else {
+        // Default: unipi commands first, then system commands, hide skill commands
+        // (skill commands are redundant when unipi equivalents exist)
+        finalItems = [...enhancedUnipiItems, ...systemItems];
+      }
+
       return {
-        items: [...nonUnipiItems, ...enhancedUnipiItems],
+        items: finalItems,
         prefix: effectivePrefix,
       };
     },

package/packages/compactor/src/session/db.ts

@@ -4,8 +4,9 @@
 
 import { createHash } from "node:crypto";
 import { execFileSync } from "node:child_process";
+import { existsSync, mkdirSync } from "node:fs";
 import { homedir } from "node:os";
-import { join } from "node:path";
+import { dirname, join } from "node:path";
 import type { SessionEvent, StoredEvent, SessionMeta, ResumeRow } from "../types.js";
 
 export function getWorktreeSuffix(): string {
@@ -76,6 +77,9 @@ export class SessionDB {
   }
 
   async init(): Promise<void> {
+    const dir = dirname(this.dbPath);
+    if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+
     const sqlite: any = await getSQLite();
     // Handle different SQLite API shapes:
     // - bun:sqlite exports Database as a named export

package/packages/info-screen/index.ts

@@ -32,27 +32,56 @@ export default function (pi: ExtensionAPI) {
   // Start load tracking
   startLoadTracking();
 
-  // Listen for module announcements — track and trigger reactive updates
-  pi.events.on(UNIPI_EVENTS.MODULE_READY, (event: any) => {
-    if (event.name && event.name !== MODULES.INFO_SCREEN) {
+  // Debounced MODULE_READY handling — batch module announcements
+  // to prevent layout shift from rapid per-module cache invalidation.
+  let moduleReadyBatch: Array<{ name: string; version: string; tools?: string[]; loadTimeMs?: number }> = [];
+  let moduleReadyTimer: ReturnType<typeof setTimeout> | null = null;
+  const MODULE_READY_DEBOUNCE_MS = 150;
+
+  function flushModuleReadyBatch(): void {
+    const batch = moduleReadyBatch;
+    moduleReadyBatch = [];
+    moduleReadyTimer = null;
+
+    if (batch.length === 0) return;
+
+    // Track all modules and tools
+    let hasTools = false;
+    for (const event of batch) {
       trackModule(event.name, event.version || "unknown");
       recordLoadTime(event.name, "module", event.loadTimeMs);
-
-      // Invalidate overview so next fetch picks up new module list
-      infoRegistry.invalidateCache("overview");
-
-      // Trigger background refresh of overview — subscribers will re-render
-      infoRegistry.getGroupData("overview");
-
       if (event.tools && Array.isArray(event.tools)) {
         for (const tool of event.tools) {
           trackTool(tool, event.name);
         }
-        // Refresh tools group too
-        infoRegistry.invalidateCache("tools");
-        infoRegistry.getGroupData("tools");
+        hasTools = true;
       }
     }
+
+    // Single cache invalidation for all modules
+    infoRegistry.invalidateCache("overview");
+    infoRegistry.getGroupData("overview");
+
+    if (hasTools) {
+      infoRegistry.invalidateCache("tools");
+      infoRegistry.getGroupData("tools");
+    }
+  }
+
+  // Listen for module announcements — track and trigger reactive updates
+  pi.events.on(UNIPI_EVENTS.MODULE_READY, (event: any) => {
+    if (event.name && event.name !== MODULES.INFO_SCREEN) {
+      moduleReadyBatch.push({
+        name: event.name,
+        version: event.version,
+        tools: event.tools,
+        loadTimeMs: event.loadTimeMs,
+      });
+
+      // Debounce: wait for more modules to arrive, then flush once
+      if (moduleReadyTimer) clearTimeout(moduleReadyTimer);
+      moduleReadyTimer = setTimeout(flushModuleReadyBatch, MODULE_READY_DEBOUNCE_MS);
+    }
   });
 
   pi.events.on(UNIPI_EVENTS.INFO_GROUP_REGISTERED, (_event: any) => {

package/packages/mcp/src/bridge/registry.ts

@@ -107,9 +107,7 @@ export class ServerRegistry {
             safeEnv[k] = typeof v === "string" ? v : String(v);
           }
         } else {
-          console.error(
-            `[MCP] Server '${name}': env is not an object (${typeof def.env}), skipping env vars`,
-          );
+          // Env config invalid — silently skip env vars.
         }
       }
 

package/packages/mcp/src/index.ts

@@ -75,11 +75,8 @@ export default function (pi: ExtensionAPI) {
     try {
       const result = loadAndResolve(cwd);
       servers = result.servers;
-    } catch (err) {
-      console.error(
-        "[MCP] Failed to load config:",
-        err instanceof Error ? err.message : err,
-      );
+    } catch (_err) {
+      // Config load failure — servers will be empty, visible via /unipi:mcp-status.
     }
 
     // Start enabled servers (parallel, non-blocking errors)
@@ -88,14 +85,11 @@ export default function (pi: ExtensionAPI) {
       .map(async (server) => {
         try {
           await registry!.startServer(server);
-          console.log(
-            `[MCP] Started server '${server.name}' (${registry!.getServerState(server.name)?.toolCount ?? 0} tools)`,
-          );
+          // Removed console.log — startup logs cause layout shift in TUI.
+          // Server status visible via /unipi:mcp-status or info screen.
         } catch (err) {
-          console.error(
-            `[MCP] Failed to start server '${server.name}':`,
-            err instanceof Error ? err.message : err,
-          );
+          // Removed console.error — errors surfaced via info-screen MCP group.
+          // Server failure tracked in registry state.
         }
       });
 
@@ -138,7 +132,7 @@ export default function (pi: ExtensionAPI) {
               },
             };
           } catch (err) {
-            console.error("[MCP] Info dataProvider error:", err);
+            // Removed console.error — info-screen shows "?" on error.
             return {
               total: { value: "?" },
               active: { value: "?" },

package/packages/memory/index.ts

@@ -78,11 +78,10 @@ export default function (pi: ExtensionAPI) {
       
       // Sync any orphaned markdown files into the database
       const synced = projectStorage.syncOrphanedFiles();
-      if (synced > 0) {
-        console.warn(`[unipi/memory] Synced ${synced} orphaned memory files into database`);
-      }
-    } catch (err) {
-      console.warn("[unipi/memory] Failed to initialize storage, running without memory:", (err as any)?.message ?? err);
+      // Removed console.warn — orphaned file sync is informational only.
+      // Visible via memory tool list or info-screen memory group.
+    } catch (_err) {
+      // Memory init failure — running without memory. Silent startup.
       projectStorage = null;
     }
 
@@ -113,7 +112,6 @@ export default function (pi: ExtensionAPI) {
     // Register info group
     const registry = getInfoRegistry();
     if (registry) {
-      console.debug("[memory] Registering info group");
       registry.registerGroup({
         id: "memory",
         name: "Memory",
@@ -143,8 +141,8 @@ export default function (pi: ExtensionAPI) {
           try {
             projectMemories = projectStorage.listAll();
             allMemories = listAllProjects();
-          } catch (err) {
-            console.warn("[unipi/memory] Failed to list memories for info panel:", err);
+          } catch (_err) {
+            // Info panel data unavailable — shows empty values.
           }
           const uniqueProjects = [...new Set(allMemories.map((m) => m.project))];
 
@@ -175,8 +173,8 @@ export default function (pi: ExtensionAPI) {
       try {
         projectCount = projectStorage?.listAll()?.length ?? 0;
         projectCountAll = listAllProjects().length;
-      } catch (err) {
-        console.warn("[unipi/memory] Failed to count memories for status:", err);
+      } catch (_err) {
+        // Count unavailable — status bar shows 0.
       }
       const vecReady = isEmbeddingReady();
       const vecIcon = vecReady ? "⚡" : "📝";
@@ -196,8 +194,7 @@ export default function (pi: ExtensionAPI) {
     let projectMemories: Array<{ id: string; title: string; type: string }> = [];
     try {
       projectMemories = projectStorage.listAll();
-    } catch (err) {
-      console.warn("[unipi/memory] Failed to list memories for recall:", err);
+    } catch (_err) {
       recallDone = true; // Skip recall on error
       return;
     }

package/packages/notify/README.md

@@ -1,6 +1,6 @@
 # @pi-unipi/notify
 
-Cross-platform notification extension for Pi. Sends push notifications to native OS, Gotify, and Telegram when agent lifecycle events occur.
+Cross-platform notification extension for Pi. Sends push notifications to native OS, Gotify, Telegram, and ntfy when agent lifecycle events occur.
 
 ## What it does
 
@@ -52,12 +52,35 @@ This guides you through:
 2. Pasting the bot token
 3. Auto-detecting your chat ID
 
+### ntfy
+
+HTTP-based pub-sub notifications via [ntfy.sh](https://ntfy.sh) or self-hosted. Run setup command:
+
+```
+/unipi:notify-set-ntfy
+```
+
+Or configure manually:
+
+```json
+{
+  "ntfy": {
+    "enabled": true,
+    "serverUrl": "https://ntfy.sh",
+    "topic": "your-topic-name",
+    "priority": 3
+  }
+}
+```
+
 ## Commands
 
 | Command | Description |
 |---------|-------------|
 | `/unipi:notify-settings` | Open settings overlay to configure platforms and events |
+| `/unipi:notify-set-gotify` | Configure Gotify server connection |
 | `/unipi:notify-set-tg` | Interactive Telegram bot setup |
+| `/unipi:notify-set-ntfy` | Configure ntfy topic and server |
 | `/unipi:notify-test` | Send test notification to all enabled platforms |
 
 ## Agent Tool

package/packages/notify/index.ts

@@ -19,6 +19,8 @@ import { loadConfig } from "./settings.js";
 import {
   registerEventListeners,
   unregisterEventListeners,
+  setSessionContext,
+  clearSessionContext,
 } from "./events.js";
 
 /** Package version */
@@ -38,20 +40,22 @@ export default function (pi: ExtensionAPI) {
   registerNotifyCommands(pi);
 
   // Session lifecycle — register events and announce module
-  pi.on("session_start", async () => {
+  pi.on("session_start", async (_event, ctx) => {
+    setSessionContext(ctx);
     const config = loadConfig();
     registerEventListeners(pi, config);
 
     emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
       name: MODULES.NOTIFY,
       version: VERSION,
-      commands: ["unipi:notify-settings", "unipi:notify-set-gotify", "unipi:notify-set-tg", "unipi:notify-test"],
+      commands: ["unipi:notify-settings", "unipi:notify-set-gotify", "unipi:notify-set-tg", "unipi:notify-set-ntfy", "unipi:notify-test", "unipi:notify-recap-model"],
       tools: [NOTIFY_TOOLS.NOTIFY_USER],
     });
   });
 
   // Cleanup on session shutdown
   pi.on("session_shutdown", async () => {
+    clearSessionContext();
     unregisterEventListeners();
   });
 }

package/packages/notify/skills/configure-notify/SKILL.md

@@ -47,6 +47,13 @@ Help users configure the `@pi-unipi/notify` notification system.
     "enabled": false,
     "botToken": null,
     "chatId": null
+  },
+  "ntfy": {
+    "enabled": false,
+    "serverUrl": "https://ntfy.sh",
+    "topic": null,
+    "token": null,
+    "priority": 3
   }
 }
 ```
@@ -75,6 +82,20 @@ Bot API notifications. Requires:
 - `botToken` — From @BotFather
 - `chatId` — Auto-detected by `/unipi:notify-set-tg`
 
+### ntfy (default: disabled)
+
+Simple HTTP-based pub-sub notification service. Supports public [ntfy.sh](https://ntfy.sh) and self-hosted instances.
+Requires:
+- `serverUrl` — ntfy server URL (default: `https://ntfy.sh`)
+- `topic` — Topic name to publish to (acts as a channel)
+- `token` — Optional access token for authenticated servers
+- `priority` — 1-5 (default: 3)
+
+**Setup options:**
+1. **Interactive overlay:** Run `/unipi:notify-set-ntfy` for guided setup with connection test
+2. **Manual config:** Edit `config.json` directly with the fields above
+3. **Agent can write config:** Read the current config, merge changes, write back
+
 ## Commands
 
 | Command | Description |
@@ -82,6 +103,7 @@ Bot API notifications. Requires:
 | `/unipi:notify-settings` | TUI overlay to toggle platforms and events |
 | `/unipi:notify-set-gotify` | Interactive Gotify setup wizard |
 | `/unipi:notify-set-tg` | Interactive Telegram setup wizard |
+| `/unipi:notify-set-ntfy` | Interactive ntfy setup wizard |
 | `/unipi:notify-test` | Send test notification to all enabled platforms |
 
 ## Events
@@ -125,6 +147,7 @@ Read the JSON, make changes, write it back. Example:
 
 For Gotify: suggest running `/unipi:notify-set-gotify`
 For Telegram: suggest running `/unipi:notify-set-tg`
+For ntfy: suggest running `/unipi:notify-set-ntfy`
 For general settings: suggest `/unipi:notify-settings`
 
 ## Validation rules
@@ -132,3 +155,5 @@ For general settings: suggest `/unipi:notify-settings`
 - Gotify: `serverUrl` and `appToken` required when enabled
 - Gotify: `priority` must be 1-10
 - Telegram: `botToken` and `chatId` required when enabled
+- ntfy: `serverUrl` and `topic` required when enabled
+- ntfy: `priority` must be 1-5

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

@@ -205,6 +205,7 @@ describe("Badge generation — event bus (CRITICAL FIX)", () => {
     const validLifecycleEvents = [
       "session_start", "session_shutdown", "input",
       "tool_call", "tool_execution_start",
+      "agent_end", "before_agent_start",
     ];
 
     // Check that pi.on() is only used with lifecycle events
@@ -228,11 +229,26 @@ describe("Badge generation — event bus (CRITICAL FIX)", () => {
 // ─── Test: Event flow ──────────────────────────────────────────────
 
 describe("Badge generation — event flow", () => {
-  it("utility emits BADGE_GENERATE_REQUEST on first input", () => {
+  it("utility emits BADGE_GENERATE_REQUEST after agent responds (deferred from input)", () => {
     const src = readSource("packages/utility/src/index.ts");
 
+    // BADGE_GENERATE_REQUEST should be emitted in agent_end handler, not input
     assert.ok(src.includes("BADGE_GENERATE_REQUEST"));
     assert.ok(src.includes('source: "input-hook"'));
+
+    // input handler should NOT emit BADGE_GENERATE_REQUEST directly
+    const inputBlock = src.match(/pi\.on\("input"[\s\S]*?(?=pi\.on\(|$)/)?.[0] ?? "";
+    assert.ok(
+      !inputBlock.includes("BADGE_GENERATE_REQUEST"),
+      "input handler should NOT emit BADGE_GENERATE_REQUEST — deferred to agent_end",
+    );
+
+    // agent_end handler should emit BADGE_GENERATE_REQUEST
+    const agentEndBlock = src.match(/pi\.on\("agent_end"[\s\S]*?(?=pi\.on\(|$)/)?.[0] ?? "";
+    assert.ok(
+      agentEndBlock.includes("BADGE_GENERATE_REQUEST"),
+      "agent_end handler should emit BADGE_GENERATE_REQUEST with full conversation context",
+    );
   });
 
   it("BADGE_GENERATE_REQUEST event is defined in core", () => {

package/packages/subagents/src/agent-runner.ts

@@ -172,12 +172,16 @@ export async function runAgent(
   let toolNames = getToolNamesForType(type, agentConfig);
 
   // Create resource loader
+  // Respect agentConfig.extensions/skills flags: if explicitly false, skip loading.
+  // This prevents explore/work agents from loading all parent extensions.
   const agentDir = getAgentDir();
+  const skipExtensions = options.isolated || agentConfig?.extensions === false;
+  const skipSkills = options.isolated || agentConfig?.skills === false;
   const loader = new DefaultResourceLoader({
     cwd: effectiveCwd,
     agentDir,
-    noExtensions: options.isolated,
-    noSkills: options.isolated,
+    noExtensions: skipExtensions,
+    noSkills: skipSkills,
     noPromptTemplates: true,
     noThemes: true,
     noContextFiles: true,
@@ -213,15 +217,19 @@ export async function runAgent(
   });
   session.setActiveToolsByName(activeTools);
 
-  // Bind extensions
-  await session.bindExtensions({
-    onError: (err) => {
-      options.onToolActivity?.({
-        type: "end",
-        toolName: `extension-error:${err.extensionPath}`,
-      });
-    },
-  });
+  // Bind extensions — only if extensions were loaded.
+  // Skipping for agents with extensions: false avoids firing session_start
+  // on an empty extension set, preventing unnecessary MODULE_READY cascade.
+  if (!skipExtensions) {
+    await session.bindExtensions({
+      onError: (err) => {
+        options.onToolActivity?.({
+          type: "end",
+          toolName: `extension-error:${err.extensionPath}`,
+        });
+      },
+    });
+  }
 
   options.onSessionCreated?.(session);
 

package/packages/utility/src/index.ts

@@ -38,6 +38,12 @@ const VERSION = getPackageVersion(new URL(".", import.meta.url).pathname);
 /** Whether we've seen the first user message (for auto badge generation) */
 let firstMessageSeen = false;
 
+/** Stored user text from first input, used to build conversation summary after agent responds */
+let firstUserText = "";
+
+/** Stored UI context from first input, used to show badge overlay after agent responds */
+let firstInputCtx: any = null;
+
 /** All commands registered by this module */
 const ALL_COMMANDS = [
   UTILITY_COMMANDS.CONTINUE,
@@ -106,7 +112,7 @@ export default function (pi: ExtensionAPI) {
     }
   });
 
-  // First-message hook: auto-generate session name on first user message
+  // First-message hook: capture user text for deferred badge generation
   pi.on("input", async (_event: any, ctx: any) => {
     // Only trigger on first user message
     if (firstMessageSeen) return;
@@ -120,8 +126,8 @@ export default function (pi: ExtensionAPI) {
     const sessionName = pi.getSessionName?.();
     if (sessionName) return;
 
-    // Get first message text for context
-    const messageText = typeof _event?.content === "string"
+    // Store first message text for later use in agent_end
+    firstUserText = typeof _event?.content === "string"
       ? _event.content
       : Array.isArray(_event?.content)
         ? _event.content
@@ -130,16 +136,57 @@ export default function (pi: ExtensionAPI) {
             .join(" ")
         : "";
 
-    // Emit event for subagents to spawn background agent
-    emitEvent(pi, UNIPI_EVENTS.BADGE_GENERATE_REQUEST, {
-      source: "input-hook",
-      conversationSummary: messageText.slice(0, 500),
-    });
+    // Store ctx for badge overlay show after agent responds
+    firstInputCtx = ctx;
+  });
+
+  // After agent completes first response, generate badge name with full conversation context
+  pi.on("agent_end", async (event: any, _ctx: any) => {
+    // Only act if we captured a first input and are waiting for badge generation
+    if (!firstInputCtx) return;
+    const ctx = firstInputCtx;
+    firstInputCtx = null; // consume — only trigger once
+
+    // Check if a name was already set (e.g. manually) in the meantime
+    const sessionName = pi.getSessionName?.();
+    if (sessionName) return;
 
     // Show badge overlay if UI available
     if (ctx?.hasUI && !nameBadgeState.isVisible()) {
       await nameBadgeState.show(pi, ctx);
     }
+
+    // Build conversation summary from full message history (user + assistant)
+    const messages: any[] = event?.messages ?? [];
+    const summaryParts: string[] = [];
+
+    // Include the user's first message
+    if (firstUserText) {
+      summaryParts.push(`User: ${firstUserText}`);
+    }
+
+    // Include assistant's response text
+    const assistantMsgs = messages.filter((m: any) => m.role === "assistant");
+    for (const msg of assistantMsgs) {
+      if (Array.isArray(msg.content)) {
+        const textParts = msg.content
+          .filter((c: any) => c.type === "text")
+          .map((c: any) => c.text)
+          .join(" ");
+        if (textParts) summaryParts.push(`Assistant: ${textParts}`);
+      } else if (typeof msg.content === "string" && msg.content) {
+        summaryParts.push(`Assistant: ${msg.content}`);
+      }
+    }
+
+    // Truncate to reasonable size
+    const conversationSummary = summaryParts.join("\n").slice(0, 800);
+
+    // Emit event for subagents to spawn background agent
+    emitEvent(pi, UNIPI_EVENTS.BADGE_GENERATE_REQUEST, {
+      source: "input-hook",
+      conversationSummary,
+    });
   });
 
   // Track command usage
@@ -153,6 +200,8 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_shutdown", async () => {
     nameBadgeState.hide();
     firstMessageSeen = false;
+    firstUserText = "";
+    firstInputCtx = null;
     await lifecycle.shutdown("session_shutdown");
   });
 }