@pi-unipi/notify 2.17.0 → 2.19.0

package/README.md

@@ -32,6 +32,8 @@ Notify subscribes to Pi lifecycle events and routes notifications based on your
 | `ask_user_prompt` | Off | Agent asked a question and is waiting for an answer |
 | `permission_request` | Off | A permission prompt is about to be shown (requires [`@gotgenes/pi-permission-system`](https://www.npmjs.com/package/@gotgenes/pi-permission-system)) |
 
+`ask_user_prompt` and `permission_request` are **blocking** events: while one is unanswered the agent is parked, so notify re-sends it periodically (see [Re-notify unanswered prompts](#re-notify-unanswered-prompts)).
+
 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
@@ -75,7 +77,25 @@ After a terminal keypress, listed platforms stay quiet for `windowMs`. Default:
 }
 ```
 
-Add `gotify`, `telegram`, or `ntfy` to `platforms` to silence those channels too. Empty `platforms` silences all enabled platforms (same as `events.*.platforms`).
+Add `gotify`, `telegram`, or `ntfy` to `platforms` to silence those channels too. Empty `platforms` silences all enabled platforms (same as `events.*.platforms`). Blocking events (`ask_user_prompt`, `permission_request`) are never silenced — see below.
+
+### Re-notify unanswered prompts
+
+When a blocking prompt (`ask_user_prompt`, `permission_request`) is not answered, notify re-sends the same notification every `intervalMs`, with the title suffixed `(still waiting)` and priority `high`, up to `maxRepeats` times. Default: **on**, every 2 minutes, 3 repeats. This is the one notify case where missing the push leaves the agent parked indefinitely.
+
+```json
+{
+  "renotify": {
+    "enabled": true,
+    "intervalMs": 120000,
+    "maxRepeats": 3
+  }
+}
+```
+
+`maxRepeats: 0` sends the initial notification only. Reminders stop as soon as any of these fires: the user presses a key, herdr reports `herdr:blocked` `active: false`, the agent starts a new turn (`agent_start`), or the session ends. Only one prompt can be outstanding at a time — arming a new one replaces the previous reminder. Reminders bypass `silenceAfterInput` because blocking events are exempt from it.
+
+Edit in `/unipi:notify-settings` → Re-notify, or in `~/.unipi/config/notify/config.json`.
 
 ### Gotify
 

package/activity.ts

@@ -19,6 +19,20 @@ const VALID_PLATFORMS: ReadonlySet<NotifyPlatform> = new Set([
   "ntfy",
 ]);
 
+/**
+ * Events where a human is blocking the session. They arrive seconds after the
+ * keypress that caused them, so recent input must never mute them.
+ */
+const BLOCKING_EVENTS: ReadonlySet<string> = new Set([
+  "ask_user_prompt",
+  "permission_request",
+]);
+
+/** Whether an event type is a human-blocking prompt. */
+export function isBlockingEvent(eventType: string | undefined): boolean {
+  return eventType !== undefined && BLOCKING_EVENTS.has(eventType);
+}
+
 let lastInputAt = 0;
 
 /** Record a terminal keypress. `at` is injectable for tests. */
@@ -36,12 +50,19 @@ export function resetInputActivity(): void {
  * Does not look at platform `enabled` flags — caller filters those first.
  * Empty `platforms` (while enabled) silences all incoming channels, matching
  * `events.*.platforms: []` → all enabled.
+ *
+ * Human-blocking events (`ask_user_prompt`, `permission_request`) bypass the
+ * filter entirely — the keypress that triggered them must not mute them.
  */
 export function filterPlatformsAfterInput(
   platforms: NotifyPlatform[],
   config: Pick<NotifyConfig, "silenceAfterInput">,
   now: number = Date.now(),
+  eventType?: string,
 ): { send: NotifyPlatform[]; silenced: NotifyPlatform[] } {
+  if (isBlockingEvent(eventType)) {
+    return { send: platforms.slice(), silenced: [] };
+  }
   const cfg = config.silenceAfterInput;
   if (!shouldSilence(cfg, now)) {
     return { send: platforms.slice(), silenced: [] };

package/events.ts

@@ -16,7 +16,7 @@ import { sendNtfyNotification } from "./platforms/ntfy.js";
 import { buildAskUserPromptMessage } from "./ask-user-prompt-message.js";
 import { buildPermissionPromptMessage } from "./permission-prompt-message.js";
 import { summarizeLastMessage } from "./summarize.js";
-import { filterPlatformsAfterInput } from "./activity.js";
+import { filterPlatformsAfterInput, isBlockingEvent } from "./activity.js";
 
 // Event emitted by @juicesharp/rpiv-ask-user-question before showing its UI.
 // Keep this as a local string until that package publishes an importable
@@ -30,14 +30,107 @@ const ASK_USER_PROMPT_EVENT = "rpiv:ask-user:prompt" as const;
 // third-party package rather than the unipi event contract.
 const PERMISSION_UI_PROMPT_EVENT = "permissions:ui_prompt" as const;
 
+/** Minimal shape of the background-tasks shared registry (optional sibling package). */
+type SharedTaskRegistryLike = {
+  allTasks(): ReadonlyArray<{ status?: string; triggerOnCompletion?: boolean }>;
+};
+
+/** Symbol @pi-unipi/background-tasks publishes its live registry under. */
+const SHARED_REGISTRY_KEY = Symbol.for("unipi.background-tasks.shared-registry");
+
+/**
+ * True when a background task will wake the agent with its own follow-up turn.
+ * Reads the shared globalThis symbol directly rather than importing
+ * @pi-unipi/background-tasks, so notify has zero load-order or dependency
+ * coupling to that optional sibling. Any read failure means "no pending wake".
+ */
+export function hasPendingWakeTask(): boolean {
+  try {
+    const registry = (globalThis as Record<symbol, unknown>)[SHARED_REGISTRY_KEY] as
+      | SharedTaskRegistryLike
+      | undefined;
+    if (typeof registry?.allTasks !== "function") return false;
+    const tasks = registry.allTasks();
+    return Array.isArray(tasks)
+      ? tasks.some((task) => task.status === "running" && task.triggerOnCompletion === true)
+      : false;
+  } catch {
+    return false;
+  }
+}
+
+/** Default dispatch priority for an event type, when the event path sets one. */
+function defaultEventPriority(eventKey: string): NotifyPriority | undefined {
+  if (isBlockingEvent(eventKey)) return "high";
+  if (isAgentNotificationEvent(eventKey)) return "low";
+  return undefined;
+}
+
 /** Stored session context for modelRegistry access */
 let sessionCtx: ExtensionContext | null = null;
 
 /** Unsubscribe functions for pi.events.on() listeners. Cleared before each registration to avoid accumulation across reloads. */
 const unsubs: Array<() => void> = [];
 
+/** Pending re-notify interval for an unanswered blocking prompt. */
+let renotifyTimer: ReturnType<typeof setInterval> | undefined;
+
+/** Cancel any pending re-notify timer. Safe to call at any time. */
+export function disarmRenotify(): void {
+  const timer = renotifyTimer;
+  renotifyTimer = undefined;
+  if (timer === undefined) return;
+  try {
+    clearInterval(timer);
+  } catch {
+    // Timer already gone (e.g. after a reload) — nothing to clear.
+  }
+}
+
+/**
+ * (Re)arm the reminder loop for a blocking prompt. Only one prompt can be
+ * outstanding at a time, so arming replaces any existing timer rather than
+ * stacking a second one.
+ */
+function armRenotify(
+  pi: ExtensionAPI,
+  title: string,
+  message: string,
+  platforms: NotifyPlatform[],
+  eventType: string,
+  config: NotifyConfig,
+  cwd: string,
+  dispatch: DispatchNotification,
+): void {
+  disarmRenotify();
+  const { enabled, intervalMs, maxRepeats } = config.renotify;
+  if (!enabled || maxRepeats <= 0) return;
+
+  let fired = 0;
+  const timer = setInterval(() => {
+    fired += 1;
+    dispatch(
+      pi,
+      `${title} (still waiting)`,
+      message,
+      platforms,
+      eventType,
+      config,
+      cwd,
+      "high"
+    ).catch(() => {
+      // Silently ignore — background notification failure is non-blocking.
+    });
+    if (fired >= maxRepeats) disarmRenotify();
+  }, intervalMs);
+  // Never hold the process open for a reminder. (undefined-safe for mocked timers.)
+  timer.unref?.();
+  renotifyTimer = timer;
+}
+
 /** Unregister all previously registered pi.events.on() listeners. */
 function unregisterAll(): void {
+  disarmRenotify();
   for (const unsub of unsubs) {
     try { unsub(); } catch { /* ignore */ }
   }
@@ -83,7 +176,8 @@ const LIFECYCLE_EVENTS = new Set(["agent_end", "agent_settled", "session_shutdow
 export function registerEventListeners(
   pi: ExtensionAPI,
   config: NotifyConfig,
-  cwd: string
+  cwd: string,
+  dispatch: DispatchNotification = dispatchNotification
 ): void {
   // Remove all previously registered EventBus listeners to prevent accumulation
   // across reloads (EventBus persists but module instances are replaced).
@@ -99,11 +193,21 @@ 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, cwd).catch(
-        () => {
-          // Silently ignore — background notification failure is non-blocking.
-        }
-      );
+      dispatch(
+        pi,
+        title,
+        message,
+        eventConfig.platforms,
+        eventKey,
+        config,
+        cwd,
+        defaultEventPriority(eventKey)
+      ).catch(() => {
+        // Silently ignore — background notification failure is non-blocking.
+      });
+      if (isBlockingEvent(eventKey)) {
+        armRenotify(pi, title, message, eventConfig.platforms, eventKey, config, cwd, dispatch);
+      }
     };
 
     // Pi lifecycle events are dispatched via ExtensionRunner — must use
@@ -123,16 +227,26 @@ export function registerEventListeners(
     unsubs.push(pi.events.on(ASK_USER_PROMPT_EVENT, (payload: unknown) => {
       const title = `Pi — ${BUILTIN_EVENTS.ask_user_prompt.label}`;
       const message = buildAskUserPromptMessage(payload);
-      dispatchNotification(pi, title, message, askUserConfig.platforms, "ask_user_prompt", config, cwd).catch(
+      dispatch(pi, title, message, askUserConfig.platforms, "ask_user_prompt", config, cwd, "high").catch(
         () => {
           // Silently ignore — background notification failure is non-blocking.
         }
       );
+      armRenotify(pi, title, message, askUserConfig.platforms, "ask_user_prompt", config, cwd, dispatch);
     }));
   }
 
-  registerAgentNotification(pi, "agent_end", config, cwd);
-  registerAgentNotification(pi, "agent_settled", config, cwd);
+  // A reminder loop must never outlive the prompt it is nagging about: any of
+  // these signals means the human acted or the agent moved on.
+  unsubs.push(pi.events.on("herdr:blocked", (payload: unknown) => {
+    if ((payload as { active?: unknown } | null)?.active === false) disarmRenotify();
+  }));
+  (pi as any).on("agent_start", () => {
+    disarmRenotify();
+  });
+
+  registerAgentNotification(pi, "agent_end", config, cwd, dispatch);
+  registerAgentNotification(pi, "agent_settled", config, cwd, dispatch);
 }
 
 /** Get all platforms that are currently enabled in config */
@@ -150,6 +264,9 @@ export function unregisterEventListeners(): void {
   unregisterAll();
 }
 
+/** Dispatcher signature — injectable so tests can observe calls without sending. */
+export type DispatchNotification = typeof dispatchNotification;
+
 /**
  * Dispatch a notification to the configured platforms.
  * Sends to all specified platforms (or defaults) in parallel.
@@ -184,7 +301,7 @@ export async function dispatchNotification(
   });
 
   const { send: platformsToSend, silenced: inputSilenced } =
-    filterPlatformsAfterInput(enabledPlatforms, config);
+    filterPlatformsAfterInput(enabledPlatforms, config, Date.now(), eventType);
 
   const results = await Promise.all(
     platformsToSend.map(async (platform) => {
@@ -327,12 +444,18 @@ function registerAgentNotification(
   pi: ExtensionAPI,
   eventKey: "agent_end" | "agent_settled",
   config: NotifyConfig,
-  cwd: string
+  cwd: string,
+  dispatch: DispatchNotification = dispatchNotification
 ): void {
   const eventConfig = config.events[eventKey];
   if (!eventConfig?.enabled) return;
 
   const handler = (payload: unknown) => {
+    // A running background task with triggerOnCompletion wakes the agent in a
+    // fresh turn that produces its own agent_end/agent_settled. Notifying for
+    // this intermediate turn as well would duplicate the wake message.
+    if (hasPendingWakeTask()) return;
+
     // Fire-and-forget: build message and dispatch in background,
     // don't block agent lifecycle hooks from completing.
     const sessionName = pi.getSessionName?.();
@@ -361,7 +484,7 @@ function registerAgentNotification(
             })
             .catch(() => buildAgentLifecycleMessage(eventKey, sessionName))
             .then((message) =>
-              dispatchNotification(pi, title, message, eventConfig.platforms, eventKey, config, cwd)
+              dispatch(pi, title, message, eventConfig.platforms, eventKey, config, cwd, "low")
             )
             .catch(() => {
               // Silently ignore — background agent notification failure is non-blocking.
@@ -373,7 +496,7 @@ function registerAgentNotification(
 
     // No recap or recap unavailable: dispatch immediately in background.
     const message = buildAgentLifecycleMessage(eventKey, sessionName);
-    dispatchNotification(pi, title, message, eventConfig.platforms, eventKey, config, cwd).catch(
+    dispatch(pi, title, message, eventConfig.platforms, eventKey, config, cwd, "low").catch(
       () => {
         // Silently ignore — background agent notification failure is non-blocking.
       }

package/index.ts

@@ -23,6 +23,7 @@ import {
   unregisterEventListeners,
   setSessionContext,
   clearSessionContext,
+  disarmRenotify,
 } from "./events.js";
 import { noteInput, resetInputActivity } from "./activity.js";
 
@@ -49,6 +50,8 @@ export default function (pi: ExtensionAPI) {
       try {
         unsubTerminalInput = onTerminalInput(() => {
           noteInput();
+          // The user is at the keyboard — any outstanding prompt reminder is stale.
+          disarmRenotify();
         });
       } catch {
         unsubTerminalInput = undefined;
@@ -70,6 +73,7 @@ export default function (pi: ExtensionAPI) {
   pi.on("session_shutdown", async () => {
     unsubTerminalInput?.();
     unsubTerminalInput = undefined;
+    disarmRenotify();
     resetInputActivity();
     clearSessionContext();
     unregisterEventListeners();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/notify",
-  "version": "2.17.0",
+  "version": "2.19.0",
   "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.17.0",
+    "@pi-unipi/core": "2.19.0",
     "node-notifier": "^10.0.1"
   },
   "peerDependencies": {

package/settings.ts

@@ -9,7 +9,7 @@ import { dirname, join } from "path";
 import { homedir } from "os";
 import { NOTIFY_DIRS } from "@pi-unipi/core";
 import { mergeSilenceAfterInput } from "./activity.js";
-import type { NotifyConfig } from "./types.js";
+import type { NotifyConfig, RenotifyConfig } from "./types.js";
 
 /** Resolve config path (expands ~ to homedir) */
 function resolveConfigPath(): string {
@@ -52,6 +52,11 @@ export const DEFAULT_CONFIG: NotifyConfig = {
     windowMs: 10000,
     platforms: ["native"],
   },
+  renotify: {
+    enabled: true,
+    intervalMs: 120000,
+    maxRepeats: 3,
+  },
 };
 
 /** Load config from disk, returning defaults if missing or invalid */
@@ -132,5 +137,30 @@ function mergeWithDefaults(loaded: Partial<NotifyConfig>): NotifyConfig {
       loaded.silenceAfterInput,
       base.silenceAfterInput,
     ),
+    renotify: mergeRenotify(loaded.renotify, base.renotify),
+  };
+}
+
+/** Merge the renotify block, falling back per-field on invalid scalars. */
+function mergeRenotify(
+  loaded: Partial<RenotifyConfig> | undefined,
+  defaults: RenotifyConfig,
+): RenotifyConfig {
+  const intervalMs =
+    typeof loaded?.intervalMs === "number" &&
+    Number.isFinite(loaded.intervalMs) &&
+    loaded.intervalMs >= 10000
+      ? loaded.intervalMs
+      : defaults.intervalMs;
+  const maxRepeats =
+    typeof loaded?.maxRepeats === "number" &&
+    Number.isInteger(loaded.maxRepeats) &&
+    loaded.maxRepeats >= 0
+      ? loaded.maxRepeats
+      : defaults.maxRepeats;
+  return {
+    enabled: loaded?.enabled ?? defaults.enabled,
+    intervalMs,
+    maxRepeats,
   };
 }

package/skills/configure-notify/SKILL.md

@@ -67,6 +67,11 @@ Help users configure the `@pi-unipi/notify` notification system.
     "windowMs": 10000,
     "platforms": ["native"]
   },
+  "renotify": {
+    "enabled": true,
+    "intervalMs": 120000,
+    "maxRepeats": 3
+  },
   "NOTE": "ntfy section is legacy — migrated to ntfy.json on first run"
 }
 ```
@@ -95,6 +100,26 @@ Quiet listed platforms for `windowMs` after any terminal keypress. **Default: of
 
 TUI: `/unipi:notify-settings` → Platforms → Quiet after activity (Space), ←→ then Space for channels, +/− for the window (1s steps).
 
+### Re-notify unanswered prompts (default: enabled)
+
+When a blocking prompt (`ask_user_prompt`, `permission_request`) is not answered, notify re-sends the same notification every `intervalMs`, title suffixed `(still waiting)`, priority `high`, up to `maxRepeats` times.
+
+```json
+"renotify": {
+  "enabled": true,
+  "intervalMs": 120000,
+  "maxRepeats": 3
+}
+```
+
+- `enabled` — master switch (default: true)
+- `intervalMs` — delay between reminders in milliseconds, minimum 10000 (default: 120000 = 2 min)
+- `maxRepeats` — reminders after the first notification, 0 sends none (default: 3)
+
+Reminders stop as soon as the user presses a key, herdr reports `herdr:blocked` `active: false`, the agent starts a new turn, or the session ends. Arming a new prompt replaces any existing reminder (only one can be outstanding). Reminders bypass `silenceAfterInput` since blocking events are exempt.
+
+TUI: `/unipi:notify-settings` → Re-notify → Space toggles enabled, +/− adjusts interval (30s steps) and max repeats.
+
 ### Gotify (default: disabled)
 
 Self-hosted push notification server. Requires:
@@ -185,6 +210,8 @@ ntfy uses dedicated `ntfy.json` files at both global and project scope, with ful
 
 Each event can override `platforms` — empty array means use `defaultPlatforms`.
 
+`ask_user_prompt` and `permission_request` are **blocking** events: while one is unanswered the agent is parked, so notify re-sends it periodically (see the Re-notify unanswered prompts section under Platforms).
+
 ### `permission_request`
 
 Fires on the `permissions:ui_prompt` broadcast from
@@ -246,3 +273,5 @@ For general settings: suggest `/unipi:notify-settings`
 - Telegram: `botToken` and `chatId` required when enabled
 - ntfy: `serverUrl` and `topic` required when enabled
 - ntfy: `priority` must be 1-5
+- renotify: `intervalMs` must be a finite number >= 10000 (else the default 120000 is used)
+- renotify: `maxRepeats` must be an integer >= 0 (else the default 3 is used)

package/tui/settings-overlay.ts

@@ -18,7 +18,7 @@ import type { NotifyConfig, NotifyPlatform, NtfyConfig } from "../types.js";
 import { OverlayTheme, boxInnerWidth } from "@pi-unipi/core";
 
 /** Section types */
-type Section = "platforms" | "events" | "recap";
+type Section = "platforms" | "events" | "recap" | "renotify";
 
 const PLATFORM_KEYS: NotifyPlatform[] = ["native", "gotify", "telegram", "ntfy"];
 const CHIP_LABELS: Record<NotifyPlatform, string> = {
@@ -36,6 +36,22 @@ const WINDOW_STEP_MS = 1_000;
 const WINDOW_MIN_MS = 1_000;
 const WINDOW_MAX_MS = 120_000;
 
+const RENOTIFY_INTERVAL_INDEX = 1;
+const RENOTIFY_MAX_REPEATS_INDEX = 2;
+const RENOTIFY_INTERVAL_STEP_MS = 30_000;
+const RENOTIFY_INTERVAL_MIN_MS = 10_000;
+const RENOTIFY_INTERVAL_MAX_MS = 600_000;
+const RENOTIFY_MAX_REPEATS_MAX = 10;
+
+/** Format a re-notify interval as a compact duration label. */
+function formatRenotifyInterval(ms: number): string {
+  const seconds = Math.round(ms / 1000);
+  if (seconds < 60) return `${seconds}s`;
+  const minutes = Math.floor(seconds / 60);
+  const rest = seconds % 60;
+  return rest === 0 ? `${minutes}m` : `${minutes}m${rest}s`;
+}
+
 /**
  * Settings overlay component.
  */
@@ -108,12 +124,22 @@ export class NotifySettingsOverlay implements Component {
         return;
       }
     }
+    if (this.section === "renotify") {
+      if (data === "+" || data === "=") {
+        this.nudgeRenotify(1);
+        return;
+      }
+      if (data === "-" || data === "_") {
+        this.nudgeRenotify(-1);
+        return;
+      }
+    }
     if (matchesKey(data, "space")) {
       this.toggleCurrent();
       return;
     }
     if (matchesKey(data, "tab")) {
-      const sections: Section[] = ["platforms", "events", "recap"];
+      const sections: Section[] = ["platforms", "events", "recap", "renotify"];
       const idx = sections.indexOf(this.section);
       this.section = sections[(idx + 1) % sections.length];
       this.selectedIndex = 0;
@@ -139,6 +165,7 @@ export class NotifySettingsOverlay implements Component {
   private get maxItems(): number {
     if (this.section === "platforms") return 7; // 4 platforms + focused + silence master + chips
     if (this.section === "recap") return 1; // toggle
+    if (this.section === "renotify") return 3; // enable + interval + max repeats
     return Object.keys(this.config.events).length;
   }
 
@@ -150,6 +177,21 @@ export class NotifySettingsOverlay implements Component {
     );
   }
 
+  private nudgeRenotify(direction: number): void {
+    const { renotify } = this.config;
+    if (this.selectedIndex === RENOTIFY_INTERVAL_INDEX) {
+      renotify.intervalMs = Math.min(
+        RENOTIFY_INTERVAL_MAX_MS,
+        Math.max(RENOTIFY_INTERVAL_MIN_MS, renotify.intervalMs + direction * RENOTIFY_INTERVAL_STEP_MS),
+      );
+    } else if (this.selectedIndex === RENOTIFY_MAX_REPEATS_INDEX) {
+      renotify.maxRepeats = Math.min(
+        RENOTIFY_MAX_REPEATS_MAX,
+        Math.max(0, renotify.maxRepeats + direction),
+      );
+    }
+  }
+
   private chipOn(key: NotifyPlatform): boolean {
     const listed = this.config.silenceAfterInput.platforms;
     if (listed.length === 0) return true;
@@ -191,6 +233,10 @@ export class NotifySettingsOverlay implements Component {
       }
     } else if (this.section === "recap") {
       this.config.recap.enabled = !this.config.recap.enabled;
+    } else if (this.section === "renotify") {
+      if (this.selectedIndex === 0) {
+        this.config.renotify.enabled = !this.config.renotify.enabled;
+      }
     } else {
       const eventKeys = Object.keys(this.config.events);
       const key = eventKeys[this.selectedIndex];
@@ -238,13 +284,19 @@ export class NotifySettingsOverlay implements Component {
       this.section === "recap"
         ? this.overlay.fg("accent", this.overlay.bold("[Recap]"))
         : this.overlay.fg("dim", "Recap");
-    lines.push(this.overlay.frameLine(`  ${platformTab}  ${eventsTab}  ${recapTab}`, innerWidth));
+    const renotifyTab =
+      this.section === "renotify"
+        ? this.overlay.fg("accent", this.overlay.bold("[Re-notify]"))
+        : this.overlay.fg("dim", "Re-notify");
+    lines.push(this.overlay.frameLine(`  ${platformTab}  ${eventsTab}  ${recapTab}  ${renotifyTab}`, innerWidth));
     lines.push(this.overlay.ruleLine(innerWidth));
 
     if (this.section === "platforms") {
       this.renderPlatforms(lines, innerWidth);
     } else if (this.section === "recap") {
       this.renderRecap(lines, innerWidth);
+    } else if (this.section === "renotify") {
+      this.renderRenotify(lines, innerWidth);
     } else {
       this.renderEvents(lines, innerWidth);
     }
@@ -271,6 +323,9 @@ export class NotifySettingsOverlay implements Component {
     if (this.section === "recap") {
       return "↑↓ navigate · Space toggle · M change model · Tab switch · Enter save · Esc cancel";
     }
+    if (this.section === "renotify") {
+      return "↑↓ navigate · Space toggle · +/− adjust · Tab switch · Enter save · Esc cancel";
+    }
     if (this.section === "platforms" && this.selectedIndex === SILENCE_MASTER_INDEX) {
       return "↑↓ navigate · Space toggle · +/− window · Tab switch · Enter save · Esc cancel";
     }
@@ -449,4 +504,50 @@ export class NotifySettingsOverlay implements Component {
       )
     );
   }
+
+  private renderRenotify(lines: string[], innerWidth: number): void {
+    const toggleOn = this.overlay.fg("success", "●");
+    const toggleOff = this.overlay.fg("dim", "○");
+    const rows: Array<{ label: string; detail: string; toggle?: boolean }> = [
+      {
+        label: "Enable Re-notify",
+        detail: "Remind while a question or permission prompt is unanswered",
+        toggle: this.config.renotify.enabled,
+      },
+      {
+        label: "Interval",
+        detail: formatRenotifyInterval(this.config.renotify.intervalMs),
+      },
+      {
+        label: "Max repeats",
+        detail: `${this.config.renotify.maxRepeats}`,
+      },
+    ];
+
+    for (let i = 0; i < rows.length; i++) {
+      const row = rows[i];
+      if (!row) continue;
+      const isSelected = i === this.selectedIndex;
+      const toggle = row.toggle === undefined ? " " : row.toggle ? toggleOn : toggleOff;
+      const label = isSelected
+        ? this.overlay.bold(row.label)
+        : this.overlay.fg("dim", row.label);
+      const detail =
+        this.config.renotify.enabled || i === 0
+          ? this.overlay.fg("dim", row.detail)
+          : this.overlay.fg("dim", "—");
+      lines.push(
+        this.overlay.frameLine(
+          `${isSelected ? this.overlay.fg("accent", "▸") : " "} ${toggle} ${label}  ${detail}`,
+          innerWidth,
+        ),
+      );
+    }
+    lines.push(
+      this.overlay.frameLine(
+        this.overlay.fg("dim", "  Blocking prompts only (ask_user, permission_request)"),
+        innerWidth,
+      ),
+    );
+  }
 }

package/types.ts

@@ -90,6 +90,16 @@ export interface SilenceAfterInputConfig {
   platforms: NotifyPlatform[];
 }
 
+/** Re-send an unanswered human-blocking prompt until someone acts */
+export interface RenotifyConfig {
+  /** Master switch */
+  enabled: boolean;
+  /** Delay between reminders, in milliseconds */
+  intervalMs: number;
+  /** Reminders to send after the first notification (0 = none) */
+  maxRepeats: number;
+}
+
 /** Full notification configuration */
 export interface NotifyConfig {
   /** Global default platforms for all events */
@@ -106,6 +116,8 @@ export interface NotifyConfig {
   recap: RecapConfig;
   /** Suppress listed platforms after recent terminal input */
   silenceAfterInput: SilenceAfterInputConfig;
+  /** Re-notify unanswered human-blocking prompts */
+  renotify: RenotifyConfig;
 }
 
 /** Parameters for the notify_user agent tool */