@pi-unipi/notify 0.1.8 → 0.1.10

package/README.md

@@ -1,21 +1,52 @@
 # @pi-unipi/notify
 
-Cross-platform notification extension for Pi. Sends push notifications to native OS, Gotify, Telegram, and ntfy when agent lifecycle events occur.
+Push notifications when things happen. Workflow finishes, Ralph loop completes, MCP server errors — notify sends alerts to native OS, Gotify, Telegram, or ntfy.
 
-## What it does
+Configure once, get alerts everywhere. Per-event platform routing lets you send critical errors to Telegram and routine completions to Gotify.
 
-- Listens to Pi lifecycle events (workflow complete, Ralph loop done, MCP errors, etc.)
-- Routes notifications to your configured platforms
-- Provides `notify_user` tool for agent-initiated notifications
-- Per-event platform configuration with sensible defaults
+## 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-recap-model` | Set model for notification recaps |
+| `/unipi:notify-test` | Send test notification to all enabled platforms |
 
-## Installation
+## Special Triggers
 
-Part of the `@pi-unipi/unipi` meta-package. No separate install needed.
+Notify subscribes to Pi lifecycle events and routes notifications based on your config:
+
+| Event | Default | Description |
+|-------|---------|-------------|
+| `workflow_end` | On | Workflow command completes |
+| `ralph_loop_end` | On | Ralph loop completes |
+| `mcp_server_error` | On | MCP server error |
+| `agent_end` | Off | Agent finishes responding |
+| `memory_consolidated` | Off | Memory auto-saved |
+| `session_shutdown` | Off | Session ends |
+
+Notify registers with the info-screen dashboard, showing enabled platforms and last notification time. The footer subscribes to `NOTIFICATION_SENT` events to display notification stats.
+
+## Agent Tool
+
+| Tool | Description |
+|------|-------------|
+| `notify_user` | Send cross-platform notification |
+
+```
+notify_user({
+  title: "Build Failed",
+  message: "TypeScript compilation failed with 12 errors.",
+  priority: "high"
+})
+```
 
 ## Platforms
 
