@pi-unipi/unipi 2.5.0 → 2.6.1

package/packages/core/bounded-output.ts

@@ -0,0 +1,106 @@
+import { chmodSync, lstatSync, mkdirSync, writeFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { randomUUID } from "node:crypto";
+
+export const DEFAULT_MODEL_OUTPUT_BYTES = 64 * 1024;
+export const MAX_RAW_ARTIFACT_BYTES = 16 * 1024 * 1024;
+
+export interface BoundedOutput {
+  text: string;
+  truncated: boolean;
+  originalBytes: number;
+  visibleBytes: number;
+  artifactPath?: string;
+}
+
+export interface BoundOutputOptions {
+  maxBytes?: number;
+  artifactPrefix?: string;
+  artifactDir?: string;
+}
+
+function byteSlice(text: string, start: number, end?: number): string {
+  return Buffer.from(text, "utf8").subarray(start, end).toString("utf8").replace(/\uFFFD+$/u, "");
+}
+
+function secureArtifactDir(customDir?: string): string {
+  const dir = customDir ?? join(homedir(), ".unipi", "tool-results");
+  mkdirSync(dir, { recursive: true, mode: 0o700 });
+  let stat = lstatSync(dir);
+  if (!stat.isDirectory() || stat.isSymbolicLink()) {
+    throw new Error(`Refusing unsafe tool-result directory: ${dir}`);
+  }
+  if ((stat.mode & 0o077) !== 0) {
+    chmodSync(dir, 0o700);
+    stat = lstatSync(dir);
+    if ((stat.mode & 0o077) !== 0) {
+      throw new Error(`Refusing non-private tool-result directory: ${dir}`);
+    }
+  }
+  return dir;
+}
+
+function safePrefix(prefix: string): string {
+  const safe = prefix.replace(/[^a-zA-Z0-9_-]/g, "-").replace(/-+/g, "-").slice(0, 48);
+  return safe || "tool-result";
+}
+
+/**
+ * Bound model-visible UTF-8 output and, up to the raw artifact safety cap,
+ * preserve the complete text in a private local artifact.
+ *
+ * Artifacts use random names and mode 0600 beneath a mode-0700 directory. The
+ * returned path is intentionally explicit so the agent can retrieve it with
+ * the ordinary read tool only when full output is actually needed.
+ */
+export function boundModelOutput(text: string, options: BoundOutputOptions = {}): BoundedOutput {
+  const maxBytes = Math.max(1024, Math.floor(options.maxBytes ?? DEFAULT_MODEL_OUTPUT_BYTES));
+  const originalBytes = Buffer.byteLength(text, "utf8");
+  if (originalBytes <= maxBytes) {
+    return { text, truncated: false, originalBytes, visibleBytes: originalBytes };
+  }
+
+  let artifactPath: string | undefined;
+  let artifactWarning: string | undefined;
+  if (originalBytes <= MAX_RAW_ARTIFACT_BYTES) {
+    try {
+      const dir = secureArtifactDir(options.artifactDir);
+      artifactPath = join(dir, `${safePrefix(options.artifactPrefix ?? "tool-result")}-${randomUUID()}.txt`);
+      writeFileSync(artifactPath, text, { encoding: "utf8", mode: 0o600, flag: "wx" });
+    } catch (error) {
+      artifactWarning = `Full-output artifact unavailable: ${error instanceof Error ? error.message : String(error)}`;
+      artifactPath = undefined;
+    }
+  } else {
+    artifactWarning = `Full output exceeded the ${MAX_RAW_ARTIFACT_BYTES}-byte local artifact safety cap and was not retained.`;
+  }
+
+  const marker = [
+    "",
+    "--- output bounded by UniPi ---",
+    artifactPath ? `Full output: ${artifactPath}` : artifactWarning!,
+    `Original size: ${originalBytes} bytes; model-visible ceiling: ${maxBytes} bytes.`,
+    ...(artifactPath ? ["Use the read tool with offset/limit to inspect only the needed region."] : []),
+  ].join("\n");
+  const omissionReserve = 80;
+  const markerBytes = Buffer.byteLength(marker, "utf8");
+  const contentBudget = Math.max(1, maxBytes - markerBytes - omissionReserve);
+  const headBytes = Math.ceil(contentBudget * 0.75);
+  const tailBytes = Math.max(0, contentBudget - headBytes);
+  const head = byteSlice(text, 0, headBytes);
+  const tail = tailBytes > 0 ? byteSlice(text, originalBytes - tailBytes) : "";
+  const omission = `\n… ${Math.max(0, originalBytes - contentBudget)} bytes omitted …\n`;
+  let bounded = `${head}${omission}${tail}${marker}`;
+  if (Buffer.byteLength(bounded, "utf8") > maxBytes) {
+    bounded = byteSlice(bounded, 0, maxBytes);
+  }
+
+  return {
+    text: bounded,
+    truncated: true,
+    originalBytes,
+    visibleBytes: Buffer.byteLength(bounded, "utf8"),
+    artifactPath,
+  };
+}

package/packages/core/constants.ts

@@ -168,6 +168,7 @@ export const UTILITY_COMMANDS = {
   BADGE_TOGGLE: "badge-toggle",
   BADGE_SETTINGS: "badge-settings",
   UTIL_SETTINGS: "util-settings",
+  PREFIX_CACHE: "prefix-cache",
 } as const;
 
 /** Utility tool names */
@@ -232,6 +233,7 @@ export const MCP_DEFAULTS = {
   STARTUP_TIMEOUT_MS: 10000,
   MAX_SERVERS: 20,
   TOOL_NAME_SEPARATOR: "__",
+  MAX_MODEL_OUTPUT_BYTES: 64 * 1024,
 } as const;
 
 /** Compactor sentinel — when passed as customInstructions to ctx.compact(),
@@ -295,6 +297,7 @@ export const NOTIFY_COMMANDS = {
   SET_NTFY: "notify-set-ntfy",
   TEST: "notify-test",
   RECAP_MODEL: "notify-recap-model",
+  NOTIFY_EVENT: "notify-event",
 } as const;
 
 /** Notify tool names */

package/packages/core/index.ts

@@ -10,3 +10,4 @@ export * from "./sandbox.js";
 export * from "./utils.js";
 export * from "./model-cache.js";
 export * from "./tui-width.js";
+export * from "./bounded-output.js";

package/packages/core/model-cache.ts

@@ -9,14 +9,18 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 
-/** Path to the model cache directory */
-const CACHE_DIR = path.join(
-  process.env.HOME ?? process.env.USERPROFILE ?? "~",
-  ".unipi/config",
-);
+/** Resolve the model cache directory at call time (respects HOME changes). */
+function cacheDir(): string {
+  return path.join(
+    process.env.HOME ?? process.env.USERPROFILE ?? "~",
+    ".unipi/config",
+  );
+}
 
-/** Path to the model cache file */
-const CACHE_FILE = path.join(CACHE_DIR, "models-cache.json");
+/** Resolve the model cache file path at call time. */
+function cacheFile(): string {
+  return path.join(cacheDir(), "models-cache.json");
+}
 
 /** A single cached model entry */
 export interface CachedModel {
@@ -42,8 +46,9 @@ export interface ModelCache {
  */
 export function readModelCache(): CachedModel[] {
   try {
-    if (!fs.existsSync(CACHE_FILE)) return [];
-    const parsed = JSON.parse(fs.readFileSync(CACHE_FILE, "utf-8"));
+    const file = cacheFile();
+    if (!fs.existsSync(file)) return [];
+    const parsed = JSON.parse(fs.readFileSync(file, "utf-8"));
     return Array.isArray(parsed.models) ? parsed.models : [];
   } catch {
     return [];
@@ -56,14 +61,15 @@ export function readModelCache(): CachedModel[] {
  */
 export function writeModelCache(models: CachedModel[]): void {
   try {
-    if (!fs.existsSync(CACHE_DIR)) {
-      fs.mkdirSync(CACHE_DIR, { recursive: true });
+    const dir = cacheDir();
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
     }
     const cache: ModelCache = {
       updatedAt: new Date().toISOString(),
       models,
     };
-    fs.writeFileSync(CACHE_FILE, JSON.stringify(cache, null, 2) + "\n", "utf-8");
+    fs.writeFileSync(cacheFile(), JSON.stringify(cache, null, 2) + "\n", "utf-8");
   } catch {
     // Best effort — cache is optional
   }

package/packages/core/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/core",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Shared utilities, event types, and constants for Unipi extension suite",
   "type": "module",
   "license": "MIT",

package/packages/footer/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/footer",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Persistent status bar for Unipi — subscribes to UNIPI_EVENTS and renders key stats from all unipi packages",
   "type": "module",
   "main": "index.ts",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.5.0"
+    "@pi-unipi/core": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/image/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/image",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Image generation and image recognition tools for the Pi coding agent",
   "type": "module",
   "main": "src/index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.5.0"
+    "@pi-unipi/core": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.80.0",

package/packages/info-screen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Dashboard and module registry for Unipi — configurable info overlay with tabbed groups",
   "type": "module",
   "main": "index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.5.0"
+    "@pi-unipi/core": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/input-shortcuts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/input-shortcuts",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Keyboard shortcuts for stash/restore, undo/redo, clipboard, and thinking toggle — chord-based overlay system",
   "type": "module",
   "main": "src/index.ts",
@@ -33,7 +33,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.5.0"
+    "@pi-unipi/core": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/kanboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/kanboard",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Visualization layer for unipi workflow — HTTP server with htmx/Alpine.js UI, modular parsers, TUI overlay, and kanban board",
   "type": "module",
   "main": "index.ts",
@@ -39,7 +39,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.5.0"
+    "@pi-unipi/core": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/mcp/README.md

@@ -39,6 +39,10 @@ MCP input properties are cloned and recursively canonicalized before registratio
 
 Pi 0.80 cannot remove dynamically registered tools. Enabling, disabling, deleting, or changing MCP servers is therefore applied on the next Pi restart rather than mutating the tool list mid-session. This prevents stale schemas and makes the restart an explicit cache-epoch boundary.
 
+### Bounded Results
+
+MCP text results are model-visible up to a hard 64 KiB ceiling. A larger result keeps a bounded head/tail preview and, when the raw result is at most 16 MiB, writes the complete text to a private mode-0600 artifact under `~/.unipi/tool-results/`. Existing result directories are tightened to mode 0700. The returned result includes the path and directs the agent to use `read` with offset/limit. Results above the raw safety cap or filesystem write failures still return a bounded preview with an explicit non-retention warning. MCP image bytes are not written by this text bridge; image blocks remain represented by MIME metadata as before.
+
 Example tool calls:
 ```
 github__search_code({ query: "authentication middleware" })

package/packages/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/mcp",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "MCP server management extension for Pi coding agent — browse, add, configure, and use MCP servers",
   "type": "module",
   "main": "src/index.ts",
@@ -30,7 +30,7 @@
     "test": "npx tsx --test tests/**/*.test.ts"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.5.0"
+    "@pi-unipi/core": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

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

@@ -5,7 +5,7 @@
  * Naming convention: {serverName}__{toolName}
  */
 
-import { MCP_DEFAULTS } from "@pi-unipi/core";
+import { MCP_DEFAULTS, boundModelOutput } from "@pi-unipi/core";
 import type { McpTool, McpToolResult } from "../types.js";
 import type { McpClient } from "./client.js";
 
@@ -170,21 +170,28 @@ export function translateMcpTool(
         }
       }
 
-      if (result.isError) {
-        const errorText = blocks.map((b) => b.text).join("\n") || "Unknown error";
-        return {
-          content: [{ type: "text", text: `MCP tool error from ${serverName}: ${errorText}` }],
-          details: { error: true, server: serverName, tool: mcpTool.name },
-        };
-      }
-
       if (blocks.length === 0) {
-        blocks.push({ type: "text", text: "(no output)" });
+        blocks.push({ type: "text", text: result.isError ? "Unknown error" : "(no output)" });
       }
 
+      const rawText = blocks.map((block) => block.text).join("\n");
+      const wrapper = result.isError ? `MCP tool error from ${serverName}: ` : "";
+      const output = boundModelOutput(rawText, {
+        maxBytes: Math.max(1024, MCP_DEFAULTS.MAX_MODEL_OUTPUT_BYTES - Buffer.byteLength(wrapper, "utf8")),
+        artifactPrefix: `mcp-${serverName}-${mcpTool.name}`,
+      });
+      const visibleText = `${wrapper}${output.text}`;
+
       return {
-        content: blocks,
-        details: { server: serverName, tool: mcpTool.name },
+        content: [{ type: "text", text: visibleText }],
+        details: {
+          error: result.isError || undefined,
+          server: serverName,
+          tool: mcpTool.name,
+          truncated: output.truncated,
+          originalBytes: output.originalBytes,
+          artifactPath: output.artifactPath,
+        },
       };
     } catch (err) {
       const message = err instanceof Error ? err.message : String(err);

package/packages/memory/index.ts

@@ -35,6 +35,54 @@ import { isEmbeddingReady, hasModelChanged } from "./settings.js";
 /** Package version */
 const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
 
+interface MemoryReminderInput {
+  projectName: string;
+  memories: Array<{ title: string }>;
+  canSearch: boolean;
+  canStore: boolean;
+}
+
+/**
+ * Build the deterministic, model-visible first-turn memory reminder.
+ * Exported so provider-payload regressions can exercise the exact production
+ * content without initializing a storage backend.
+ */
+export function buildMemoryRecallReminder(input: MemoryReminderInput): string {
+  const lines = [
+    "## 🧠 Memory System Active",
+    "",
+    `You have ${input.memories.length} memories stored for project "${input.projectName}".`,
+  ];
+
+  if (input.canSearch && input.memories.length > 0) {
+    const titleList = input.memories.slice(0, 20).map((memory) => `- ${memory.title}`).join("\n");
+    const extra = input.memories.length > 20
+      ? `\n... and ${input.memories.length - 20} more`
+      : "";
+    lines.push(
+      "**BEFORE starting work**, call `memory_search` with relevant keywords to check for existing context.",
+      "",
+      "Available memories:",
+      titleList + extra,
+    );
+  }
+
+  if (input.canStore) {
+    lines.push(
+      "",
+      "**AFTER completing the task**, if you learned something non-obvious,",
+      "call `memory_store` to save it for future sessions.",
+    );
+  }
+
+  lines.push(
+    "",
+    "Guardrails: read max 10 memory results per search. Update existing memories instead of creating duplicates.",
+  );
+
+  return lines.join("\n");
+}
+
 /** Storage instance for current project */
 let projectStorage: MemoryStorage | null = null;
 
@@ -251,44 +299,18 @@ export default function (pi: ExtensionAPI) {
       return;
     }
 
-    const lines = [
-      "## 🧠 Memory System Active",
-      "",
-      `You have ${projectMemories.length} memories stored for project "${projectName}".`,
-    ];
-
-    if (canSearch && projectMemories.length > 0) {
-      const titleList = projectMemories.slice(0, 20).map(m => `- ${m.title}`).join("\n");
-      const extra = projectMemories.length > 20 ? `\n... and ${projectMemories.length - 20} more` : "";
-      lines.push(
-        "**BEFORE starting work**, call `memory_search` with relevant keywords to check for existing context.",
-        "",
-        "Available memories:",
-        titleList + extra,
-      );
-    } else {
-      recallDone = true;
-    }
-
-    if (canStore) {
-      lines.push(
-        "",
-        "**AFTER completing the task**, if you learned something non-obvious,",
-        "call `memory_store` to save it for future sessions.",
-      );
-    } else {
-      storeDone = true;
-    }
-
-    lines.push(
-      "",
-      "Guardrails: read max 10 memory results per search. Update existing memories instead of creating duplicates.",
-    );
+    if (!canSearch || projectMemories.length === 0) recallDone = true;
+    if (!canStore) storeDone = true;
 
     return {
       message: {
         customType: "unipi-memory-recall-reminder",
-        content: lines.join("\n"),
+        content: buildMemoryRecallReminder({
+          projectName,
+          memories: projectMemories,
+          canSearch,
+          canStore,
+        }),
         display: false,
       },
     };

package/packages/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/memory",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Persistent cross-session memory with MemPalace backend (auto-installed) and SQLite fallback for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -43,8 +43,8 @@
     "better-sqlite3": "^12.9.0",
     "sqlite-vec": "^0.1.9",
     "js-yaml": "^4.1.0",
-    "@pi-unipi/core": "2.5.0",
-    "@pi-unipi/info-screen": "2.5.0"
+    "@pi-unipi/core": "2.6.1",
+    "@pi-unipi/info-screen": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/milestone/hooks.ts

@@ -51,7 +51,7 @@ function formatMilestoneContext(filePath: string): string | null {
 }
 
 /** Build an append-only snapshot that explicitly invalidates earlier snapshots. */
-function formatMilestoneSnapshot(workspace: string, context: string | null): string {
+export function formatMilestoneSnapshot(workspace: string, context: string | null): string {
   return [
     "# UniPi Milestone Snapshot",
     "This snapshot supersedes all prior UniPi milestone snapshots; use only this snapshot for milestone status.",

package/packages/milestone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/milestone",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Lifecycle layer for project-level goals — MILESTONES.md tracking, session hooks, auto-sync",
   "type": "module",
   "main": "index.ts",
@@ -32,7 +32,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.5.0"
+    "@pi-unipi/core": "2.6.1"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.80.0",

package/packages/notify/README.md

@@ -13,6 +13,7 @@ Configure once, get alerts everywhere. Per-event platform routing lets you send
 | `/unipi:notify-set-tg` | Interactive Telegram bot setup |
 | `/unipi:notify-set-ntfy` | Configure ntfy topic and server |
 | `/unipi:notify-recap-model` | Set model for notification recaps |
+| `/unipi:notify-event` | Toggle a single event without the TUI (`<event> <on\|off>`) — reports the new value; run `/reload` to re-register listeners |
 | `/unipi:notify-test` | Send test notification to all enabled platforms |
 
 ## Special Triggers

package/packages/notify/commands.ts

@@ -12,13 +12,32 @@ import { GotifySetupOverlay } from "./tui/gotify-setup.js";
 import { TelegramSetupOverlay } from "./tui/telegram-setup.js";
 import { NtfySetupOverlay } from "./tui/ntfy-setup.js";
 import { RecapModelSelectorOverlay } from "./tui/recap-model-selector.js";
-import { loadConfig } from "./settings.js";
+import type { CachedModel } from "@pi-unipi/core";
+import { loadConfig, saveConfig } from "./settings.js";
 import { loadNtfyConfig } from "./ntfy-config.js";
 import { sendNativeNotification, SuppressedError } from "./platforms/native.js";
 import { sendGotifyNotification } from "./platforms/gotify.js";
 import { sendTelegramNotification } from "./platforms/telegram.js";
 import { sendNtfyNotification } from "./platforms/ntfy.js";
 
+/**
+ * Collect models for the recap selector from Pi's live model registry.
+ * Returns undefined when the registry is unavailable so the overlay can fall
+ * back to the project-wide model cache (issue #27: selector was empty because
+ * it only read ~/.unipi/config/models-cache.json, which may not exist even
+ * when models are configured in ~/.pi/agent/models.json).
+ */
+function registryModels(ctx: ExtensionContext): CachedModel[] | undefined {
+  const registry = ctx.modelRegistry;
+  if (!registry) return undefined;
+  try {
+    const models = registry.getAvailable?.() ?? registry.getAll() ?? [];
+    return models.map((m) => ({ provider: m.provider, id: m.id, name: m.name }));
+  } catch {
+    return undefined;
+  }
+}
+
 /**
  * Register notify commands.
  */
@@ -44,7 +63,7 @@ export function registerNotifyCommands(pi: ExtensionAPI): void {
               // Open model selector as nested overlay
               ctx.ui.custom(
                 (innerTui: any, innerTheme: any, _innerKb: any, innerDone: any) => {
-                  const selector = new RecapModelSelectorOverlay();
+                  const selector = new RecapModelSelectorOverlay(registryModels(ctx));
                   selector.setTheme(innerTheme);
                   selector.onClose = () => innerDone(undefined);
                   selector.requestRender = () => innerTui.requestRender();
@@ -102,9 +121,10 @@ export function registerNotifyCommands(pi: ExtensionAPI): void {
           return;
         }
 
+        const models = registryModels(ctx);
         ctx.ui.custom(
           (tui, theme, _keybindings, done) => {
-            const overlay = new RecapModelSelectorOverlay();
+            const overlay = new RecapModelSelectorOverlay(models);
             overlay.setTheme(theme);
             overlay.onClose = () => done(undefined);
             overlay.requestRender = () => tui.requestRender();
@@ -251,6 +271,44 @@ export function registerNotifyCommands(pi: ExtensionAPI): void {
     }
   );
 
+  // /unipi:notify-event <event> <on|off> — Non-TUI event toggle (issue #27 escape
+  // hatch for terminals where overlay input is unusable)
+  pi.registerCommand(
+    `${UNIPI_PREFIX}${NOTIFY_COMMANDS.NOTIFY_EVENT}`,
+    {
+      description: "Toggle a notify event without the TUI: <event> <on|off>",
+      handler: async (args: string, ctx: ExtensionContext) => {
+        const parts = args.trim().split(/\s+/).filter(Boolean);
+        const [event, value] = parts;
+
+        if (parts.length !== 2 || (value !== "on" && value !== "off")) {
+          ctx.ui.notify(
+            "Usage: /unipi:notify-event <event> <on|off>",
+            "warning"
+          );
+          return;
+        }
+
+        const config = loadConfig();
+        if (!(event in config.events)) {
+          const known = Object.keys(config.events).join(", ");
+          ctx.ui.notify(
+            `Unknown event "${event}". Known events: ${known}`,
+            "error"
+          );
+          return;
+        }
+
+        config.events[event].enabled = value === "on";
+        saveConfig(config);
+        ctx.ui.notify(
+          `notify: ${event} is now ${value}. Run /reload to re-register listeners.`,
+          "info"
+        );
+      },
+    }
+  );
+
   // /unipi:notify-test — Send test notification to all enabled platforms
   pi.registerCommand(
     `${UNIPI_PREFIX}${NOTIFY_COMMANDS.TEST}`,

package/packages/notify/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "2.5.0",
+  "version": "2.6.1",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "main": "index.ts",
@@ -34,7 +34,7 @@
     "access": "public"
   },
   "dependencies": {
-    "@pi-unipi/core": "2.5.0",
+    "@pi-unipi/core": "2.6.1",
     "node-notifier": "^10.0.1"
   },
   "peerDependencies": {