@pi-unipi/unipi 2.18.0 → 2.19.0

package/packages/fusion/src/tools.ts

@@ -60,7 +60,7 @@ async function waitForReport(
   ctx: ExtensionContext,
   onUpdate?: (update: unknown) => void,
   timeoutMs = 2700000,
-): Promise<{ report?: HandoffReport; interrupted?: string; aborted?: boolean }> {
+): Promise<{ report?: HandoffReport; interrupted?: string; aborted?: boolean; error?: string }> {
   const started = Date.now();
   let lastProgressKey = "";
   while (true) {
@@ -72,8 +72,14 @@ async function waitForReport(
     const remaining = timeoutMs - (Date.now() - started);
     if (remaining <= 0) return {};
     const timer = new Promise<undefined>((resolve) => setTimeout(() => resolve(undefined), Math.min(500, remaining)));
-    const report = await Promise.race([done, timer]);
-    if (report !== undefined) return { report };
+    const outcome = await Promise.race([
+      done.then((report) => ({ report }), (error) => ({ error: error instanceof Error ? error.message : String(error) })),
+      timer,
+    ]);
+    if (outcome !== undefined) {
+      if ("error" in outcome) return { error: outcome.error };
+      return { report: outcome.report };
+    }
     const progress = progressText(runtime, id);
     const key = progressKey(runtime, id);
     if (key !== lastProgressKey) {
@@ -175,6 +181,7 @@ export function registerFusionTools(pi: ExtensionAPI, deps: FusionToolDeps): voi
         deps.onReport?.(ctx, waited.report);
         return result(reportText(waited.report), waited.report, waited.report.status !== "completed");
       }
+      if (waited.error) return result(`Handoff ${handoff.id} failed: ${waited.error}`, undefined, true);
       if (waited.aborted) return result(`${progressText(runtime, handoff.id)}\nHandoff ${handoff.id} aborted.`, undefined, true);
       if (waited.interrupted) return result(`A user message arrived while the sidekick (agent_id ${handoff.id}) was working. The handoff continues in the background. Act on the user's message first, then call read_subagent({agent_id:"${handoff.id}", block:true}) to collect the report or sidekick({message}) to redirect it.\n${waited.interrupted}`);
       return result(`Handoff ${handoff.id} is still running.\n${progressText(runtime, handoff.id)}`);
@@ -205,6 +212,7 @@ export function registerFusionTools(pi: ExtensionAPI, deps: FusionToolDeps): voi
         deps.onReport?.(ctx, waited.report);
         return result(reportText(waited.report), waited.report, waited.report.status !== "completed");
       }
+      if (waited.error) return result(`Handoff ${id} failed: ${waited.error}`, undefined, true);
       if (waited.aborted) return result(`Handoff ${id} aborted.`, undefined, true);
       if (waited.interrupted) return result(`A user message arrived while the sidekick (agent_id ${id}) was working.\n${waited.interrupted}`);
       return result(`Handoff ${id} is still running.\n${progressText(runtime, id)}`);

package/packages/image/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/image",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "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.18.0"
+    "@pi-unipi/core": "2.19.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-ai": "^0.84.0",

package/packages/info-screen/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/info-screen",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "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.18.0"
+    "@pi-unipi/core": "2.19.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/input-shortcuts/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/input-shortcuts",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "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.18.0"
+    "@pi-unipi/core": "2.19.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/kanboard/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/kanboard",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "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.18.0"
+    "@pi-unipi/core": "2.19.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/mcp/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/mcp",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "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.18.0"
+    "@pi-unipi/core": "2.19.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/memory/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/memory",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "description": "Persistent cross-session memory with MemPalace backend (auto-installed) and SQLite fallback for Pi coding agent",
   "type": "module",
   "main": "index.ts",
@@ -39,8 +39,8 @@
     "README.md"
   ],
   "dependencies": {
-    "@pi-unipi/core": "2.18.0",
-    "@pi-unipi/info-screen": "2.18.0",
+    "@pi-unipi/core": "2.19.0",
+    "@pi-unipi/info-screen": "2.19.0",
     "js-yaml": "^4.1.0"
   },
   "peerDependencies": {

package/packages/milestone/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pi-unipi/milestone",
-  "version": "2.18.0",
+  "version": "2.19.0",
   "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.18.0"
+    "@pi-unipi/core": "2.19.0"
   },
   "peerDependencies": {
     "@earendil-works/pi-coding-agent": "^0.84.0",

package/packages/notify/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/packages/notify/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/packages/notify/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/packages/notify/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/packages/notify/package.json

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

package/packages/notify/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/packages/notify/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)