omni-notify-mcp 1.3.7 → 1.3.11

package/README.md

@@ -6,9 +6,9 @@
 
 <p align="center">
   <em>Reach me on any channel. Ask me anything. Get out of my way when I'm busy.</em><br>
-  An MCP server that gives AI agents (Claude, Cursor, etc.) a single
-  <code>notify</code> / <code>ask</code> interface — desktop, Telegram, SMS, email —
-  with two-way replies, idle gating, and Do Not Disturb.
+  HTTP-first notification/control server with optional MCP compatibility for AI agents
+  (Claude, Copilot, Cursor, etc.): desktop, Telegram, Slack, SMS, email,
+  two-way replies, idle gating, and Do Not Disturb.
 </p>
 
 <p align="center">
@@ -37,6 +37,20 @@ You step away from your machine and the AI is still working. **It needs to**:
 
 ## Quick start
 
+```bash
+npx omni-notify-ui
+```
+
+This starts the HTTP/UI server on `http://localhost:3737`.
+
+MCP is optional. To enable the `/mcp` endpoint, start with:
+
+```bash
+ENABLE_MCP=1 npx omni-notify-ui
+```
+
+Or use the stdio bridge (which auto-spawns the UI with MCP enabled):
+
 ```bash
 npx omni-notify-mcp
 ```
@@ -54,12 +68,6 @@ Add to your MCP config (`~/.claude.json`, `.vscode/mcp.json`, `claude_desktop_co
 }
 ```
 
-Then run the config UI to wire up your channels:
-
-```bash
-npx omni-notify-ui
-```
-
 Open <http://localhost:3737>, toggle the channels you want, and hit Save. The MCP server picks up changes immediately — no restart.
 
 ## What the agent gets

package/dist/index.js

@@ -27,12 +27,14 @@ import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { spawn } from "child_process";
 import { existsSync } from "fs";
-import { join, dirname } from "path";
+import { join, dirname, basename } from "path";
+import { hostname } from "os";
 import { fileURLToPath } from "url";
 import { z } from "zod";
 const PORT = process.env.NOTIFY_MCP_PORT ? parseInt(process.env.NOTIFY_MCP_PORT) : 3737;
 const BASE = `http://localhost:${PORT}`;
-const SESSION_TAG = (process.env.NOTIFY_MCP_TAG ?? "").toLowerCase().replace(/[^a-z0-9_-]/g, "") || undefined;
+const VSC_ID = (process.env.NOTIFY_MCP_TAG || basename(process.cwd())).toLowerCase().replace(/[^a-z0-9_-]/g, "");
+const SESSION_TAG = `${hostname().toLowerCase().replace(/[^a-z0-9_-]/g, "")}-${VSC_ID}`;
 const CLIENT_NAME = "claude-channel-bridge";
 // ── 1. Ensure the HTTP server is up ───────────────────────────────────────────
 async function serverIsUp() {
@@ -43,9 +45,9 @@ async function serverIsUp() {
             body: JSON.stringify({ jsonrpc: "2.0", id: 0, method: "initialize", params: {} }),
             signal: AbortSignal.timeout(1500),
         });
-        // Any HTTP response (including 400/406 from malformed init) means the
-        // server is alive and speaking HTTP. Real "down" surfaces as a throw.
-        return r.status > 0;
+        // The bridge requires an active /mcp endpoint.
+        // 404 specifically means UI may be up but MCP transport is disabled.
+        return r.status > 0 && r.status !== 404;
     }
     catch {
         return false;
@@ -68,7 +70,7 @@ function spawnUiServerIfNeeded() {
     const child = spawn(process.execPath, [uiPath], {
         detached: true,
         stdio: "ignore",
-        env: { ...process.env, PORT: String(PORT) },
+        env: { ...process.env, PORT: String(PORT), ENABLE_MCP: "1" },
     });
     child.unref();
 }
@@ -159,6 +161,21 @@ async function httpInitialize() {
     // Follow-up: the spec requires a notifications/initialized after initialize.
     await httpRpc("notifications/initialized").catch(() => { });
 }
+// Periodically touch our /mcp session so the server's reaper doesn't prune it.
+// Without this, the bridge opens a session on startup, proxies tool calls
+// infrequently, and after 60s of idle the server wipes the session from its
+// sessions[] map — which makes Telegram's "routed to X agents" ack say
+// "no agents connected" even though the bridge is still alive and subscribed.
+function startSessionKeepalive() {
+    setInterval(async () => {
+        try {
+            await httpRpc("tools/list").catch(() => { });
+        }
+        catch {
+            // best effort; next call will re-initialize via 404 retry path
+        }
+    }, 30_000);
+}
 // ── 3. Stdio MCP server — the thing Claude Code / Cursor attaches to ─────────
 const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
     // Declare the claude/channel capability so Claude Code knows to surface
@@ -168,10 +185,14 @@ const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
     capabilities: {
         experimental: { "claude/channel": {} },
     },
-    instructions: "This is the stdio bridge for notify-mcp. It pushes unsolicited user " +
-        "messages to the agent via `notifications/claude/channel` when the host " +
-        "supports Channels (Claude Code v2.1.80+). Otherwise call `wait_for_inbox` " +
-        "as a long-poll to reliably receive user messages as tool results.\n\n" +
+    instructions: "This is the stdio bridge for notify-mcp. To receive unsolicited user " +
+        "messages in ANY MCP host (Claude Code, Copilot, Cursor), call `wait_for_inbox` " +
+        "— it long-polls up to 50s and returns new user messages as tool results. Call " +
+        "it whenever you finish a task or would otherwise wait, then again right after " +
+        "handling each batch, so messages keep arriving. (The Claude Code CLI launched " +
+        "with `--channels` ALSO delivers messages as synthetic turns automatically, but " +
+        "that path does NOT exist in the VSCode extension or Copilot — `wait_for_inbox` " +
+        "is the reliable lowest-common-denominator mechanism across every host.)\n\n" +
         "ALWAYS call `notify` when: (a) a task that took >60s of wall-clock time " +
         "just finished (success or failure), (b) you have a question or need a " +
         "decision, (c) something important happened the user needs to know right " +
@@ -182,6 +203,15 @@ const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
         "shorten it with '…' or a summary. NEVER mention delivery channels (Telegram, " +
         "SMS, desktop, etc.) or echo 'Sent via: …' — those are server internals. " +
         "Say 'notif' or 'notification' if you need to refer to the act of notifying.\n\n" +
+        "🚨 500-CHAR LIMIT — CHUNK, NEVER TRUNCATE 🚨\n" +
+        "The `notify` tool rejects bodies > 500 chars with `MCP error -32602: too_big`. " +
+        "When you have more to say than fits in 500 chars, you MUST split into MULTIPLE " +
+        "notify calls — do NOT silently shorten the body. Procedure: (1) decide what " +
+        "the user MUST see (every fact, file path, line number, recommendation); (2) if " +
+        "the body exceeds 500 chars, split into N chunks numbered '(1/N) ...', '(2/N) ...', " +
+        "each ≤ 500 chars including the prefix; (3) send all N chunks in order via separate " +
+        "notify calls and echo all N IN FULL in chat. NEVER respond to a `too_big` error by " +
+        "shortening to a single chunk — that loses information the user explicitly needs.\n\n" +
         "When the user asks you to remember a behavioral rule or change how you should act, " +
         "call `update_instructions` with the full updated rules block. This writes to CLAUDE.md " +
         "so the instructions persist across sessions and context compaction.",
@@ -200,7 +230,10 @@ async function proxyToolCall(name, args) {
     }
     return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }] };
 }
