@pi-unipi/notify 2.15.0 → 2.16.1

package/README.md

@@ -61,6 +61,22 @@ Desktop notifications via [node-notifier](https://github.com/mikaelbr/node-notif
 
 Zero configuration — works out of the box. Set `native.suppressWhenFocused` to `true` to skip native notifications when the active/focused window is already Pi.
 
+### Silence after input
+
+After a terminal keypress, listed platforms stay quiet for `windowMs`. Default: **off**, native only, 10s. Edit in `/unipi:notify-settings` → Platforms (Quiet after activity + channel chips), or in `~/.unipi/config/notify/config.json`:
+
+```json
+{
+  "silenceAfterInput": {
+    "enabled": true,
+    "windowMs": 10000,
+    "platforms": ["native"]
+  }
+}
+```
+
+Add `gotify`, `telegram`, or `ntfy` to `platforms` to silence those channels too. Empty `platforms` silences all enabled platforms (same as `events.*.platforms`).
+
 ### Gotify
 
 Self-hosted push notification server:
@@ -104,6 +120,22 @@ Settings stored at `~/.unipi/config/notify/config.json`. Edit via `/unipi:notify
 
 Per-event platform routing lets you control where each event type goes. The settings overlay shows all events with platform toggles.
 
+### Recap (thinking models)
+
+Recap summarizes the last assistant message into a one-line push notification (100-token budget). Thinking models served by llama.cpp or vLLM can spend that entire budget on reasoning and return nothing, falling back to a plain 100-character truncation. If your recap endpoint supports chat-template kwargs, set `recap.disableThinking` to skip reasoning tokens:
+
+```json
+{
+  "recap": {
+    "enabled": true,
+    "model": "localhost/gemma-4-e4b",
+    "disableThinking": true
+  }
+}
+```
+
+This sends `chat_template_kwargs: { enable_thinking: false, preserve_thinking: false }` with the request. Keep it `false` (the default) for strict OpenAI-compatible endpoints — they reject unknown params. Anthropic models are unaffected (thinking is opt-in there).
+
 ## License
 
 MIT

package/activity.ts

@@ -0,0 +1,100 @@
+/**
+ * @pi-unipi/notify — Recent terminal-input activity
+ *
+ * Tracks the last interactive keypress so dispatch can silence selected
+ * platforms while the user is at the keyboard.
+ */
+
+import type {
+  NotifyConfig,
+  NotifyPlatform,
+  SilenceAfterInputConfig,
+} from "./types.js";
+
+/** Known platform names — unknown strings are dropped when merging config. */
+const VALID_PLATFORMS: ReadonlySet<NotifyPlatform> = new Set([
+  "native",
+  "gotify",
+  "telegram",
+  "ntfy",
+]);
+
+let lastInputAt = 0;
+
+/** Record a terminal keypress. `at` is injectable for tests. */
+export function noteInput(at: number = Date.now()): void {
+  lastInputAt = at;
+}
+
+/** Clear activity (session start/shutdown). */
+export function resetInputActivity(): void {
+  lastInputAt = 0;
+}
+
+/**
+ * Split already-enabled platforms into "send" vs "silenced by recent input".
+ * Does not look at platform `enabled` flags — caller filters those first.
+ * Empty `platforms` (while enabled) silences all incoming channels, matching
+ * `events.*.platforms: []` → all enabled.
+ */
+export function filterPlatformsAfterInput(
+  platforms: NotifyPlatform[],
+  config: Pick<NotifyConfig, "silenceAfterInput">,
+  now: number = Date.now(),
+): { send: NotifyPlatform[]; silenced: NotifyPlatform[] } {
+  const cfg = config.silenceAfterInput;
+  if (!shouldSilence(cfg, now)) {
+    return { send: platforms.slice(), silenced: [] };
+  }
+  if (cfg.platforms.length === 0) {
+    return { send: [], silenced: platforms.slice() };
+  }
+  const silent = new Set(cfg.platforms);
+  const send: NotifyPlatform[] = [];
+  const silenced: NotifyPlatform[] = [];
+  for (const platform of platforms) {
+    if (silent.has(platform)) silenced.push(platform);
+    else send.push(platform);
+  }
+  return { send, silenced };
+}
+
+/** Normalize a partial config blob against defaults. */
+export function mergeSilenceAfterInput(
+  loaded: Partial<SilenceAfterInputConfig> | undefined,
+  defaults: SilenceAfterInputConfig,
+): SilenceAfterInputConfig {
+  if (!loaded) {
+    return {
+      enabled: defaults.enabled,
+      windowMs: defaults.windowMs,
+      platforms: defaults.platforms.slice(),
+    };
+  }
+  const platforms = Array.isArray(loaded.platforms)
+    ? loaded.platforms.filter((p): p is NotifyPlatform =>
+        VALID_PLATFORMS.has(p as NotifyPlatform),
+      )
+    : defaults.platforms.slice();
+  const windowMs =
+    typeof loaded.windowMs === "number" &&
+    Number.isFinite(loaded.windowMs) &&
+    loaded.windowMs >= 0
+      ? loaded.windowMs
+      : defaults.windowMs;
+  return {
+    enabled: loaded.enabled ?? defaults.enabled,
+    windowMs,
+    platforms,
+  };
+}
+
+function shouldSilence(
+  cfg: SilenceAfterInputConfig | undefined,
+  now: number,
+): cfg is SilenceAfterInputConfig {
+  if (!cfg?.enabled) return false;
+  if (lastInputAt <= 0) return false;
+  if (now - lastInputAt >= cfg.windowMs) return false;
+  return true;
+}

package/events.ts

@@ -16,6 +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";
 
 // Event emitted by @juicesharp/rpiv-ask-user-question before showing its UI.
 // Keep this as a local string until that package publishes an importable
@@ -182,8 +183,11 @@ export async function dispatchNotification(
     return false;
   });
 
+  const { send: platformsToSend, silenced: inputSilenced } =
+    filterPlatformsAfterInput(enabledPlatforms, config);
+
   const results = await Promise.all(
-    enabledPlatforms.map(async (platform) => {
+    platformsToSend.map(async (platform) => {
       try {
         const effectivePriority = await sendToPlatform(platform, title, message, config, cwd, priority);
         return { platform, success: true, ...(effectivePriority === undefined ? {} : { priority: effectivePriority }) };
@@ -202,6 +206,10 @@ export async function dispatchNotification(
     })
   );
 
+  for (const platform of inputSilenced) {
+    results.push({ platform, success: true, suppressed: true });
+  }
+
   const unsuppressed = results.filter((r) => !r.suppressed);
   const allSuccess = results.length > 0 && unsuppressed.every((r) => r.success);
   const suppressedPlatforms = results
@@ -344,7 +352,9 @@ function registerAgentNotification(
             .then((apiKeyResult) => {
               const apiKey = apiKeyResult.ok ? (apiKeyResult as { apiKey?: string }).apiKey : undefined;
               if (apiKey) {
-                return summarizeLastMessage(lastText, apiKey, model.baseUrl, model.api, modelId)
+                return summarizeLastMessage(lastText, apiKey, model.baseUrl, model.api, modelId, {
+                  disableThinking: config.recap.disableThinking,
+                })
                   .then((recap) => sessionName ? `${sessionName}: ${recap}` : recap);
               }
               return buildAgentLifecycleMessage(eventKey, sessionName);

package/index.ts

@@ -24,10 +24,14 @@ import {
   setSessionContext,
   clearSessionContext,
 } from "./events.js";
+import { noteInput, resetInputActivity } from "./activity.js";
 
 /** Package version */
 const VERSION = getPackageVersion(dirname(fileURLToPath(import.meta.url)));
 
+/** Unsubscribe for the interactive-mode keypress listener. */
+let unsubTerminalInput: (() => void) | undefined;
+
 export default function (pi: ExtensionAPI) {
 
   // Register tools and commands
@@ -37,6 +41,19 @@ export default function (pi: ExtensionAPI) {
   // Session lifecycle — register events and announce module
   pi.on("session_start", async (_event, ctx) => {
     setSessionContext(ctx);
+    resetInputActivity();
+    unsubTerminalInput?.();
+    unsubTerminalInput = undefined;
+    const onTerminalInput = ctx.ui?.onTerminalInput;
+    if (typeof onTerminalInput === "function") {
+      try {
+        unsubTerminalInput = onTerminalInput(() => {
+          noteInput();
+        });
+      } catch {
+        unsubTerminalInput = undefined;
+      }
+    }
     const cwd = process.cwd();
     const config = loadConfig();
     registerEventListeners(pi, config, cwd);
@@ -51,6 +68,9 @@ export default function (pi: ExtensionAPI) {
 
   // Cleanup on session shutdown
   pi.on("session_shutdown", async () => {
+    unsubTerminalInput?.();
+    unsubTerminalInput = undefined;
+    resetInputActivity();
     clearSessionContext();
     unregisterEventListeners();
   });

package/package.json

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

package/settings.ts

@@ -8,6 +8,7 @@ import { readFileSync, writeFileSync, mkdirSync, existsSync } from "fs";
 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";
 
 /** Resolve config path (expands ~ to homedir) */
@@ -44,6 +45,12 @@ export const DEFAULT_CONFIG: NotifyConfig = {
   recap: {
     enabled: false,
     model: "openrouter/openai/gpt-oss-20b",
+    disableThinking: false,
+  },
+  silenceAfterInput: {
+    enabled: false,
+    windowMs: 10000,
+    platforms: ["native"],
   },
 };
 
@@ -60,7 +67,10 @@ export function loadConfig(): NotifyConfig {
   } catch (_err) {
     // Config load failure — using defaults silently.
   }
-  return { ...DEFAULT_CONFIG };
+  // Deep copy: callers (e.g. the settings overlay) mutate the returned config.
+  // A shallow copy would share nested objects with DEFAULT_CONFIG and leak
+  // mutations into later loadConfig() calls (even after Esc/cancel).
+  return structuredClone(DEFAULT_CONFIG);
 }
 
 /** Save config to disk, creating directory if needed */
@@ -110,12 +120,17 @@ export function validateConfig(config: NotifyConfig): string[] {
 
 /** Merge loaded config with defaults to ensure all fields exist */
 function mergeWithDefaults(loaded: Partial<NotifyConfig>): NotifyConfig {
+  const base = structuredClone(DEFAULT_CONFIG);
   return {
-    defaultPlatforms: loaded.defaultPlatforms ?? DEFAULT_CONFIG.defaultPlatforms,
-    events: { ...DEFAULT_CONFIG.events, ...loaded.events },
-    native: { ...DEFAULT_CONFIG.native, ...loaded.native },
-    gotify: { ...DEFAULT_CONFIG.gotify, ...loaded.gotify },
-    telegram: { ...DEFAULT_CONFIG.telegram, ...loaded.telegram },
-    recap: { ...DEFAULT_CONFIG.recap, ...loaded.recap },
+    defaultPlatforms: loaded.defaultPlatforms ?? base.defaultPlatforms,
+    events: { ...base.events, ...loaded.events },
+    native: { ...base.native, ...loaded.native },
+    gotify: { ...base.gotify, ...loaded.gotify },
+    telegram: { ...base.telegram, ...loaded.telegram },
+    recap: { ...base.recap, ...loaded.recap },
+    silenceAfterInput: mergeSilenceAfterInput(
+      loaded.silenceAfterInput,
+      base.silenceAfterInput,
+    ),
   };
 }

package/skills/configure-notify/SKILL.md

@@ -62,6 +62,11 @@ Help users configure the `@pi-unipi/notify` notification system.
     "token": null,
     "priority": 3
   },
+  "silenceAfterInput": {
+    "enabled": false,
+    "windowMs": 10000,
+    "platforms": ["native"]
+  },
   "NOTE": "ntfy section is legacy — migrated to ntfy.json on first run"
 }
 ```
@@ -72,6 +77,24 @@ Help users configure the `@pi-unipi/notify` notification system.
 
 Desktop notifications via node-notifier. Works out of the box on Windows, macOS, Linux.
 
+### Silence after input
+
+Quiet listed platforms for `windowMs` after any terminal keypress. **Default: off.** Same `config.json` as other notify settings.
+
+```json
+"silenceAfterInput": {
+  "enabled": true,
+  "windowMs": 10000,
+  "platforms": ["native"]
+}
+```
+
+- `enabled` — master switch
+- `windowMs` — quiet window in milliseconds (default: 10000)
+- `platforms` — channels to silence (`native`, `gotify`, `telegram`, `ntfy`). Empty list silences all enabled platforms (same as `events.*.platforms`).
+
+TUI: `/unipi:notify-settings` → Platforms → Quiet after activity (Space), ←→ then Space for channels, +/− for the window (1s steps).
+
 ### Gotify (default: disabled)
 
 Self-hosted push notification server. Requires:

package/summarize.ts

@@ -12,6 +12,17 @@ const MAX_TOKENS = 100;
 const TIMEOUT_MS = 10_000;
 const FALLBACK_TRUNCATE_CHARS = 100;
 
+/** Options for summarizeLastMessage */
+export interface SummarizeOptions {
+  /**
+   * Send `chat_template_kwargs: { enable_thinking: false, preserve_thinking: false }`
+   * on OpenAI-compatible requests (llama.cpp / vLLM chat templates) so thinking
+   * models don't burn the token budget on reasoning (issue #36). Anthropic
+   * ignores this — thinking is opt-in there already.
+   */
+  disableThinking?: boolean;
+}
+
 /**
  * Summarize a message using an LLM.
  *
@@ -20,6 +31,7 @@ const FALLBACK_TRUNCATE_CHARS = 100;
  * @param baseUrl - Provider base URL (from Model.baseUrl)
  * @param api - API type (from Model.api, e.g. "openai-completions")
  * @param modelId - Model ID to use
+ * @param opts - Optional summarization options
  * @returns Summarized text, or truncated original on failure
  */
 export async function summarizeLastMessage(
@@ -28,6 +40,7 @@ export async function summarizeLastMessage(
   baseUrl: string,
   api: string,
   modelId: string,
+  opts?: SummarizeOptions,
 ): Promise<string> {
   // Truncate input if too long
   const input =
@@ -41,7 +54,7 @@ export async function summarizeLastMessage(
       return await callAnthropic(baseUrl, apiKey, modelId, input);
     }
     // Default: OpenAI-compatible (covers openai-completions, openai-responses, etc.)
-    return await callOpenAICompatible(baseUrl, apiKey, modelId, input);
+    return await callOpenAICompatible(baseUrl, apiKey, modelId, input, opts);
   } catch {
     return fallbackSummary(messageText);
   }
@@ -53,6 +66,7 @@ async function callOpenAICompatible(
   apiKey: string,
   modelId: string,
   input: string,
+  opts?: SummarizeOptions,
 ): Promise<string> {
   const url = `${baseUrl.replace(/\/$/, "")}/chat/completions`;
   const controller = new AbortController();
@@ -68,6 +82,14 @@ async function callOpenAICompatible(
       body: JSON.stringify({
         model: modelId,
         max_tokens: MAX_TOKENS,
+        ...(opts?.disableThinking
+          ? {
+              chat_template_kwargs: {
+                enable_thinking: false,
+                preserve_thinking: false,
+              },
+            }
+          : {}),
         messages: [
           { role: "system", content: SYSTEM_PROMPT },
           { role: "user", content: input },

package/tui/settings-overlay.ts

@@ -14,12 +14,28 @@ import {
   validateConfig,
 } from "../settings.js";
 import { loadNtfyConfig, saveNtfyConfig, getNtfyConfigScope } from "../ntfy-config.js";
-import type { NotifyConfig, NtfyConfig } from "../types.js";
+import type { NotifyConfig, NotifyPlatform, NtfyConfig } from "../types.js";
 import { OverlayTheme, boxInnerWidth } from "@pi-unipi/core";
 
 /** Section types */
 type Section = "platforms" | "events" | "recap";
 
+const PLATFORM_KEYS: NotifyPlatform[] = ["native", "gotify", "telegram", "ntfy"];
+const CHIP_LABELS: Record<NotifyPlatform, string> = {
+  native: "Native",
+  gotify: "Gotify",
+  telegram: "Telegram",
+  ntfy: "ntfy",
+};
+
+const SUPPRESS_FOCUSED_INDEX = 4;
+const SILENCE_MASTER_INDEX = 5;
+const SILENCE_CHIPS_INDEX = 6;
+
+const WINDOW_STEP_MS = 1_000;
+const WINDOW_MIN_MS = 1_000;
+const WINDOW_MAX_MS = 120_000;
+
 /**
  * Settings overlay component.
  */
@@ -29,6 +45,8 @@ export class NotifySettingsOverlay implements Component {
   private ntfyScope: "project" | "global" | "none";
   private section: Section = "platforms";
   private selectedIndex = 0;
+  /** Which silence-after-input chip is focused (0–3). */
+  private chipIndex = 0;
   private error: string | null = null;
   private saved = false;
   onClose?: () => void;
@@ -70,6 +88,26 @@ export class NotifySettingsOverlay implements Component {
       this.selectedIndex = Math.min(this.maxItems - 1, this.selectedIndex + 1);
       return;
     }
+    if (this.section === "platforms" && this.selectedIndex === SILENCE_CHIPS_INDEX) {
+      if (matchesKey(data, "left") || data === "h") {
+        this.chipIndex = Math.max(0, this.chipIndex - 1);
+        return;
+      }
+      if (matchesKey(data, "right") || data === "l") {
+        this.chipIndex = Math.min(PLATFORM_KEYS.length - 1, this.chipIndex + 1);
+        return;
+      }
+    }
+    if (this.section === "platforms" && this.selectedIndex === SILENCE_MASTER_INDEX) {
+      if (data === "+" || data === "=") {
+        this.nudgeWindow(WINDOW_STEP_MS);
+        return;
+      }
+      if (data === "-" || data === "_") {
+        this.nudgeWindow(-WINDOW_STEP_MS);
+        return;
+      }
+    }
     if (matchesKey(data, "space")) {
       this.toggleCurrent();
       return;
@@ -99,30 +137,57 @@ export class NotifySettingsOverlay implements Component {
   }
 
   private get maxItems(): number {
-    if (this.section === "platforms") return 5; // native, gotify, telegram, ntfy + suppress option
+    if (this.section === "platforms") return 7; // 4 platforms + focused + silence master + chips
     if (this.section === "recap") return 1; // toggle
     return Object.keys(this.config.events).length;
   }
 
+  private nudgeWindow(delta: number): void {
+    const current = this.config.silenceAfterInput.windowMs;
+    this.config.silenceAfterInput.windowMs = Math.min(
+      WINDOW_MAX_MS,
+      Math.max(WINDOW_MIN_MS, current + delta),
+    );
+  }
+
+  private chipOn(key: NotifyPlatform): boolean {
+    const listed = this.config.silenceAfterInput.platforms;
+    if (listed.length === 0) return true;
+    return listed.includes(key);
+  }
+
+  private toggleSilenceChip(key: NotifyPlatform): void {
+    const listed = this.config.silenceAfterInput.platforms;
+    const effective = listed.length === 0 ? PLATFORM_KEYS.slice() : listed.slice();
+    const idx = effective.indexOf(key);
+    if (idx >= 0) {
+      if (effective.length === 1) return;
+      effective.splice(idx, 1);
+    } else {
+      effective.push(key);
+    }
+    const ordered = PLATFORM_KEYS.filter((p) => effective.includes(p));
+    this.config.silenceAfterInput.platforms =
+      ordered.length === PLATFORM_KEYS.length ? [] : ordered;
+  }
+
   private toggleCurrent(): void {
     if (this.section === "platforms") {
-      const platforms: Array<"native" | "gotify" | "telegram" | "ntfy"> = [
-        "native",
-        "gotify",
-        "telegram",
-        "ntfy",
-      ];
-      if (this.selectedIndex < platforms.length) {
-        const key = platforms[this.selectedIndex];
+      if (this.selectedIndex < PLATFORM_KEYS.length) {
+        const key = PLATFORM_KEYS[this.selectedIndex];
         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 {
-        // suppressWhenFocused toggle (index 4)
+      } else if (this.selectedIndex === SUPPRESS_FOCUSED_INDEX) {
         this.config.native.suppressWhenFocused = !this.config.native.suppressWhenFocused;
+      } else if (this.selectedIndex === SILENCE_MASTER_INDEX) {
+        this.config.silenceAfterInput.enabled = !this.config.silenceAfterInput.enabled;
+      } else if (this.selectedIndex === SILENCE_CHIPS_INDEX) {
+        const key = PLATFORM_KEYS[this.chipIndex];
+        if (key) this.toggleSilenceChip(key);
       }
     } else if (this.section === "recap") {
       this.config.recap.enabled = !this.config.recap.enabled;
@@ -196,18 +261,35 @@ export class NotifySettingsOverlay implements Component {
 
     // Footer
     lines.push(this.overlay.ruleLine(innerWidth));
-    const footerHint = this.section === "recap"
-      ? "↑↓ navigate · Space toggle · M change model · Tab switch · Enter save · Esc cancel"
-      : "↑↓ navigate · Space toggle · Tab switch · Enter save · Esc cancel";
-    lines.push(this.overlay.frameLine(this.overlay.fg("dim", footerHint), innerWidth));
+    lines.push(this.overlay.frameLine(this.overlay.fg("dim", this.footerHint()), innerWidth));
     lines.push(this.overlay.borderLine(innerWidth, "bottom"));
 
     return lines;
   }
 
+  private footerHint(): string {
+    if (this.section === "recap") {
+      return "↑↓ navigate · Space toggle · M change model · 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";
+    }
+    if (this.section === "platforms" && this.selectedIndex === SILENCE_CHIPS_INDEX) {
+      return "↑↓ navigate · ←→ channel · Space toggle · Tab switch · Enter save · Esc cancel";
+    }
+    return "↑↓ navigate · Space toggle · Tab switch · Enter save · Esc cancel";
+  }
+
+  private silenceSummary(): string {
+    const seconds = Math.round(this.config.silenceAfterInput.windowMs / 1000);
+    const listed = this.config.silenceAfterInput.platforms;
+    const scope = listed.length === 0 ? "all enabled" : listed.join(", ");
+    return `${seconds}s · ${scope}`;
+  }
+
   private renderPlatforms(lines: string[], innerWidth: number): void {
     const platforms: Array<{
-      key: "native" | "gotify" | "telegram" | "ntfy";
+      key: NotifyPlatform;
       label: string;
       detail: string;
     }> = [
@@ -259,8 +341,7 @@ export class NotifySettingsOverlay implements Component {
 
     // suppressWhenFocused toggle (index 4)
     {
-      const i = platforms.length;
-      const isSelected = i === this.selectedIndex;
+      const isSelected = this.selectedIndex === SUPPRESS_FOCUSED_INDEX;
       const isEnabled = this.config.native.suppressWhenFocused === true;
       const toggleOn = this.overlay.fg("success", "●");
       const toggleOff = this.overlay.fg("dim", "○");
@@ -277,6 +358,47 @@ export class NotifySettingsOverlay implements Component {
         )
       );
     }
+
+    this.renderSilenceAfterInput(lines, innerWidth);
+  }
+
+  private renderSilenceAfterInput(lines: string[], innerWidth: number): void {
+    const masterOn = this.config.silenceAfterInput.enabled;
+    const masterSelected = this.selectedIndex === SILENCE_MASTER_INDEX;
+    const toggle = masterOn
+      ? this.overlay.fg("success", "●")
+      : this.overlay.fg("dim", "○");
+    const label = masterSelected
+      ? this.overlay.bold("Quiet after activity")
+      : this.overlay.fg("dim", "Quiet after activity");
+    const detail = this.overlay.fg("dim", this.silenceSummary());
+    lines.push(
+      this.overlay.frameLine(
+        `${masterSelected ? this.overlay.fg("accent", "▸") : " "} ${toggle} ${label}  ${detail}`,
+        innerWidth,
+      ),
+    );
+
+    const chipsSelected = this.selectedIndex === SILENCE_CHIPS_INDEX;
+    const chips = PLATFORM_KEYS.map((key, i) => {
+      const on = this.chipOn(key);
+      const mark = on ? "●" : "○";
+      const text = `${mark} ${CHIP_LABELS[key]}`;
+      const focused = chipsSelected && i === this.chipIndex;
+      if (focused) {
+        return this.overlay.fg("accent", this.overlay.bold(`[${text}]`));
+      }
+      const painted = on
+        ? `${this.overlay.fg("success", mark)} ${CHIP_LABELS[key]}`
+        : this.overlay.fg("dim", text);
+      return masterOn ? painted : this.overlay.fg("dim", text);
+    });
+    lines.push(
+      this.overlay.frameLine(
+        `${chipsSelected ? this.overlay.fg("accent", "▸") : " "}   ${chips.join("  ")}`,
+        innerWidth,
+      ),
+    );
   }
 
   private renderEvents(lines: string[], innerWidth: number): void {

package/types.ts

@@ -69,6 +69,25 @@ export interface RecapConfig {
   enabled: boolean;
   /** Model to use for recap (e.g. "openrouter/openai/gpt-oss-20b") */
   model: string;
+  /**
+   * Send `chat_template_kwargs: { enable_thinking: false, preserve_thinking: false }`
+   * with recap requests so llama.cpp/vLLM-style servers skip reasoning tokens.
+   * Without this, a thinking model can burn the entire 100-token budget on
+   * reasoning and return no summary (issue #36). Only enable for endpoints
+   * that accept these params — strict OpenAI-compatible servers reject them.
+   * The Anthropic path ignores this (thinking is opt-in there already).
+   */
+  disableThinking?: boolean;
+}
+
+/** Quiet listed platforms after recent terminal input */
+export interface SilenceAfterInputConfig {
+  /** Master switch */
+  enabled: boolean;
+  /** Quiet window after the last keypress, in milliseconds */
+  windowMs: number;
+  /** Platforms to suppress (empty = all enabled platforms) */
+  platforms: NotifyPlatform[];
 }
 
 /** Full notification configuration */
@@ -85,6 +104,8 @@ export interface NotifyConfig {
   telegram: TelegramConfig;
   /** Recap summarization settings */
   recap: RecapConfig;
+  /** Suppress listed platforms after recent terminal input */
+  silenceAfterInput: SilenceAfterInputConfig;
 }
 
 /** Parameters for the notify_user agent tool */