-### Native OS (default)
+### Native OS
 
 Desktop notifications via [node-notifier](https://github.com/mikaelbr/node-notifier):
 - **Windows:** SnoreToast (no admin required)
@@ -26,7 +57,7 @@ Zero configuration — works out of the box.
 
 ### Gotify
 
-Self-hosted push notification server. Configure in settings:
+Self-hosted push notification server:
 
 ```json
 {
@@ -41,26 +72,14 @@ Self-hosted push notification server. Configure in settings:
 
 ### Telegram
 
-Bot API notifications. Run setup command:
-
-```
-/unipi:notify-set-tg
-```
-
-This guides you through:
-1. Creating a bot via @BotFather
-2. Pasting the bot token
-3. Auto-detecting your chat ID
+Bot API notifications. Run `/unipi:notify-set-tg` for interactive setup:
+1. Create a bot via @BotFather
+2. Paste the bot token
+3. Auto-detect 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:
+HTTP-based pub-sub notifications via [ntfy.sh](https://ntfy.sh) or self-hosted:
 
 ```json
 {
@@ -73,54 +92,12 @@ Or configure manually:
 }
 ```
 
-## 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
-
-The `notify_user` tool is available to the agent for ad-hoc notifications:
-
-```
-notify_user({
-  title: "Build Failed",
-  message: "TypeScript compilation failed with 12 errors.",
-  priority: "high"
-})
-```
-
-See the bundled `notify` skill for full parameter documentation.
-
-## Event Configuration
-
-Notifications are triggered by these events (configurable in settings):
-
-| Event | Default | Description |
-|-------|---------|-------------|
-| `workflow_end` | On | Workflow command completes |
-| `ralph_loop_end` | On | Ralph loop completes |
-| `mcp_server_error` | On | MCP server error |
-| `agent_end` | Off | Agent finishes responding |
-| `memory_consolidated` | Off | Memory auto-saved |
-| `session_shutdown` | Off | Session ends |
+## Configurables
 
-## Configuration
+Settings stored at `~/.unipi/config/notify/config.json`. Edit via `/unipi:notify-settings` or manual JSON editing.
 
-Settings stored at `~/.unipi/config/notify/config.json`. Edit via:
-- Settings overlay: `/unipi:notify-settings`
-- Manual JSON editing
-- The agent can read config via the settings module
+Per-event platform routing lets you control where each event type goes. The settings overlay shows all events with platform toggles.
 
-## Info-Screen Integration
+## License
 
-The notify module registers with the info screen showing:
-- Enabled platform count
-- Active event subscriptions
-- Last notification timestamp
-- Total notifications sent this session
+MIT

package/commands.ts

@@ -13,6 +13,7 @@ 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 { loadNtfyConfig } from "./ntfy-config.js";
 import { sendNativeNotification } from "./platforms/native.js";
 import { sendGotifyNotification } from "./platforms/gotify.js";
 import { sendTelegramNotification } from "./platforms/telegram.js";
@@ -310,16 +311,17 @@ export function registerNotifyCommands(pi: ExtensionAPI): void {
           }
         }
 
-        // ntfy
-        if (config.ntfy.enabled && config.ntfy.serverUrl && config.ntfy.topic) {
+        // ntfy — resolved from project/global ntfy.json
+        const ntfyConfig = loadNtfyConfig(process.cwd());
+        if (ntfyConfig.enabled && ntfyConfig.serverUrl && ntfyConfig.topic) {
           try {
             await sendNtfyNotification(
-              config.ntfy.serverUrl,
-              config.ntfy.topic,
+              ntfyConfig.serverUrl,
+              ntfyConfig.topic,
               title,
               message,
-              config.ntfy.priority,
-              config.ntfy.token
+              ntfyConfig.priority,
+              ntfyConfig.token
             );
             results.push("✓ ntfy: sent");
           } catch (err) {

package/events.ts

@@ -8,6 +8,7 @@
 import type { ExtensionAPI, ExtensionContext } from "@mariozechner/pi-coding-agent";
 import { UNIPI_EVENTS, emitEvent } from "@pi-unipi/core";
 import type { NotifyConfig, NotifyPlatform, NotifyDispatchResult } from "./types.js";
+import { loadNtfyConfig } from "./ntfy-config.js";
 import { sendNativeNotification } from "./platforms/native.js";
 import { sendGotifyNotification } from "./platforms/gotify.js";
 import { sendTelegramNotification } from "./platforms/telegram.js";
@@ -47,7 +48,8 @@ export const BUILTIN_EVENTS: Record<
  */
 export function registerEventListeners(
   pi: ExtensionAPI,
-  config: NotifyConfig
+  config: NotifyConfig,
+  cwd: string
 ): void {
   // Register built-in events (except agent_end which has custom logic)
   for (const [eventKey, def] of Object.entries(BUILTIN_EVENTS)) {
@@ -60,8 +62,10 @@ export function registerEventListeners(
       const title = `Pi — ${def.label}`;
       const message = buildEventMessage(eventKey, payload);
       // Fire-and-forget: don't block the event emitter
-      dispatchNotification(pi, title, message, eventConfig.platforms, eventKey, config).catch(
-        (err) => console.error(`[notify] Background notification failed for ${eventKey}:`, err)
+      dispatchNotification(pi, title, message, eventConfig.platforms, eventKey, config, cwd).catch(
+        () => {
+          // Silently ignore — background notification failure is non-blocking.
+        }
       );
     };
 
@@ -96,9 +100,11 @@ export function registerEventListeners(
               })
               .catch(() => buildAgentEndMessage(sessionName))
               .then((message) =>
-                dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config)
+                dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config, cwd)
               )
-              .catch((err) => console.error("[notify] Background agent_end notification failed:", err));
+              .catch(() => {
+                // Silently ignore — background agent_end notification failure is non-blocking.
+              });
             return;
           }
         }
@@ -106,8 +112,10 @@ export function registerEventListeners(
 
       // No recap or recap unavailable: dispatch immediately in background
       const message = buildAgentEndMessage(sessionName);
-      dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config).catch(
-        (err) => console.error("[notify] Background agent_end notification failed:", err)
+      dispatchNotification(pi, title, message, agentEndConfig.platforms, "agent_end", config, cwd).catch(
+        () => {
+          // Silently ignore — background agent_end notification failure is non-blocking.
+        }
       );
     };
 
@@ -126,12 +134,12 @@ export function registerEventListeners(
 }
 
 /** Get all platforms that are currently enabled in config */
-function getEnabledPlatforms(config: NotifyConfig): NotifyPlatform[] {
+function getEnabledPlatforms(config: NotifyConfig, ntfyEnabled: boolean): NotifyPlatform[] {
   const enabled: NotifyPlatform[] = [];
   if (config.native.enabled) enabled.push("native");
   if (config.gotify.enabled) enabled.push("gotify");
   if (config.telegram.enabled) enabled.push("telegram");
-  if (config.ntfy.enabled) enabled.push("ntfy");
+  if (ntfyEnabled) enabled.push("ntfy");
   return enabled;
 }
 
@@ -148,34 +156,35 @@ export async function dispatchNotification(
   message: string,
   eventPlatforms: NotifyPlatform[],
   eventType: string,
-  config: NotifyConfig
+  config: NotifyConfig,
+  cwd: string
 ): Promise<NotifyDispatchResult> {
+  // Resolve ntfy config from project/global ntfy.json
+  const ntfyConfig = loadNtfyConfig(cwd);
+
   // Resolve platforms: event-specific → all enabled → global defaults
   const platforms =
     eventPlatforms.length > 0
       ? eventPlatforms
-      : getEnabledPlatforms(config).length > 0
-        ? getEnabledPlatforms(config)
+      : getEnabledPlatforms(config, ntfyConfig.enabled).length > 0
+        ? getEnabledPlatforms(config, ntfyConfig.enabled)
         : config.defaultPlatforms;
 
   const enabledPlatforms = platforms.filter((p) => {
     if (p === "native") return config.native.enabled;
     if (p === "gotify") return config.gotify.enabled;
     if (p === "telegram") return config.telegram.enabled;
-    if (p === "ntfy") return config.ntfy.enabled;
+    if (p === "ntfy") return ntfyConfig.enabled;
     return false;
   });
 
   const results = await Promise.all(
     enabledPlatforms.map(async (platform) => {
       try {
-        await sendToPlatform(platform, title, message, config);
+        await sendToPlatform(platform, title, message, config, cwd);
         return { platform, success: true };
       } catch (err) {
-        console.error(
-          `[notify] Failed to send via ${platform}:`,
-          err instanceof Error ? err.message : err
-        );
+        // Silently ignore — platform send failure is tracked in results.
         return {
           platform,
           success: false,
@@ -203,7 +212,8 @@ async function sendToPlatform(
   platform: NotifyPlatform,
   title: string,
   message: string,
-  config: NotifyConfig
+  config: NotifyConfig,
+  cwd: string
 ): Promise<void> {
   switch (platform) {
     case "native":
@@ -234,19 +244,22 @@ async function sendToPlatform(
         message
       );
       break;
-    case "ntfy":
-      if (!config.ntfy.serverUrl || !config.ntfy.topic) {
+    case "ntfy": {
+      const ntfyConfig = loadNtfyConfig(cwd);
+      if (!ntfyConfig.enabled) return;
+      if (!ntfyConfig.serverUrl || !ntfyConfig.topic) {
         throw new Error("ntfy: serverUrl and topic are required");
       }
       await sendNtfyNotification(
-        config.ntfy.serverUrl,
-        config.ntfy.topic,
+        ntfyConfig.serverUrl,
+        ntfyConfig.topic,
         title,
         message,
-        config.ntfy.priority,
-        config.ntfy.token
+        ntfyConfig.priority,
+        ntfyConfig.token
       );
       break;
+    }
   }
 }
 

package/index.ts

@@ -42,8 +42,9 @@ export default function (pi: ExtensionAPI) {
   // Session lifecycle — register events and announce module
   pi.on("session_start", async (_event, ctx) => {
     setSessionContext(ctx);
+    const cwd = process.cwd();
     const config = loadConfig();
-    registerEventListeners(pi, config);
+    registerEventListeners(pi, config, cwd);
 
     emitEvent(pi, UNIPI_EVENTS.MODULE_READY, {
       name: MODULES.NOTIFY,

package/ntfy-config.ts

@@ -0,0 +1,178 @@
+/**
+ * @pi-unipi/notify — Project-level ntfy configuration
+ *
+ * Loads, saves, and resolves ntfy config from dedicated ntfy.json files
+ * at global (~/.unipi/config/notify/ntfy.json) and project
+ * (<cwd>/.unipi/config/notify/ntfy.json) scope.
+ *
+ * Resolution: project → global → defaults.
+ */
+
+import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
+import { dirname, join } from "path";
+import { homedir } from "os";
+import type { NtfyConfig } from "./types.js";
+
+/** Default ntfy configuration */
+const DEFAULT_NTFY_CONFIG: NtfyConfig = {
+  enabled: false,
+  serverUrl: "https://ntfy.sh",
+  priority: 3,
+};
+
+/** Global ntfy.json path: ~/.unipi/config/notify/ntfy.json */
+function getGlobalNtfyPath(): string {
+  return join(homedir(), ".unipi", "config", "notify", "ntfy.json");
+}
+
+/** Project ntfy.json path: <cwd>/.unipi/config/notify/ntfy.json */
+function getProjectNtfyPath(cwd: string): string {
+  return join(cwd, ".unipi", "config", "notify", "ntfy.json");
+}
+
+/**
+ * Read and parse a ntfy.json file.
+ * Returns null if file doesn't exist (ENOENT).
+ * Returns null and logs warning on parse error.
+ */
+function readNtfyJson(filePath: string): NtfyConfig | null {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(raw) as Partial<NtfyConfig>;
+    return { ...DEFAULT_NTFY_CONFIG, ...parsed };
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      return null;
+    }
+    console.warn(`[notify] Failed to parse ${filePath}: ${(err as Error).message}. Falling back.`);
+    return null;
+  }
+}
+
+/**
+ * Resolve ntfy config with project → global → defaults priority.
+ *
+ * 1. If project ntfy.json exists → use it
+ * 2. If only global ntfy.json exists → use it
+ * 3. If neither exists → return defaults (ntfy disabled)
+ *
+ * Runs legacy migration once if global ntfy.json is missing.
+ */
+export function loadNtfyConfig(cwd: string): NtfyConfig {
+  // Attempt migration from legacy config.json if global ntfy.json doesn't exist
+  migrateFromLegacyConfig();
+
+  // Try project-level first
+  const projectConfig = readNtfyJson(getProjectNtfyPath(cwd));
+  if (projectConfig !== null) {
+    return projectConfig;
+  }
+
+  // Try global level
+  const globalConfig = readNtfyJson(getGlobalNtfyPath());
+  if (globalConfig !== null) {
+    return globalConfig;
+  }
+
+  // Neither exists — return defaults
+  return { ...DEFAULT_NTFY_CONFIG };
+}
+
+/**
+ * Save ntfy config to the chosen scope.
+ * Creates parent directory if needed.
+ */
+export function saveNtfyConfig(
+  scope: "project" | "global",
+  cwd: string,
+  config: NtfyConfig
+): void {
+  const filePath =
+    scope === "project" ? getProjectNtfyPath(cwd) : getGlobalNtfyPath();
+  const dir = dirname(filePath);
+  mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, JSON.stringify(config, null, 2) + "\n", "utf-8");
+}
+
+/**
+ * Detect which scope is currently active for ntfy config.
+ *
+ * - "project" if project ntfy.json exists
+ * - "global" if global ntfy.json exists (and no project override)
+ * - "none" if neither exists
+ */
+export function getNtfyConfigScope(
+  cwd: string
+): "project" | "global" | "none" {
+  if (existsSync(getProjectNtfyPath(cwd))) {
+    return "project";
+  }
+  if (existsSync(getGlobalNtfyPath())) {
+    return "global";
+  }
+  return "none";
+}
+
+/**
+ * One-time migration from legacy config.json ntfy section to ntfy.json.
+ *
+ * Trigger conditions:
+ * - Global ntfy.json does NOT exist
+ * - config.json has non-default ntfy settings (enabled or topic/serverUrl set)
+ *
+ * After migration, config.json ntfy section is left untouched.
+ * Future reads use ntfy.json exclusively.
+ */
+export function migrateFromLegacyConfig(): void {
+  const globalNtfyPath = getGlobalNtfyPath();
+
+  // Only migrate if global ntfy.json doesn't exist yet
+  if (existsSync(globalNtfyPath)) {
+    return;
+  }
+
+  // Try to read legacy config.json
+  const legacyConfigPath = join(
+    homedir(),
+    ".unipi",
+    "config",
+    "notify",
+    "config.json"
+  );
+
+  try {
+    if (!existsSync(legacyConfigPath)) return;
+    const raw = readFileSync(legacyConfigPath, "utf-8");
+    const parsed = JSON.parse(raw) as Record<string, unknown>;
+    const ntfySection = parsed.ntfy as Partial<NtfyConfig> | undefined;
+
+    if (!ntfySection) return;
+
+    // Only migrate if there's something meaningful to migrate
+    const hasCustomConfig =
+      ntfySection.enabled === true ||
+      (ntfySection.serverUrl && ntfySection.serverUrl !== "https://ntfy.sh") ||
+      ntfySection.topic;
+
+    if (!hasCustomConfig) return;
+
+    // Write ntfy.json from legacy config
+    const migratedConfig: NtfyConfig = {
+      enabled: ntfySection.enabled ?? false,
+      serverUrl: ntfySection.serverUrl ?? "https://ntfy.sh",
+      topic: ntfySection.topic,
+      token: ntfySection.token,
+      priority: ntfySection.priority ?? 3,
+    };
+
+    const dir = dirname(globalNtfyPath);
+    mkdirSync(dir, { recursive: true });
+    writeFileSync(
+      globalNtfyPath,
+      JSON.stringify(migratedConfig, null, 2) + "\n",
+      "utf-8"
+    );
+  } catch {
+    // Migration failure is non-fatal — silently continue
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "0.1.8",
+  "version": "0.1.10",
   "description": "Cross-platform notification extension for Pi — native OS, Gotify, and Telegram notifications for agent lifecycle events",
   "type": "module",
   "license": "MIT",
@@ -24,6 +24,7 @@
     "commands.ts",
     "settings.ts",
     "events.ts",
+    "ntfy-config.ts",
     "summarize.ts",
     "types.ts",
     "platforms/*",

package/skills/configure-notify/SKILL.md

@@ -16,9 +16,13 @@ Help users configure the `@pi-unipi/notify` notification system.
 - User wants to change which events trigger notifications
 - User asks about notification settings
 
-## Config location
+## Config locations
 
-`~/.unipi/config/notify/config.json`
+**Main config (platforms + events):** `~/.unipi/config/notify/config.json`
+
+**ntfy config (dedicated file):**
+- Global: `~/.unipi/config/notify/ntfy.json`
+- Project: `<project>/.unipi/config/notify/ntfy.json`
 
 ## Config structure
 
@@ -54,7 +58,8 @@ Help users configure the `@pi-unipi/notify` notification system.
     "topic": null,
     "token": null,
     "priority": 3
-  }
+  },
+  "NOTE": "ntfy section is legacy — migrated to ntfy.json on first run"
 }
 ```
 
@@ -92,9 +97,41 @@ Requires:
 - `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
+1. **Interactive overlay:** Run `/unipi:notify-set-ntfy` for guided setup with scope selection and connection test
+2. **Manual config:** Edit `ntfy.json` directly (see Project-Level ntfy Config below)
+3. **Agent can write config:** Read the current ntfy.json, merge changes, write back
+
+### Project-Level ntfy Config
+
+ntfy uses dedicated `ntfy.json` files at both global and project scope, with full override semantics.
+
+**File locations:**
+- Global: `~/.unipi/config/notify/ntfy.json` (all projects)
+- Project: `<project>/.unipi/config/notify/ntfy.json` (this project only)
+
+**Resolution order (at dispatch time):**
+1. Project `ntfy.json` exists → use it (full override)
+2. No project config → use global `ntfy.json`
+3. Neither exists → ntfy is effectively disabled
+
+**ntfy.json shape:**
+```json
+{
+  "enabled": true,
+  "serverUrl": "https://ntfy.sh",
+  "topic": "my-project-alerts",
+  "token": null,
+  "priority": 3
+}
+```
+
+**Scope selection in wizard:** When running `/unipi:notify-set-ntfy`, the wizard now asks where to save the config (Global or Project). Re-running the wizard pre-selects the current scope and pre-fills existing values.
+
+**Settings overlay:** The ntfy line in `/unipi:notify-settings` shows topic, priority, and scope label (`[project]`, `[global]`, or "Not configured").
+
+**Migration:** On first run, if `config.json` has ntfy settings and `ntfy.json` doesn't exist, settings are automatically migrated to `ntfy.json`. The legacy `config.json` ntfy section is left untouched for backward compatibility.
+
+**Manual config:** Edit the appropriate `ntfy.json` file directly with the fields above.
 
 ## Commands
 

package/tools.ts

@@ -64,16 +64,18 @@ export function registerNotifyTools(pi: ExtensionAPI): void {
       const notifPlatforms = platforms || config.defaultPlatforms;
 
       // Fire-and-forget: dispatch in background so the tool doesn't block the agent
+      const cwd = process.cwd();
       dispatchNotification(
         pi,
         notifTitle,
         message,
         notifPlatforms,
         "agent_tool",
-        config
-      ).catch((err) =>
-        console.error("[notify] Background notify_user dispatch failed:", err)
-      );
+        config,
+        cwd
+      ).catch(() => {
+        // Silently ignore — background dispatch failure is non-blocking.
+      });
 
       return {
         content: [

package/tui/ntfy-setup.ts

@@ -10,10 +10,11 @@ import type { Component } from "@mariozechner/pi-tui";
 import { truncateToWidth, visibleWidth } from "@mariozechner/pi-tui";
 import type { Theme } from "@mariozechner/pi-coding-agent";
 import { sendNtfyNotification } from "../platforms/ntfy.js";
-import { updateConfig, loadConfig } from "../settings.js";
+import { loadNtfyConfig, saveNtfyConfig, getNtfyConfigScope } from "../ntfy-config.js";
 
 type SetupPhase =
   | "instructions"
+  | "scope"
   | "server-url"
   | "topic"
   | "token"
@@ -28,6 +29,8 @@ type SetupPhase =
  */
 export class NtfySetupOverlay implements Component {
   private phase: SetupPhase = "instructions";
+  private scope: "global" | "project" = "global";
+  private scopeIndex = 0; // 0 = global, 1 = project
   private serverUrl = "";
   private topic = "";
   private token = "";
@@ -41,12 +44,18 @@ export class NtfySetupOverlay implements Component {
   private theme: Theme | null = null;
 
   constructor() {
-    // Pre-fill from existing config if available
-    const config = loadConfig();
-    if (config.ntfy.serverUrl) this.serverUrl = config.ntfy.serverUrl;
-    if (config.ntfy.topic) this.topic = config.ntfy.topic;
-    if (config.ntfy.token) this.token = config.ntfy.token;
-    if (config.ntfy.priority) this.priority = String(config.ntfy.priority);
+    // Determine current scope and pre-fill from resolved config
+    const cwd = process.cwd();
+    const existingScope = getNtfyConfigScope(cwd);
+    if (existingScope !== "none") {
+      this.scope = existingScope;
+      this.scopeIndex = existingScope === "project" ? 1 : 0;
+    }
+    const config = loadNtfyConfig(cwd);
+    if (config.serverUrl) this.serverUrl = config.serverUrl;
+    if (config.topic) this.topic = config.topic;
+    if (config.token) this.token = config.token;
+    if (config.priority) this.priority = String(config.priority);
   }
 
   setTheme(theme: Theme): void {
@@ -59,6 +68,21 @@ export class NtfySetupOverlay implements Component {
     switch (this.phase) {
       case "instructions":
         if (data === "\r" || data === " ") {
+          this.phase = "scope";
+        } else if (data === "\x1b") {
+          this.onClose?.();
+        }
+        break;
+
+      case "scope":
+        if (data === "\x1b[A" || data === "k") {
+          // Up
+          this.scopeIndex = Math.max(0, this.scopeIndex - 1);
+        } else if (data === "\x1b[B" || data === "j") {
+          // Down
+          this.scopeIndex = Math.min(1, this.scopeIndex + 1);
+        } else if (data === "\r" || data === " ") {
+          this.scope = this.scopeIndex === 1 ? "project" : "global";
           this.phase = this.serverUrl ? "topic" : "server-url";
         } else if (data === "\x1b") {
           this.onClose?.();
@@ -206,14 +230,13 @@ export class NtfySetupOverlay implements Component {
   }
 
   private saveConfig(): void {
-    updateConfig({
-      ntfy: {
-        enabled: true,
-        serverUrl: this.serverUrl.replace(/\/$/, ""),
-        topic: this.topic,
-        token: this.token || undefined,
-        priority: parseInt(this.priority, 10) || 3,
-      },
+    const cwd = process.cwd();
+    saveNtfyConfig(this.scope, cwd, {
+      enabled: true,
+      serverUrl: this.serverUrl.replace(/\/$/, ""),
+      topic: this.topic,
+      token: this.token || undefined,
+      priority: parseInt(this.priority, 10) || 3,
     });
   }
 
@@ -336,6 +359,36 @@ export class NtfySetupOverlay implements Component {
         );
         break;
 
+      case "scope": {
+        lines.push(
+          this.frameLine(
+            this.fg("dim", "Where should this config be saved?"),
+            innerWidth
+          )
+        );
+        lines.push(this.frameLine("", innerWidth));
+        const options = ["Global (all projects)", "Project (this project only)"];
+        for (let i = 0; i < options.length; i++) {
+          const isSelected = i === this.scopeIndex;
+          const label = isSelected ? this.bold(options[i]) : this.fg("dim", options[i]);
+          lines.push(
+            this.frameLine(
+              `  ${isSelected ? this.fg("accent", "▸") : " "} ${label}`,
+              innerWidth
+            )
+          );
+        }
+        lines.push(this.frameLine("", innerWidth));
+        lines.push(this.ruleLine(innerWidth));
+        lines.push(
+          this.frameLine(
+            this.fg("dim", "↑↓ select · Enter confirm · Esc cancel"),
+            innerWidth
+          )
+        );
+        break;
+      }
+
       case "server-url":
         lines.push(
           this.frameLine(

package/tui/settings-overlay.ts

@@ -13,7 +13,8 @@ import {
   saveConfig,
   validateConfig,
 } from "../settings.js";
-import type { NotifyConfig } from "../types.js";
+import { loadNtfyConfig, saveNtfyConfig, getNtfyConfigScope } from "../ntfy-config.js";
+import type { NotifyConfig, NtfyConfig } from "../types.js";
 
 /** Section types */
 type Section = "platforms" | "events" | "recap";
@@ -23,6 +24,8 @@ type Section = "platforms" | "events" | "recap";
  */
 export class NotifySettingsOverlay implements Component {
   private config: NotifyConfig;
+  private ntfyConfig: NtfyConfig;
+  private ntfyScope: "project" | "global" | "none";
   private section: Section = "platforms";
   private selectedIndex = 0;
   private error: string | null = null;
@@ -35,6 +38,9 @@ export class NotifySettingsOverlay implements Component {
 
   constructor() {
     this.config = loadConfig();
+    const cwd = process.cwd();
+    this.ntfyConfig = loadNtfyConfig(cwd);
+    this.ntfyScope = getNtfyConfigScope(cwd);
   }
 
   setTheme(theme: Theme): void {
@@ -93,7 +99,10 @@ export class NotifySettingsOverlay implements Component {
         "ntfy",
       ];
       const key = platforms[this.selectedIndex];
-      if (key) {
+      if (key === "ntfy") {
+        // ntfy toggle updates the resolved ntfy config
+        this.ntfyConfig.enabled = !this.ntfyConfig.enabled;
+      } else if (key) {
         this.config[key].enabled = !this.config[key].enabled;
       }
     } else if (this.section === "recap") {
@@ -115,6 +124,10 @@ export class NotifySettingsOverlay implements Component {
     }
     this.error = null;
     saveConfig(this.config);
+    // Save ntfy config to its own file if scope is known
+    if (this.ntfyScope !== "none") {
+      saveNtfyConfig(this.ntfyScope, process.cwd(), this.ntfyConfig);
+    }
     this.saved = true;
     setTimeout(() => this.onClose?.(), 500);
   }
@@ -237,9 +250,9 @@ export class NotifySettingsOverlay implements Component {
       {
         key: "ntfy",
         label: "ntfy",
-        detail: this.config.ntfy.serverUrl
-          ? `Server: ${this.config.ntfy.serverUrl}`
-          : "Self-hosted push service",
+        detail: this.ntfyScope !== "none"
+          ? `Topic: ${this.ntfyConfig.topic ?? "—"} · P${this.ntfyConfig.priority} · [${this.ntfyScope}]`
+          : "Not configured",
       },
     ];
 
@@ -248,7 +261,9 @@ export class NotifySettingsOverlay implements Component {
       const isSelected = i === this.selectedIndex;
       const toggleOn = this.fg("success", "●");
       const toggleOff = this.fg("dim", "○");
-      const toggle = this.config[p.key].enabled ? toggleOn : toggleOff;
+      // ntfy enabled state comes from resolved ntfy.json, not config.json
+      const isEnabled = p.key === "ntfy" ? this.ntfyConfig.enabled : this.config[p.key].enabled;
+      const toggle = isEnabled ? toggleOn : toggleOff;
       const label = isSelected ? this.bold(p.label) : this.fg("dim", p.label);
 
       lines.push(