-server.tool("notify", "Send a notification to the user. Delivery channels and DND are server-configured.", {
+server.tool("notify", "Send a notification to the user. Delivery channels and DND are server-configured. " +
+    "MAX 500 CHARS PER MESSAGE. If you have more to say, split into multiple notify " +
+    "calls with '(1/N) ...', '(2/N) ...' prefixes — never silently shorten on " +
+    "`too_big` error; that loses information the user needs.", {
     message: z.string().max(500),
     priority: z.enum(["low", "normal", "high"]).default("normal"),
 }, async (args) => proxyToolCall("notify", args));
@@ -323,6 +356,7 @@ async function main() {
     // Fire-and-forget: the stdio transport should be usable immediately; the
     // push channel attaches as soon as the SSE handshake completes.
     subscribeInbox().catch(err => stderr(`[bridge] inbox subscriber crashed: ${err instanceof Error ? err.message : String(err)}`));
+    startSessionKeepalive();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     stderr(`[bridge] stdio MCP bridge ready (tag=${SESSION_TAG ?? "none"}, port=${PORT})`);

package/dist/ui/messaging/notificationEngine.js

@@ -0,0 +1,67 @@
+export function computeDesktopOnlyMode(priority, policy, ctx) {
+    if (priority === "high") {
+        return { desktopOnly: false };
+    }
+    if (policy.dndActive) {
+        return { desktopOnly: false, suppressedReason: "dnd" };
+    }
+    if (ctx.uiActive || (policy.idleEnabled && !ctx.inTelegramConversation && ctx.idleSeconds >= 0 && ctx.idleSeconds < policy.idleThresholdSeconds)) {
+        if (policy.alwaysDesktopWhenActive) {
+            return { desktopOnly: true };
+        }
+        return { desktopOnly: false, suppressedReason: "idle" };
+    }
+    return { desktopOnly: false };
+}
+export async function sendWithRouting(options) {
+    const { message, priority, senders, policy, ctx, enableDesktop, enableTelegram, enableEmail, enableSms, enableNtfy, enableDiscord, enableSlack, enableTeams, } = options;
+    const mode = computeDesktopOnlyMode(priority, policy, ctx);
+    if (mode.suppressedReason === "dnd") {
+        return { delivered: [], errors: [], suppressedReason: "DND active" };
+    }
+    if (mode.suppressedReason === "idle") {
+        return { delivered: [], errors: [], suppressedReason: "Idle gated while active" };
+    }
+    const delivered = [];
+    const errors = [];
+    const desktopOnly = mode.desktopOnly;
+    const trySend = async (name, fn) => {
+        if (!fn)
+            return;
+        try {
+            await fn();
+            delivered.push(name);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`${name}: ${msg}`);
+        }
+    };
+    if (priority !== "low") {
+        if (enableDesktop) {
+            await trySend("desktop", senders.desktop ? () => senders.desktop(message) : undefined);
+        }
+        if (!desktopOnly && enableTelegram) {
+            await trySend("telegram", senders.telegram ? () => senders.telegram(message) : undefined);
+        }
+    }
+    if (!desktopOnly && enableEmail) {
+        await trySend("email", senders.email ? () => senders.email(message) : undefined);
+    }
+    if (!desktopOnly && enableNtfy) {
+        await trySend("ntfy", senders.ntfy ? () => senders.ntfy(message, priority) : undefined);
+    }
+    if (!desktopOnly && enableDiscord) {
+        await trySend("discord", senders.discord ? () => senders.discord(message, priority) : undefined);
+    }
+    if (!desktopOnly && enableSlack) {
+        await trySend("slack", senders.slack ? () => senders.slack(message, priority) : undefined);
+    }
+    if (!desktopOnly && enableTeams) {
+        await trySend("teams", senders.teams ? () => senders.teams(message, priority) : undefined);
+    }
+    if (priority === "high" && enableSms) {
+        await trySend("sms", senders.sms ? () => senders.sms(message) : undefined);
+    }
+    return { delivered, errors };
+}

package/dist/ui/messaging/types.js

@@ -0,0 +1 @@
+export {};

package/dist/ui/server.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { randomUUID } from "crypto";
+import { randomUUID, createHmac, timingSafeEqual } from "crypto";
 import express from "express";
 import { google } from "googleapis";
 import { readFileSync, writeFileSync, existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from "fs";
@@ -11,16 +11,20 @@ import open from "open";
 import notifier from "node-notifier";
 import nodemailer from "nodemailer";
 import twilio from "twilio";
+import { tmpdir } from "os";
+import { sendWithRouting } from "./messaging/notificationEngine.js";
+import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
-import { z } from "zod";
-import { tmpdir } from "os";
 const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3737;
 const REDIRECT_URI = `http://localhost:${PORT}/auth/google/callback`;
 const PUBLIC_DIR = join(fileURLToPath(new URL("../../ui/public", import.meta.url)));
 const CONFIG_DIR = join(homedir(), ".notify-mcp");
 const CONFIG_PATH = join(CONFIG_DIR, "config.json");
 const ADC_PATH = join(homedir(), ".config", "gcloud", "application_default_credentials.json");
+const AGENT_API_KEY = (process.env.NOTIFY_AGENT_KEY ?? "").trim();
+const SLACK_SIGNING_SECRET = (process.env.SLACK_SIGNING_SECRET ?? "").trim();
+const ENABLE_MCP = (process.env.ENABLE_MCP ?? "").trim() === "1";
 function defaultConfig() {
     return {
         desktop: { enabled: false, sound: true },
@@ -141,8 +145,52 @@ function mergePreservingSecrets(existing, update) {
     return merged;
 }
 const app = express();
-app.use(express.json());
+app.use((req, _res, next) => { console.log(`[${new Date().toISOString()}] ${req.method} ${req.url} UA:${req.headers['user-agent']?.slice(0, 60)}`); next(); });
+app.use(express.json({
+    verify: (req, _res, buf) => {
+        req.rawBody = Buffer.from(buf);
+    },
+}));
+app.use(express.urlencoded({
+    extended: true,
+    verify: (req, _res, buf) => {
+        const r = req;
+        if (!r.rawBody)
+            r.rawBody = Buffer.from(buf);
+    },
+}));
 app.use(express.static(PUBLIC_DIR));
+function requireAgentAuth(req, res) {
+    if (!AGENT_API_KEY)
+        return true;
+    const got = String(req.headers["x-notify-key"] ?? "").trim();
+    if (!got || got !== AGENT_API_KEY) {
+        res.status(401).json({ error: "unauthorized" });
+        return false;
+    }
+    return true;
+}
+function verifySlackSignature(req) {
+    if (!SLACK_SIGNING_SECRET)
+        return true;
+    const sig = String(req.headers["x-slack-signature"] ?? "");
+    const ts = String(req.headers["x-slack-request-timestamp"] ?? "");
+    if (!sig || !ts)
+        return false;
+    const tsNum = parseInt(ts, 10);
+    if (!Number.isFinite(tsNum))
+        return false;
+    if (Math.abs(Math.floor(Date.now() / 1000) - tsNum) > 300)
+        return false;
+    const rawBody = (req.rawBody ?? Buffer.from("{}")).toString("utf8");
+    const base = `v0:${ts}:${rawBody}`;
+    const expected = `v0=${createHmac("sha256", SLACK_SIGNING_SECRET).update(base).digest("hex")}`;
+    const a = Buffer.from(expected, "utf8");
+    const b = Buffer.from(sig, "utf8");
+    if (a.length !== b.length)
+        return false;
+    return timingSafeEqual(a, b);
+}
 const ntfySubscribers = new Map();
 function ntfyFanout(topic, message, title, priority, tags) {
     const subs = ntfySubscribers.get(topic);
@@ -205,6 +253,9 @@ function handleNtfyJson(req, res) {
     }, 30_000);
     req.on("close", () => { clearInterval(keepalive); ntfySubscribers.get(topic)?.delete(sub); });
 }
+// ntfy health + info endpoints — app checks these before subscribing
+app.get("/v1/health", (_req, res) => res.json({ healthy: true }));
+app.get("/v1/info", (_req, res) => res.json({ version: "2.11.0", sha: "n/a" }));
 // ntfy app hits /:topic/sse or /:topic/json (no /ntfy/ prefix)
 app.get("/:topic/sse", (req, res) => {
     if (["api", "auth", "mcp", "assets", "ntfy"].includes(req.params.topic)) {
@@ -345,7 +396,8 @@ app.post("/api/test/tts", async (req, res) => {
         const voice = (typeof req.body?.voice === "string" && req.body.voice) ||
             cfg.desktop?.ttsVoice ||
             "en-US-AndrewMultilingualNeural";
-        await speakText("Notification from Claude. This is a voice test.", voice);
+        const text = (typeof req.body?.text === "string" && req.body.text.trim()) || "Notification from Claude. This is a voice test.";
+        await speakText(text, voice);
         res.json({ ok: true, message: `TTS played (${voice})` });
     }
     catch (err) {
@@ -772,33 +824,18 @@ function log(direction, channel, text, client) {
     }
 }
 app.get("/api/sessions", (_req, res) => {
-    const list = listActiveSessions().map(s => ({
-        clientId: s.clientId,
-        tag: s.tag,
-        clientName: s.clientName,
-        clientVersion: s.clientVersion,
-        workspaceName: s.workspaceName,
-        host: s.host,
-        connectedAt: s.connectedAt,
-        lastSeen: s.lastSeen,
+    const now = Date.now();
+    const list = [...inboxStreamClients].map((c, i) => ({
+        clientId: `sse-${i + 1}`,
+        tag: c.tag,
+        transport: "sse",
+        connectedAt: now,
+        lastSeen: now,
     }));
     res.json({ sessions: list });
 });
-app.delete("/api/sessions/:clientId", (req, res) => {
-    const { clientId } = req.params;
-    const entry = Object.entries(sessions).find(([, m]) => m.clientId === clientId);
-    if (!entry) {
-        res.status(404).json({ error: "not found" });
-        return;
-    }
-    const [sessionId] = entry;
-    try {
-        httpTransports[sessionId]?.close();
-    }
-    catch { /* ignore */ }
-    delete httpTransports[sessionId];
-    delete sessions[sessionId];
-    res.json({ ok: true });
+app.delete("/api/sessions/:clientId", (_req, res) => {
+    res.status(410).json({ error: "session_disconnect_unsupported", message: "HTTP mode does not support remote disconnect." });
 });
 app.get("/api/logs", (req, res) => {
     res.setHeader("Content-Type", "text/event-stream");
@@ -813,198 +850,149 @@ app.get("/api/logs", (req, res) => {
 // ── Notification sender ───────────────────────────────────────────────────────
 async function sendNotification(message, priority, client) {
     const cfg = loadConfig();
-    const results = [];
-    const errors = [];
-    // DND check — priority=high always bypasses; anything else gets dropped during quiet hours.
-    // Email still goes through on "low" anyway (historical behavior: low=email-only).
-    if (priority !== "high" && isDndActive(cfg)) {
-        log("·", "dnd", `suppressed ${priority} notif (DND active)`, client);
-        return "DND active — notif suppressed (priority=high would still send)";
-    }
-    // Idle gating — when the user is actively at the keyboard, suppress *remote*
-    // channels (Telegram/SMS/email) for non-high priority. By default we still
-    // play the desktop sound+banner so the user knows *something* happened —
-    // they may have multiple agents running and this is a cheap local signal
-    // that doesn't blast their phone. Disable via idle.alwaysDesktopWhenActive=false.
-    // priority=high always bypasses idle entirely.
-    // Conversation bypass: if the user just messaged us from Telegram (within
-    // the TTL), they clearly want a reply over that channel, so skip idle gating.
     const inTelegramConvo = Date.now() - lastTelegramInboundAt < TELEGRAM_CONVO_TTL_MS;
-    let desktopOnlyMode = false;
-    // If the web UI is open and the user is actively watching it, skip remote channels.
-    if (priority !== "high" && isUiActivelyOpen()) {
-        if (cfg.idle?.alwaysDesktopWhenActive !== false && cfg.desktop?.enabled) {
-            desktopOnlyMode = true;
-            log("·", "ui", `UI visible — desktop-only`, client);
-        }
-    }
-    if (!desktopOnlyMode && priority !== "high" && !inTelegramConvo && cfg.idle?.enabled !== false) {
-        const idleSecs = getOsIdleSeconds();
-        const threshold = cfg.idle?.thresholdSeconds ?? 120;
-        const userIsActive = idleSecs >= 0 && idleSecs < threshold;
-        if (userIsActive) {
-            if (cfg.idle?.alwaysDesktopWhenActive !== false && cfg.desktop?.enabled) {
-                desktopOnlyMode = true;
-                log("·", "idle", `user active (${idleSecs}s < ${threshold}s) — desktop-only`, client);
-            }
-            else {
-                log("·", "idle", `user active (${idleSecs}s < ${threshold}s) — suppressed`, client);
-                return "Idle gated — user is active, notif suppressed (priority=high would still send)";
-            }
-        }
-    }
-    else if (priority !== "high" && inTelegramConvo) {
-        log("·", "idle", `bypassed (telegram convo active)`, client);
-    }
-    const send = async (name, fn) => {
-        try {
-            await fn();
-            results.push(name);
-            log("→", name, message, client);
-        }
-        catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            errors.push(`${name}: ${msg}`);
-            log("→", name, `ERROR: ${msg}`, client);
-        }
-    };
-    if (priority !== "low") {
-        if (cfg.desktop?.enabled) {
-            const wantSound = cfg.desktop?.sound !== false;
-            // On Windows, SnoreToast's per-app sound is often muted by the user's
-            // Windows notification settings — fire a PowerShell beep alongside the
-            // toast so the audible cue is reliable. macOS/Linux: trust the OS.
-            if (wantSound && process.platform === "win32") {
-                // [console]::beep uses the PC speaker (motherboard buzzer), which
-                // modern laptops/desktops don't have — silent on most machines.
-                // SystemSounds.Asterisk plays through the actual sound card via
-                // the Windows notification sound, audible on every machine.
-                spawn("powershell", [
-                    "-NoProfile", "-Command",
-                    "Add-Type -AssemblyName System.Windows.Forms; [System.Media.SystemSounds]::Asterisk.Play(); Start-Sleep -Milliseconds 600",
-                ], { windowsHide: true, stdio: "ignore" });
-            }
-            const soundOpt = wantSound && process.platform !== "win32";
-            if (cfg.desktop?.tts) {
-                const voice = cfg.desktop?.ttsVoice ?? "en-US-AndrewMultilingualNeural";
-                speakText(message, voice).catch((err) => log("→", "tts", `ERROR: ${err instanceof Error ? err.message : String(err)}`, client));
-            }
-            await send("desktop", () => new Promise((res, rej) => notifier.notify({ title: "Claude Notify", message, sound: soundOpt }, (err) => err ? rej(err) : res())));
-        }
-        if (!desktopOnlyMode && cfg.telegram?.enabled && cfg.telegram.token && cfg.telegram.chatId) {
-            await send("telegram", async () => {
+    const idleSecs = getOsIdleSeconds();
+    const result = await sendWithRouting({
+        message,
+        priority,
+        policy: {
+            idleEnabled: cfg.idle?.enabled !== false,
+            idleThresholdSeconds: cfg.idle?.thresholdSeconds ?? 120,
+            alwaysDesktopWhenActive: cfg.idle?.alwaysDesktopWhenActive !== false,
+            dndActive: isDndActive(cfg),
+        },
+        ctx: {
+            inTelegramConversation: inTelegramConvo,
+            uiActive: isUiActivelyOpen(),
+            idleSeconds: idleSecs,
+        },
+        enableDesktop: !!cfg.desktop?.enabled,
+        enableTelegram: !!(cfg.telegram?.enabled && cfg.telegram.token && cfg.telegram.chatId),
+        enableEmail: !!(cfg.email?.enabled && cfg.email.to),
+        enableSms: !!(cfg.sms?.enabled && cfg.sms.accountSid && cfg.sms.authToken && cfg.sms.from && cfg.sms.to),
+        enableNtfy: !!(cfg.ntfy?.enabled && cfg.ntfy.topic),
+        enableDiscord: !!(cfg.discord?.enabled && cfg.discord.webhookUrl),
+        enableSlack: !!(cfg.slack?.enabled && cfg.slack.webhookUrl),
+        enableTeams: !!(cfg.teams?.enabled && cfg.teams.webhookUrl),
+        senders: {
+            desktop: async () => {
+                const wantSound = cfg.desktop?.sound !== false;
+                if (wantSound && process.platform === "win32") {
+                    spawn("powershell", [
+                        "-NoProfile", "-Command",
+                        "Add-Type -AssemblyName System.Windows.Forms; [System.Media.SystemSounds]::Asterisk.Play(); Start-Sleep -Milliseconds 600",
+                    ], { windowsHide: true, stdio: "ignore" });
+                }
+                const soundOpt = wantSound && process.platform !== "win32";
+                if (cfg.desktop?.tts) {
+                    const voice = cfg.desktop?.ttsVoice ?? "en-US-AndrewMultilingualNeural";
+                    speakText(message, voice).catch((err) => log("→", "tts", `ERROR: ${err instanceof Error ? err.message : String(err)}`, client));
+                }
+                await new Promise((resolve, reject) => {
+                    notifier.notify({ title: "Claude Notify", message, sound: soundOpt }, (err) => {
+                        if (err)
+                            reject(err);
+                        else
+                            resolve();
+                    });
+                });
+            },
+            telegram: async () => {
                 const body = { chat_id: cfg.telegram.chatId, text: message };
                 if (lastUserMessageId)
                     body.reply_to_message_id = lastUserMessageId;
                 const r = await fetch(`https://api.telegram.org/bot${cfg.telegram.token}/sendMessage`, {
-                    method: "POST", headers: { "Content-Type": "application/json" },
+                    method: "POST",
+                    headers: { "Content-Type": "application/json" },
                     body: JSON.stringify(body),
                 });
                 if (!r.ok)
                     throw new Error(await r.text());
-            });
-        }
-    }
-    if (priority === "high") {
-        const sms = cfg.sms ?? {};
-        if (sms.enabled && sms.accountSid && sms.authToken && sms.from && sms.to) {
-            await send("sms", async () => {
-                const client = twilio(sms.accountSid, sms.authToken);
-                await client.messages.create({ body: message, from: sms.from, to: sms.to });
-            });
-        }
-    }
-    const email = cfg.email ?? {};
-    if (!desktopOnlyMode && email.enabled && email.to) {
-        await send("email", async () => {
-            let transport;
-            if (email.refreshToken && email.clientId && email.clientSecret) {
-                transport = nodemailer.createTransport({
-                    service: "gmail", auth: { type: "OAuth2", user: email.connectedEmail ?? email.to,
-                        clientId: email.clientId, clientSecret: email.clientSecret,
-                        refreshToken: email.refreshToken, accessToken: email.accessToken },
-                });
-            }
-            else if (email.host && email.user && email.pass) {
-                transport = nodemailer.createTransport({
-                    host: email.host, port: email.port ?? 587, secure: email.secure ?? false,
-                    auth: { user: email.user, pass: email.pass },
+            },
+            sms: async () => {
+                const smsClient = twilio(cfg.sms.accountSid, cfg.sms.authToken);
+                await smsClient.messages.create({ body: message, from: cfg.sms.from, to: cfg.sms.to });
+            },
+            email: async () => {
+                const email = cfg.email;
+                let transport;
+                if (email.refreshToken && email.clientId && email.clientSecret) {
+                    transport = nodemailer.createTransport({
+                        service: "gmail",
+                        auth: {
+                            type: "OAuth2",
+                            user: email.connectedEmail ?? email.to,
+                            clientId: email.clientId,
+                            clientSecret: email.clientSecret,
+                            refreshToken: email.refreshToken,
+                            accessToken: email.accessToken,
+                        },
+                    });
+                }
+                else if (email.host && email.user && email.pass) {
+                    transport = nodemailer.createTransport({
+                        host: email.host,
+                        port: email.port ?? 587,
+                        secure: email.secure ?? false,
+                        auth: { user: email.user, pass: email.pass },
+                    });
+                }
+                else {
+                    return;
+                }
+                await transport.sendMail({
+                    from: email.connectedEmail ?? email.user ?? email.to,
+                    to: email.to,
+                    subject: "Claude Notify",
+                    text: message,
                 });
-            }
-            else
-                return;
-            await transport.sendMail({ from: email.connectedEmail ?? email.user ?? email.to,
-                to: email.to, subject: "Claude Notify", text: message });
-        });
-    }
-    // ntfy (built-in server — direct fanout, no external fetch)
-    if (!desktopOnlyMode) {
-        const ntfy = cfg.ntfy ?? {};
-        if (ntfy.enabled && ntfy.topic) {
-            await send("ntfy", async () => {
+            },
+            ntfy: async (_text, prio) => {
                 const priorityMap = { low: 2, normal: 3, high: 5 };
-                const tags = priority === "high" ? "rotating_light" : "bell";
-                const subs = ntfySubscribers.get(ntfy.topic)?.size ?? 0;
+                const tags = prio === "high" ? "rotating_light" : "bell";
+                const subs = ntfySubscribers.get(cfg.ntfy.topic)?.size ?? 0;
                 if (subs === 0)
-                    throw new Error(`ntfy: no subscribers on topic '${ntfy.topic}' — is the app connected?`);
-                ntfyFanout(ntfy.topic, message, "Claude Notify", priorityMap[priority] ?? 3, tags);
-            });
-        }
-    }
-    // Discord
-    if (!desktopOnlyMode) {
-        const dc = cfg.discord ?? {};
-        if (dc.enabled && dc.webhookUrl) {
-            await send("discord", async () => {
+                    throw new Error(`ntfy: no subscribers on topic '${cfg.ntfy.topic}'`);
+                ntfyFanout(cfg.ntfy.topic, message, "Claude Notify", priorityMap[prio] ?? 3, tags);
+            },
+            discord: async (_text, prio) => {
                 const colorMap = { low: 0x6b7280, normal: 0x7c6dfa, high: 0xef4444 };
-                const r = await fetch(dc.webhookUrl, {
+                const r = await fetch(cfg.discord.webhookUrl, {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify({
-                        username: dc.username ?? "Claude Notify",
+                        username: cfg.discord.username ?? "Claude Notify",
                         embeds: [{
                                 title: "Claude Notify",
                                 description: message,
-                                color: colorMap[priority] ?? colorMap.normal,
+                                color: colorMap[prio] ?? colorMap.normal,
                                 timestamp: new Date().toISOString(),
                             }],
                     }),
                 });
                 if (!r.ok)
                     throw new Error(`Discord ${r.status}: ${await r.text()}`);
-            });
-        }
-    }
-    // Slack
-    if (!desktopOnlyMode) {
-        const sl = cfg.slack ?? {};
-        if (sl.enabled && sl.webhookUrl) {
-            await send("slack", async () => {
+            },
+            slack: async (_text, prio) => {
                 const emojiMap = { low: "ℹ️", normal: "🔔", high: "🚨" };
-                const emoji = emojiMap[priority] ?? emojiMap.normal;
-                const r = await fetch(sl.webhookUrl, {
+                const emoji = emojiMap[prio] ?? emojiMap.normal;
+                const r = await fetch(cfg.slack.webhookUrl, {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify({
                         text: `${emoji} *Claude Notify*`,
                         blocks: [
                             { type: "section", text: { type: "mrkdwn", text: `${emoji} *Claude Notify*\n${message}` } },
-                            { type: "context", elements: [{ type: "mrkdwn", text: `Priority: ${priority}` }] },
+                            { type: "context", elements: [{ type: "mrkdwn", text: `Priority: ${prio}` }] },
                         ],
                     }),
                 });
                 if (!r.ok)
                     throw new Error(`Slack ${r.status}: ${await r.text()}`);
-            });
-        }
-    }
-    // Teams
-    if (!desktopOnlyMode) {
-        const tm = cfg.teams ?? {};
-        if (tm.enabled && tm.webhookUrl) {
-            await send("teams", async () => {
+            },
+            teams: async (_text, prio) => {
                 const colorMap = { low: "Default", normal: "Accent", high: "Attention" };
-                const r = await fetch(tm.webhookUrl, {
+                const r = await fetch(cfg.teams.webhookUrl, {
                     method: "POST",
                     headers: { "Content-Type": "application/json" },
                     body: JSON.stringify({
@@ -1014,11 +1002,12 @@ async function sendNotification(message, priority, client) {
                                 contentUrl: null,
                                 content: {
                                     $schema: "http://adaptivecards.io/schemas/adaptive-card.json",
-                                    type: "AdaptiveCard", version: "1.2",
+                                    type: "AdaptiveCard",
+                                    version: "1.2",
                                     body: [
-                                        { type: "TextBlock", size: "Medium", weight: "Bolder", text: "Claude Notify", color: colorMap[priority] ?? "Default" },
+                                        { type: "TextBlock", size: "Medium", weight: "Bolder", text: "Claude Notify", color: colorMap[prio] ?? "Default" },
                                         { type: "TextBlock", text: message, wrap: true },
-                                        { type: "TextBlock", text: `Priority: ${priority}`, isSubtle: true, size: "Small" },
+                                        { type: "TextBlock", text: `Priority: ${prio}`, isSubtle: true, size: "Small" },
                                     ],
                                 },
                             }],
@@ -1026,12 +1015,22 @@ async function sendNotification(message, priority, client) {
                 });
                 if (!r.ok)
                     throw new Error(`Teams ${r.status}: ${await r.text()}`);
-            });
-        }
+            },
+        },
+    });
+    if (result.suppressedReason) {
+        log("·", "notify", `suppressed (${result.suppressedReason})`, client);
+        return result.suppressedReason;
+    }
+    for (const delivered of result.delivered) {
+        log("→", delivered, message, client);
+    }
+    for (const err of result.errors) {
+        log("→", "notify", `ERROR: ${err}`, client);
     }
     return [
-        results.length ? `Sent via: ${results.join(", ")}` : null,
-        errors.length ? `Errors: ${errors.join("; ")}` : null,
+        result.delivered.length ? `Sent via: ${result.delivered.join(", ")}` : null,
+        result.errors.length ? `Errors: ${result.errors.join("; ")}` : null,
     ].filter(Boolean).join(" | ") || "No channels delivered";
 }
 // ── OS idle-time (cross-platform) ─────────────────────────────────────────────
@@ -1169,8 +1168,11 @@ function writeInboxDrop(entry) {
         const header = `# Unsolicited user message\n\n` +
             `- Time: ${entry.ts}\n` +
             (entry.tag ? `- Tag: @${entry.tag}\n` : "") +
-            `- Origin: user (out-of-band)\n\n`;
-        writeFileSync(path, header + entry.text + "\n");
+            `- Origin: ${entry.origin ?? "user"} (out-of-band)\n\n`;
+        const replyHint = entry.origin === "slack"
+            ? `\n---\n↩ This arrived over the Slack bus — the user is WAITING in the channel. Reply there ASAP when done:\n\`\`\`\ncurl -s -X POST http://localhost:${PORT}/api/agent/slack/reply -H 'Content-Type: application/json' -d '{"text":"YOUR ANSWER","tag":"${entry.tag ?? ""}"}'\n\`\`\`\n`
+            : "";
+        writeFileSync(path, header + entry.text + "\n" + replyHint);
     }
     catch (err) {
         log("·", "inbox-drop", `write failed: ${err instanceof Error ? err.message : String(err)}`);
@@ -1221,6 +1223,22 @@ function broadcastInbox(entry) {
     }
     return delivered;
 }
+function ingestInboxEntry(entry, source) {
+    const waiters = takeWaitersFor(entry.tag);
+    if (waiters.length > 0) {
+        for (const w of waiters) {
+            clearTimeout(w.timer);
+            w.resolve([entry]);
+        }
+    }
+    else {
+        inboxQueue.push(entry);
+        writeInboxDrop(entry);
+    }
+    const sse = broadcastInbox(entry);
+    log("·", "inbox", `${source}: ${entry.text} (sse=${sse}, waiters=${waiters.length})`, entry.tag);
+    return { waiters: waiters.length, sse };
+}
 // Test-only: inject a fake inbox entry exactly as the Telegram listener would.
 // Gated behind NOTIFY_MCP_TEST_ENDPOINTS=1 so it's never exposed in a normal
 // production run. Used by the test suite to drive wait_for_inbox wake-up and
@@ -1234,20 +1252,8 @@ if (process.env.NOTIFY_MCP_TEST_ENDPOINTS === "1") {
             return;
         }
         const entry = { text, ts: new Date().toISOString(), tag };
-        const waiters = takeWaitersFor(tag);
-        if (waiters.length > 0) {
-            for (const w of waiters) {
-                clearTimeout(w.timer);
-                w.resolve([entry]);
-            }
-        }
-        else {
-            inboxQueue.push(entry);
-        }
-        const sse = broadcastInbox(entry);
-        writeInboxDrop(entry);
-        log("·", "test-inject", `${text} (waiters=${waiters.length}, sse=${sse})`, tag);
-        res.json({ injected: true, waiters: waiters.length, sse });
+        const out = ingestInboxEntry(entry, "test-inject");
+        res.json({ injected: true, waiters: out.waiters, sse: out.sse });
     });
     log("·", "test", "NOTIFY_MCP_TEST_ENDPOINTS=1 — /__test__/inject-inbox enabled");
 }
@@ -1274,6 +1280,206 @@ app.get("/api/inbox/stream", (req, res) => {
         inboxStreamClients.delete(client);
     });
 });
+// ── Non-MCP automation API ───────────────────────────────────────────────────
+// These endpoints let an agent script use plain HTTP (no MCP transport) for
+// notify + unsolicited inbox handling.
+app.post("/api/agent/notify", async (req, res) => {
+    if (!requireAgentAuth(req, res))
+        return;
+    const message = String(req.body?.message ?? "").trim();
+    const priority = String(req.body?.priority ?? "normal");
+    if (!message) {
+        res.status(400).json({ error: "message required" });
+        return;
+    }
+    if (!["low", "normal", "high"].includes(priority)) {
+        res.status(400).json({ error: "invalid priority" });
+        return;
+    }
+    try {
+        const out = await sendNotification(message, priority, "agent-http");
+        res.json({ ok: true, result: out });
+    }
+    catch (err) {
+        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+    }
+});
+app.get("/api/agent/inbox/poll", (req, res) => {
+    if (!requireAgentAuth(req, res))
+        return;
+    const tag = typeof req.query.tag === "string" ? req.query.tag.toLowerCase() : undefined;
+    const messages = drainInboxFor(tag);
+    res.json({ ok: true, messages });
+});
+app.get("/api/agent/inbox/wait", async (req, res) => {
+    if (!requireAgentAuth(req, res))
+        return;
+    const tag = typeof req.query.tag === "string" ? req.query.tag.toLowerCase() : undefined;
+    const timeoutSecondsRaw = parseInt(String(req.query.timeout_seconds ?? "50"), 10);
+    const timeoutSeconds = Number.isFinite(timeoutSecondsRaw) ? Math.max(5, Math.min(55, timeoutSecondsRaw)) : 50;
+    const queued = drainInboxFor(tag);
+    if (queued.length > 0) {
+        res.json({ ok: true, messages: queued, empty: false });
+        return;
+    }
+    const token = randomUUID();
+    const entries = await new Promise((resolve) => {
+        const timer = setTimeout(() => {
+            inboxWaiters.delete(token);
+            resolve([]);
+        }, timeoutSeconds * 1000);
+        inboxWaiters.set(token, { resolve, timer, tag });
+    });
+    res.json({ ok: true, messages: entries, empty: entries.length === 0 });
+});
+app.post("/api/agent/inbox/inject", (req, res) => {
+    if (!requireAgentAuth(req, res))
+        return;
+    const text = String(req.body?.text ?? "").trim();
+    if (!text) {
+        res.status(400).json({ error: "text required" });
+        return;
+    }
+    const tag = req.body?.tag ? String(req.body.tag).toLowerCase() : undefined;
+    const entry = { text, ts: new Date().toISOString(), tag };
+    const out = ingestInboxEntry(entry, "agent-inject");
+    res.json({ ok: true, waiters: out.waiters, sse: out.sse });
+});
+app.post("/api/agent/slack/reply", (req, res) => {
+    if (!requireAgentAuth(req, res))
+        return;
+    const text = String(req.body?.text ?? "").trim();
+    if (!text) {
+        res.status(400).json({ error: "text required" });
+        return;
+    }
+    const tag = req.body?.tag ? String(req.body.tag).toLowerCase() : undefined;
+    slackPost(tag ? `[@${tag}] ${text}` : text);
+    log("→", "slack:reply", text, tag);
+    res.json({ ok: true });
+});
+// Interactive-session busy/idle, reported by that session's hooks (busy on
+// UserPromptSubmit/PreToolUse/PostToolUse, idle on Stop). Lets the bus tell the
+// user "Claude is busy" + a rough ETA when a request lands on a busy prompt.
+const sessionBusy = {};
+const busyDurations = [];
+function setSessionState(tag, busy) {
+    const prev = sessionBusy[tag];
+    if (busy) {
+        if (!prev?.busy)
+            sessionBusy[tag] = { busy: true, since: Date.now() };
+    }
+    else {
+        if (prev?.busy) {
+            busyDurations.push(Date.now() - prev.since);
+            if (busyDurations.length > 20)
+                busyDurations.shift();
+        }
+        sessionBusy[tag] = { busy: false, since: 0 };
+    }
+}
+function busyEtaSecs() {
+    if (!busyDurations.length)
+        return null;
+    return Math.round(busyDurations.reduce((a, b) => a + b, 0) / busyDurations.length / 1000);
+}
+function sessionBusyNote(tag) {
+    const s = sessionBusy[tag];
+    if (!s?.busy)
+        return "";
+    const secs = Math.round((Date.now() - s.since) / 1000);
+    const eta = busyEtaSecs();
+    return `🔧 Claude @${tag} is busy right now (working ${secs}s) — your request is queued and runs the moment the prompt is free.${eta ? ` Turns here usually finish in ~${eta}s.` : ""}`;
+}
+app.post("/api/session/state", (req, res) => {
+    const tag = req.body?.tag ? String(req.body.tag).toLowerCase() : undefined;
+    if (!tag) {
+        res.status(400).json({ error: "tag required" });
+        return;
+    }
+    setSessionState(tag, req.body?.busy === true || req.body?.busy === "true");
+    res.json({ ok: true, busy: sessionBusy[tag]?.busy ?? false });
+});
+// Slack Events API (inbound). Requires configuring your Slack app with an
+// Event Request URL: POST /api/slack/events.
+app.post("/api/slack/events", (req, res) => {
+    let body = req.body ?? {};
+    if (body?.payload && typeof body.payload === "string") {
+        try {
+            body = JSON.parse(body.payload);
+        }
+        catch {
+            // keep original body if payload isn't valid JSON
+        }
+    }
+    if ((!body || Object.keys(body).length === 0) && req.rawBody) {
+        const raw = (req.rawBody ?? Buffer.from("{}")).toString("utf8");
+        try {
+            body = JSON.parse(raw);
+        }
+        catch {
+            body = req.body ?? {};
+        }
+    }
+    // Slack URL verification can arrive before full event wiring, and some
+    // intermediaries/proxies send this as form data. Respond immediately when
+    // a challenge value is present so the URL can be saved.
+    const challenge = body?.challenge ?? (typeof req.query.challenge === "string" ? req.query.challenge : undefined);
+    if (challenge) {
+        log("·", "slack", "url_verification challenge received");
+        res.status(200).json({ challenge });
+        return;
+    }
+    if (!verifySlackSignature(req)) {
+        log("·", "slack", "rejected: bad signature");
+        res.status(401).json({ error: "bad slack signature" });
+        return;
+    }
+    const envelopeType = String(body?.type ?? "unknown");
+    const event = body?.event ?? {};
+    const eventType = String(event?.type ?? "none");
+    const subtype = typeof event?.subtype === "string" ? event.subtype : "";
+    const channel = String(event?.channel ?? body?.channel_id ?? "none");
+    log("·", "slack", `event: envelope=${envelopeType}, type=${eventType}, subtype=${subtype || "none"}, channel=${channel}`);
+    if (body.type !== "event_callback") {
+        res.json({ ok: true, ignored: true, reason: `unsupported envelope type: ${envelopeType}` });
+        return;
+    }
+    const ignoreReasons = [];
+    if (event.type !== "message")
+        ignoreReasons.push(`event.type=${eventType}`);
+    if (subtype)
+        ignoreReasons.push(`subtype=${subtype}`);
+    if (event.bot_id)
+        ignoreReasons.push("bot message");
+    if (!event.text)
+        ignoreReasons.push("missing text");
+    if (event.type !== "message" || subtype || event.bot_id || !event.text) {
+        const reason = ignoreReasons.join(", ") || "filtered";
+        log("·", "slack", `ignored: ${reason}`);
+        res.json({ ok: true, ignored: true, reason });
+        return;
+    }
+    const parsed = parseTag(String(event.text));
+    const candidate = [...pendingAsks.entries()].find(([, p]) => (parsed.tag ? p.tag === parsed.tag : true));
+    if (candidate) {
+        const [id, pending] = candidate;
+        clearTimeout(pending.timer);
+        pendingAsks.delete(id);
+        log("←", "ask:reply", parsed.text, parsed.tag);
+        pending.resolve(parsed.text);
+        res.json({ ok: true, routed: "ask" });
+        return;
+    }
+    const ts = event.ts ? new Date(Number(event.ts) * 1000).toISOString() : new Date().toISOString();
+    const entry = {
+        text: parsed.text,
+        tag: parsed.tag,
+        ts,
+    };
+    const out = ingestInboxEntry(entry, "slack");
+    res.json({ ok: true, routed: "inbox", waiters: out.waiters, sse: out.sse });
+});
 async function initTgOffset(token) {
     const r = await fetch(`https://api.telegram.org/bot${token}/getUpdates?offset=-1&timeout=0`);
     const json = await r.json();
@@ -1369,28 +1575,19 @@ async function startTelegramListener() {
                         writeInboxDrop(entry);
                         const liveSseCount = broadcastInbox(entry);
                         log("·", "inbox", `${text} (sse=${liveSseCount}, waiters=${waiters.length})`, tag);
-                        // Before building the ack, prune sessions whose transport stream
-                        // is dead or whose heartbeat has lapsed. Without this the ack
-                        // cheerfully claims "broadcast to 3 sessions" when 2 of them are
-                        // closed VS Code windows — which is exactly what prompted this fix.
-                        pruneDeadSessions();
-                        // Build an ack that names the active sessions the user's message
-                        // is being routed to. If the user tagged it and no session with
-                        // that tag is connected, tell them plainly so they don't sit
-                        // waiting for a reply that can't come.
-                        const targets = sessionsMatchingTag(tag);
+                        const sseCount = sseSubscribersForTag(tag);
+                        const anyoneListening = sseCount > 0 || waiters.length > 0;
                         let ackText;
-                        if (tag && targets.length === 0) {
+                        if (!anyoneListening && tag) {
                             ackText = `📭 No session @${tag} connected. Message queued — next @${tag} to connect will pick it up.`;
                         }
-                        else if (targets.length === 0) {
+                        else if (!anyoneListening) {
                             ackText = `📭 No agents connected. Message queued — next agent to connect will pick it up.`;
                         }
                         else {
-                            const names = targets.map(sessionDisplay).join(", ");
                             ackText = tag
-                                ? `📬 Routed to ${names}. Waiting for them to reply.`
-                                : `📬 Broadcast to ${targets.length} session(s): ${names}. Each should reply with its identity — respond to the one you want.`;
+                                ? `📬 Routed to @${tag}. Waiting for reply.`
+                                : `📬 Broadcast to ${sseCount} listener${sseCount === 1 ? "" : "s"}. Waiting for reply.`;
                         }
                         fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
                             method: "POST", headers: { "Content-Type": "application/json" },
@@ -1416,6 +1613,158 @@ async function startTelegramListener() {
         }
     }
 }
+// ── Slack inbound poller (always-on; folds slack-poll.sh → #16) ────────────────
+const SLACK_SECRETS_PATH = join(fileURLToPath(new URL("../../notify-secrets.json", import.meta.url)));
+function decodeB64Fields(obj) {
+    if (Array.isArray(obj))
+        return obj.map(decodeB64Fields);
+    if (obj && typeof obj === "object") {
+        const out = {};
+        for (const [k, v] of Object.entries(obj)) {
+            if (k.endsWith("_b64") && typeof v === "string")
+                out[k.slice(0, -4)] = Buffer.from(v, "base64").toString("utf8");
+            else
+                out[k] = decodeB64Fields(v);
+        }
+        return out;
+    }
+    return obj;
+}
+function loadSecrets() {
+    if (!existsSync(SLACK_SECRETS_PATH))
+        return {};
+    try {
+        return decodeB64Fields(JSON.parse(readFileSync(SLACK_SECRETS_PATH, "utf8")));
+    }
+    catch (err) {
+        log("·", "secrets", `load failed: ${err instanceof Error ? err.message : String(err)}`);
+        return {};
+    }
+}
+function slackCreds() {
+    const s = loadSecrets().slack ?? {};
+    const cfgSlack = loadConfig().slack ?? {};
+    const token = (process.env.SLACK_BOT_TOKEN ?? s.botToken ?? "").trim() || undefined;
+    const channel = (process.env.SLACK_CHANNEL_ID ?? s.channelId ?? "").trim() || undefined;
+    const webhook = (s.webhookUrl ?? cfgSlack.webhookUrl ?? "").trim() || undefined;
+    return { token, channel, webhook };
+}
+async function slackPost(text) {
+    const { webhook } = slackCreds();
+    if (!webhook)
+        return;
+    try {
+        await fetch(webhook, { method: "POST", headers: { "Content-Type": "application/json" }, body: JSON.stringify({ text }) });
+    }
+    catch { /* webhook post is best-effort */ }
+}
+function slackClientTags() {
+    const tags = new Set();
+    for (const sess of listActiveSessions())
+        if (sess.tag)
+            tags.add(sess.tag);
+    for (const c of inboxStreamClients)
+        if (c.tag)
+            tags.add(c.tag);
+    for (const [, w] of inboxWaiters)
+        if (w.tag)
+            tags.add(w.tag);
+    return [...tags].sort();
+}
+function slackClientsNumbered() {
+    const tags = slackClientTags();
+    return tags.length ? tags.map((t, i) => `${i + 1}. ${t}`).join("\n") : "(none connected)";
+}
+function resolveSlackClient(handle) {
+    const tags = slackClientTags();
+    if (/^[0-9]+$/.test(handle))
+        return tags[parseInt(handle, 10) - 1];
+    return tags.find(t => t === handle);
+}
+async function handleSlackCommand(lc) {
+    if (lc === "list clients" || lc === "clients" || lc === "list") {
+        await slackPost(`Connected clients — reply @<name> or #<id>:\n${slackClientsNumbered()}`);
+        return true;
+    }
+    if (lc === "help" || lc === "commands" || lc === "?") {
+        await slackPost("Commands: `clients`. Direct: `@<name> msg`, `#<id> msg`, or untagged → broadcast to all.");
+        return true;
+    }
+    return false;
+}
+let slackCursor = "";
+let slackConsecutiveErrors = 0;
+async function pollSlackOnce(token, channel) {
+    const url = `https://slack.com/api/conversations.history?channel=${encodeURIComponent(channel)}&oldest=${encodeURIComponent(slackCursor)}&limit=50`;
+    const r = await fetch(url, { headers: { Authorization: `Bearer ${token}` }, signal: AbortSignal.timeout(15_000) });
+    const json = await r.json();
+    if (!json.ok)
+        throw new Error(`conversations.history: ${json.error ?? "unknown"}`);
+    const all = json.messages ?? [];
+    const human = all
+        .filter(m => !m.subtype && !m.bot_id && !m.app_id && m.user && String(m.text ?? "").trim())
+        .sort((a, b) => Number(a.ts) - Number(b.ts));
+    for (const m of human) {
+        const text = String(m.text ?? "");
+        const stripped = text.replace(/<@[A-Za-z0-9]+>/g, "");
+        const lc = stripped.toLowerCase().trim();
+        if (await handleSlackCommand(lc)) {
+            log("←", "slack:cmd", lc);
+            continue;
+        }
+        const clean = stripped.replace(/^\s+/, "");
+        const routed = clean.match(/^[@#]([^\s]+)\s+([\s\S]*)$/);
+        if (routed) {
+            const handle = routed[1];
+            const msg = routed[2];
+            const tag = resolveSlackClient(handle);
+            if (!tag) {
+                await slackPost(`❌ Unknown client "${handle}". Connected:\n${slackClientsNumbered()}`);
+                log("←", "slack", `unknown client: ${handle}`);
+                continue;
+            }
+            ingestInboxEntry({ text: msg, ts: new Date().toISOString(), tag, origin: "slack" }, "slack");
+            await slackPost(sessionBusyNote(tag) || "ack");
+        }
+        else {
+            ingestInboxEntry({ text, ts: new Date().toISOString(), origin: "slack" }, "slack");
+            await slackPost("ack");
+        }
+    }
+    const newest = all.reduce((acc, m) => (Number(m.ts) > Number(acc || 0) ? String(m.ts) : acc), slackCursor);
+    if (newest)
+        slackCursor = newest;
+}
+async function startSlackListener() {
+    const interval = (Number(process.env.SLACK_POLL_INTERVAL) || 2) * 1000;
+    while (true) {
+        try {
+            const { token, channel } = slackCreds();
+            if (!token || !channel) {
+                await new Promise(r => setTimeout(r, 5000));
+                continue;
+            }
+            if (!slackCursor) {
+                slackCursor = String(Math.floor(Date.now() / 1000) - 300);
+                log("·", "slack", `listener ready, channel=${channel}, backfill=300s (closes restart gap)`);
+            }
+            await pollSlackOnce(token, channel);
+            if (slackConsecutiveErrors > 0) {
+                log("·", "slack", `recovered after ${slackConsecutiveErrors} attempt(s)`);
+                slackConsecutiveErrors = 0;
+            }
+            await new Promise(r => setTimeout(r, interval));
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            if (!msg.includes("terminated") && !msg.includes("aborted"))
+                log("·", "slack:error", msg);
+            slackConsecutiveErrors++;
+            const delay = Math.min(60_000, 2000 * Math.pow(2, Math.min(5, slackConsecutiveErrors - 1)));
+            await new Promise(r => setTimeout(r, delay));
+        }
+    }
+}
 app.get("/reply/:token", (req, res) => {
     const pending = pendingAsks.get(req.params.token);
     res.send(`<!DOCTYPE html><html><head><title>Reply to Claude</title>
@@ -1886,6 +2235,22 @@ function sessionsMatchingTag(tag) {
         return listActiveSessions();
     return listActiveSessions().filter(s => s.tag === tag);
 }
+// Count live SSE subscribers on /api/inbox/stream that would receive a message
+// with the given tag. Stdio-bridge clients subscribe via SSE but don't always
+// appear in sessions[] (their /mcp initialize session can get reaped while the
+// SSE stream stays alive). Without counting them, the Telegram ack lies with
+// "no agents connected" even when a bridge is actively listening.
+function sseSubscribersForTag(tag) {
+    let n = 0;
+    for (const c of inboxStreamClients) {
+        if (c.res.destroyed || c.res.writableEnded || !c.res.writable)
+            continue;
+        if (tag && c.tag !== tag)
+            continue;
+        n++;
+    }
+    return n;
+}
 // Synchronous best-effort liveness check before we count sessions in an ack.
 // The transport's SDK doesn't expose a "ping" API, but it does hold a ref to
 // the response stream of the last GET the client opened — if that stream is
@@ -1922,6 +2287,13 @@ function sessionDisplay(s) {
     return s.tag ? `@${s.tag}` : s.clientId;
 }
 app.all("/mcp", async (req, res) => {
+    if (!ENABLE_MCP) {
+        res.status(404).json({
+            error: "mcp_disabled",
+            message: "MCP transport is disabled. Set ENABLE_MCP=1 to enable /mcp.",
+        });
+        return;
+    }
     console.log("[debug-url]", req.method, req.url, "query:", JSON.stringify(req.query), "ua:", req.headers["user-agent"]);
     const existingSessionId = req.headers["mcp-session-id"];
     if (existingSessionId && httpTransports[existingSessionId]) {
@@ -2055,8 +2427,14 @@ function trackReconnect(clientId) {
 const httpServer = app.listen(PORT, "0.0.0.0", () => {
     const ip = getLocalIp();
     console.log(`\n  Claude Notify config UI  → http://localhost:${PORT}`);
-    console.log(`  MCP endpoint (remote)    → http://${ip}:${PORT}/mcp\n`);
+    if (ENABLE_MCP) {
+        console.log(`  MCP endpoint (remote)    → http://${ip}:${PORT}/mcp\n`);
+    }
+    else {
+        console.log("  MCP endpoint (remote)    → disabled (set ENABLE_MCP=1 to enable)\n");
+    }
     startTelegramListener();
+    startSlackListener();
     open(`http://localhost:${PORT}`).catch(() => { });
 });
 // TCP-level keepalive on every incoming socket. Without this, a client that

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-notify-mcp",
-  "version": "1.3.7",
+  "version": "1.3.11",
   "description": "An MCP server that lets AI agents (Claude, Cursor, etc.) reach you on any channel — desktop, Telegram, SMS, email — with two-way ask/reply, real-time inbox push, Do Not Disturb, idle gating, multi-session routing, and a one-page web UI for setup. Zero config code; configure once, agents call notify/ask.",
   "main": "dist/index.js",
   "type": "module",

package/ui/public/app.js

@@ -83,7 +83,7 @@ function populateForm() {
   $("ntfy-enabled").checked = !!ntfy.enabled;
   $("ntfy-topic").value = ntfy.topic ?? "";
   const defaultUrl = `${location.protocol}//${location.hostname}:${location.port || (location.protocol === 'https:' ? 443 : 80)}`;
-  $("ntfy-server-url").value = ntfy.serverUrl || defaultUrl;
+  $("ntfy-server-url").value = (ntfy.serverUrl || defaultUrl).replace(/\/ntfy\/?$/, "");
 
   // Discord
   const dc = config.discord ?? {};

package/ui/public/help.html

@@ -40,7 +40,7 @@
       <div class="tabs">
         <button class="tab tab-active" data-tab="claude-code">Claude Code (CLI)</button>
         <button class="tab" data-tab="cursor">Cursor</button>
-        <button class="tab" data-tab="vscode">VS Code</button>
+        <button class="tab" data-tab="vscode">VS Code + Copilot</button>
         <button class="tab" data-tab="claude-desktop">Claude Desktop</button>
         <button class="tab" data-tab="windsurf">Windsurf</button>
         <button class="tab" data-tab="zed">Zed</button>
@@ -125,6 +125,7 @@
 }</code></pre>
         </div>
         <p class="hint">Or via Command Palette → <em>MCP: Add Server</em> → npm package → <code>omni-notify-mcp</code>.</p>
+        <p class="hint"><strong>Important for GitHub Copilot Chat/Agent:</strong> Copilot can miss server-pushed notifications. For reliable inbound user messages, the agent should loop on <code>wait_for_inbox(timeout_seconds=50)</code> and handle tool results immediately.</p>
       </div>
 
       <!-- Claude Desktop -->
@@ -230,16 +231,18 @@
 
     <section class="help-section">
       <h2>What the AI gets</h2>
-      <p>Six tools, all server-configured. The agent never names a channel — it just calls <code>notify</code>/<code>ask</code> and your settings decide where it goes:</p>
+      <p>Eight tools, all server-configured. The agent never names a channel — it just calls <code>notify</code>/<code>ask</code> and your settings decide where it goes:</p>
       <table class="tools-table">
         <tr><td><code>notify</code></td><td>Send a message. <code>priority=low|normal|high</code> controls fan-out and bypasses DND when high.</td></tr>
         <tr><td><code>ask</code></td><td>Send a question and <strong>wait for your reply</strong> (Telegram or email link).</td></tr>
         <tr><td><code>poll</code></td><td>Drain unsolicited messages you sent the agent.</td></tr>
+        <tr><td><code>wait_for_inbox</code></td><td>Long-poll up to 50s and return immediately when a new inbound user message exists.</td></tr>
         <tr><td><code>get_idle_seconds</code></td><td>Seconds since your last keyboard/mouse input.</td></tr>
         <tr><td><code>get_idle_config</code></td><td>The server's idle-gating policy.</td></tr>
         <tr><td><code>get_dnd_status</code></td><td>Whether Do Not Disturb is currently suppressing.</td></tr>
+        <tr><td><code>reply</code></td><td>Channel return-path for stdio clients that support pushed channel events.</td></tr>
       </table>
-      <p class="hint">Well-behaved agents pre-flight with <code>get_idle_seconds</code> and skip the notif entirely if you're at the keyboard. The MCP <code>instructions</code> field tells every connecting client this — no per-prompt prodding required.</p>
+      <p class="hint">For Copilot, treat <code>wait_for_inbox</code> as the primary inbound path. Keep a tight loop and process every non-empty result before continuing long tasks.</p>
     </section>
 
     <section class="help-section">