omni-notify-mcp 1.3.14 → 1.3.21

package/dist/ui/server.js

@@ -12,16 +12,15 @@ import notifier from "node-notifier";
 import nodemailer from "nodemailer";
 import { PinpointSMSVoiceV2Client, SendTextMessageCommand, DescribePhoneNumbersCommand, DescribeVerifiedDestinationNumbersCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2";
 import { tmpdir } from "os";
-import { sendWithRouting } from "./messaging/notificationEngine.js";
+import { sendWithRouting, idleReading, formatIdleReading, describePriorityRouting } from "./messaging/notificationEngine.js";
 import { z } from "zod";
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 const PORT = process.env.PORT ? parseInt(process.env.PORT) : 3737;
 const REDIRECT_URI = `http://localhost:${PORT}/auth/google/callback`;
 const SLACK_REDIRECT_URI = `http://localhost:${PORT}/auth/slack/callback`;
-// Bot scopes requested during the one-click OAuth connect. chat:write.public
-// lets the bot post to public channels without being invited first.
-const SLACK_OAUTH_SCOPES = "channels:read,groups:read,chat:write,chat:write.public";
+// GATE: the Slack methods a one-click bot token may call — conversations.list (channel picker), conversations.history (bus poller), chat.postMessage (notifications, public channels without an invite); a method outside this set answers missing_scope
+const SLACK_OAUTH_SCOPES = "channels:read,groups:read,channels:history,groups:history,chat:write,chat:write.public";
 const DISCORD_REDIRECT_URI = `http://localhost:${PORT}/auth/discord/callback`;
 // webhook.incoming makes Discord return a ready-to-use channel webhook on Authorize.
 const DISCORD_OAUTH_SCOPE = "webhook.incoming";
@@ -38,7 +37,6 @@ function defaultConfig() {
         disabledClients: [],
         desktop: { enabled: false, sound: true },
         telegram: { enabled: false, token: "", chatIds: [] },
-        whatsapp: { enabled: false, instanceId: "", apiToken: "", phone: "" },
         sms: { enabled: false, accessKeyId: "", secretAccessKey: "", region: "us-east-1", originationNumber: "", to: [] },
         email: { enabled: false, to: "" },
         ntfy: { enabled: false, topic: "", serverUrl: "" },
@@ -140,6 +138,15 @@ function displayTag(tag) {
     return clientAliasMap()[tag] || tag;
 }
 const MASKED = "••••••••";
+// Credentials and secrets are runtime state, never source-relative: under a
+// global/`npx` install the compiled server lives in a package directory that
+// contains no secrets file at all, so the file MUST be found by the same
+// CONFIG_DIR resolution the config uses. `NOTIFY_MCP_SECRETS_PATH` overrides.
+const SECRETS_PATH = process.env.NOTIFY_MCP_SECRETS_PATH
+    || join(CONFIG_DIR, "notify-secrets.json");
+// Backward compatibility for an existing per-user install: older builds,
+// `setup-secrets.sh` and the README all placed the file at `~/.notify-mcp-secrets`.
+const LEGACY_SECRETS_PATH = join(homedir(), ".notify-mcp-secrets");
 // AWS SendTextMessage requires E.164 (e.g. +14089812202) — strip spaces, dashes,
 // parens, dots so a user-entered "+1 408 981 2202" is accepted.
 function e164(s) {
@@ -159,8 +166,6 @@ function maskSecrets(config) {
         c.sms.secretAccessKey = MASKED;
     if (c.telegram?.token)
         c.telegram.token = MASKED;
-    if (c.whatsapp?.apiToken)
-        c.whatsapp.apiToken = MASKED;
     if (c.discord?.webhookUrl)
         c.discord.webhookUrl = MASKED;
     if (c.discord?.clientSecret)
@@ -173,11 +178,12 @@ function maskSecrets(config) {
         c.slack.clientSecret = MASKED;
     if (c.teams?.webhookUrl)
         c.teams.webhookUrl = MASKED;
+    delete c.whatsapp;
     return c;
 }
 function mergePreservingSecrets(existing, update) {
     const merged = { ...defaultConfig(), ...existing };
-    for (const section of ["desktop", "telegram", "whatsapp", "sms", "email", "ntfy", "discord", "slack", "teams", "dnd", "idle"]) {
+    for (const section of ["desktop", "telegram", "sms", "email", "ntfy", "discord", "slack", "teams", "dnd", "idle"]) {
         merged[section] = { ...(merged[section] || {}), ...(update[section] || {}) };
     }
     // Nested schedule inside dnd
@@ -198,7 +204,6 @@ function mergePreservingSecrets(existing, update) {
     guard(["email", "accessToken"]);
     guard(["sms", "secretAccessKey"]);
     guard(["telegram", "token"]);
-    guard(["whatsapp", "apiToken"]);
     guard(["discord", "webhookUrl"]);
     guard(["discord", "clientSecret"]);
     guard(["slack", "webhookUrl"]);
@@ -605,27 +610,6 @@ app.get("/api/telegram/chats", async (req, res) => {
         res.status(500).json({ error: String(err) });
     }
 });
-app.post("/api/test/whatsapp", async (_req, res) => {
-    const config = loadConfig();
-    const { instanceId, apiToken, phone } = config.whatsapp ?? {};
-    if (!instanceId || !apiToken || !phone) {
-        res.status(400).json({ error: "Instance ID, API token and phone are required." });
-        return;
-    }
-    try {
-        const r = await fetch(`https://api.green-api.com/waInstance${instanceId}/sendMessage/${apiToken}`, {
-            method: "POST",
-            headers: { "Content-Type": "application/json" },
-            body: JSON.stringify({ chatId: `${phone}@c.us`, message: "Test from Claude Notify — WhatsApp is working!" }),
-        });
-        if (!r.ok)
-            throw new Error(`Green API ${r.status}: ${await r.text()}`);
-        res.json({ ok: true, message: "WhatsApp message sent!" });
-    }
-    catch (err) {
-        res.status(500).json({ error: String(err) });
-    }
-});
 app.post("/api/test/sms", async (_req, res) => {
     const config = loadConfig();
     const { accessKeyId, secretAccessKey, region, originationNumber, to } = config.sms ?? {};
@@ -1452,19 +1436,30 @@ app.get("/api/logs", (req, res) => {
     logClients.add(res);
     req.on("close", () => logClients.delete(res));
 });
-// ── Notification sender ───────────────────────────────────────────────────────
 async function sendNotification(message, priority, client) {
     const cfg = loadConfig();
     if (cfg.muteAll === true) {
-        log("·", "notify", `suppressed — all notifications disabled (master mute), priority=${priority}`, client);
-        return "Suppressed — all notifications are disabled (master mute is ON).";
+        log("·", "notify", `BLOCKED — all notifications disabled (master mute), priority=${priority}`, client);
+        return {
+            outcome: "blocked",
+            attempted: [],
+            delivered: [],
+            errors: [],
+            text: "BLOCKED — master mute is ON, so nothing was sent anywhere.",
+        };
     }
     if (client && Array.isArray(cfg.disabledClients) && cfg.disabledClients.includes(client)) {
-        log("·", "notify", `suppressed — client '${client}' is disabled, priority=${priority}`, client);
-        return `Suppressed — this client ('${client}') is disabled in BullseyeNotify.`;
+        log("·", "notify", `BLOCKED — client '${client}' is disabled, priority=${priority}`, client);
+        return {
+            outcome: "blocked",
+            attempted: [],
+            delivered: [],
+            errors: [],
+            text: `BLOCKED — this client ('${client}') is disabled in BullseyeNotify, so nothing was sent anywhere.`,
+        };
     }
     const inTelegramConvo = Date.now() - lastTelegramInboundAt < TELEGRAM_CONVO_TTL_MS;
-    const idleSecs = getOsIdleSeconds();
+    const idle = idleReading(getOsIdleSeconds());
     const result = await sendWithRouting({
         message,
         priority,
@@ -1477,7 +1472,7 @@ async function sendNotification(message, priority, client) {
         ctx: {
             inTelegramConversation: inTelegramConvo,
             uiActive: isUiActivelyOpen(),
-            idleSeconds: idleSecs,
+            idle,
         },
         enableDesktop: !!cfg.desktop?.enabled,
         enableTelegram: !!(cfg.telegram?.enabled && cfg.telegram.token && cfg.telegram.chatIds?.length),
@@ -1681,8 +1676,14 @@ async function sendNotification(message, priority, client) {
         },
     });
     if (result.suppressedReason) {
-        log("·", "notify", `suppressed (${result.suppressedReason})`, client);
-        return result.suppressedReason;
+        log("·", "notify", `suppressed (${result.suppressedReason}) — ${result.summary}`, client);
+        return {
+            outcome: "blocked",
+            attempted: [],
+            delivered: [],
+            errors: [],
+            text: result.summary,
+        };
     }
     for (const delivered of result.delivered) {
         log("→", delivered, message, client);
@@ -1690,20 +1691,31 @@ async function sendNotification(message, priority, client) {
     for (const err of result.errors) {
         log("→", "notify", `ERROR: ${err}`, client);
     }
-    return [
-        result.delivered.length ? `Sent via: ${result.delivered.join(", ")}` : null,
-        result.errors.length ? `Errors: ${result.errors.join("; ")}` : null,
-    ].filter(Boolean).join(" | ") || "No channels delivered";
+    if (result.outcome === "failed") {
+        log("→", "notify", `NOT DELIVERED — ${result.summary}`, client);
+    }
+    return {
+        outcome: result.outcome === "failed" ? "failed" : "delivered",
+        attempted: result.attempted,
+        delivered: result.delivered,
+        errors: result.errors,
+        text: result.summary,
+    };
 }
-// ── OS idle-time (cross-platform) ─────────────────────────────────────────────
-// Returns seconds since last keyboard/mouse input. -1 on error/unsupported.
-// Clients call the `get_idle_seconds` tool and decide whether to fire a notif.
+// PowerShell is invoked with -ExecutionPolicy Bypass: the default policy on a
+// stock Windows box is Restricted, which refuses any .ps1 outright (measured:
+// `-File` exits 1, `"running scripts is disabled on this system"`), so the
+// bundled probe could not run at all and every caller saw the -1 sentinel. Only
+// this one script is exempted — the machine's own policy is untouched.
 const IDLE_SCRIPT_PS1 = join(fileURLToPath(new URL("../../scripts/idle-check.ps1", import.meta.url)));
+// Returns seconds since last keyboard/mouse input, or -1 when the read did not
+// happen. Callers MUST convert with `idleReading()` — -1 is a sentinel, never a
+// measurement, and comparing it against a threshold silently reads as "active".
 function getOsIdleSeconds() {
     try {
         if (process.platform === "win32") {
             // PowerShell + Win32 GetLastInputInfo via bundled script
-            const r = spawnSync("powershell", ["-NoProfile", "-File", IDLE_SCRIPT_PS1], {
+            const r = spawnSync("powershell", ["-NoProfile", "-ExecutionPolicy", "Bypass", "-File", IDLE_SCRIPT_PS1], {
                 encoding: "utf-8", windowsHide: true,
             });
             if (r.status === 0) {
@@ -1904,6 +1916,20 @@ function ingestInboxEntry(entry, source) {
     log("·", "inbox", `${source}: ${entry.text} (sse=${sse}, waiters=${waiters.length})`, entry.tag);
     return { waiters: waiters.length, sse };
 }
+function ingestTelegramEntry(entry) {
+    const { waiters } = ingestInboxEntry(entry, "telegram");
+    const sseCount = sseSubscribersForTag(entry.tag);
+    const listening = sseCount > 0 || waiters > 0;
+    // NULL-OK: field tag is OPTIONAL and therefore it is ok to check for NULL
+    if (entry.tag) {
+        return listening
+            ? `📬 Routed to @${entry.tag}. Waiting for reply.`
+            : `📭 No session @${entry.tag} connected. Message queued — next @${entry.tag} to connect will pick it up.`;
+    }
+    return listening
+        ? `📬 Broadcast to ${sseCount} listener${sseCount === 1 ? "" : "s"}. Waiting for reply.`
+        : "📭 No agents connected. Message queued — next agent to connect will pick it up.";
+}
 // 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
@@ -1923,7 +1949,15 @@ if (process.env.NOTIFY_MCP_TEST_ENDPOINTS === "1") {
     app.get("/__test__/slack-clients", (_req, res) => {
         res.json({ tags: slackClientTags(), numbered: slackClientsNumbered() });
     });
-    log("·", "test", "NOTIFY_MCP_TEST_ENDPOINTS=1 — /__test__/inject-inbox + /__test__/slack-clients enabled");
+    app.post("/__test__/telegram-inbox", express.json(), (req, res) => {
+        if (typeof req.body?.text !== "string") {
+            res.status(400).json({ error: "text required" });
+            return;
+        }
+        const { tag, text } = parseTag(req.body.text);
+        res.json({ ack: ingestTelegramEntry({ text, ts: new Date().toISOString(), tag }) });
+    });
+    log("·", "test", "NOTIFY_MCP_TEST_ENDPOINTS=1 — /__test__/inject-inbox + /__test__/slack-clients + /__test__/telegram-inbox enabled");
 }
 app.get("/api/inbox/stream", (req, res) => {
     res.setHeader("Content-Type", "text/event-stream");
@@ -1966,10 +2000,17 @@ app.post("/api/agent/notify", async (req, res) => {
     }
     try {
         const out = await sendNotification(message, priority, "agent-http");
-        res.json({ ok: true, result: out });
+        res.status(out.outcome === "delivered" ? 200 : 502).json({
+            ok: out.outcome === "delivered",
+            outcome: out.outcome,
+            attempted: out.attempted,
+            delivered: out.delivered,
+            errors: out.errors,
+            result: out.text,
+        });
     }
     catch (err) {
-        res.status(500).json({ error: err instanceof Error ? err.message : String(err) });
+        res.status(500).json({ ok: false, outcome: "failed", error: err instanceof Error ? err.message : String(err) });
     }
 });
 app.get("/api/agent/inbox/poll", (req, res) => {
@@ -2226,39 +2267,7 @@ async function startTelegramListener() {
                         const entry = {
                             text, ts: new Date().toISOString(), messageId: msg.message_id, tag,
                         };
-                        // Waiters (wait_for_inbox long-poll) get first crack — they were
-                        // already parked by an agent explicitly asking "wake me up when
-                        // something arrives." Hand the entry off as a tool *result*, which
-                        // every MCP client actually surfaces. Only queue if no one was
-                        // waiting, so the message isn't delivered twice.
-                        const waiters = takeWaitersFor(tag);
-                        if (waiters.length > 0) {
-                            for (const w of waiters) {
-                                clearTimeout(w.timer);
-                                w.resolve([entry]);
-                            }
-                            log("·", "inbox", `${text} → ${waiters.length} long-poll waiter(s)`, tag);
-                        }
-                        else {
-                            inboxQueue.push(entry);
-                        }
-                        writeInboxDrop(entry);
-                        const liveSseCount = broadcastInbox(entry);
-                        log("·", "inbox", `${text} (sse=${liveSseCount}, waiters=${waiters.length})`, tag);
-                        const sseCount = sseSubscribersForTag(tag);
-                        const anyoneListening = sseCount > 0 || waiters.length > 0;
-                        let ackText;
-                        if (!anyoneListening && tag) {
-                            ackText = `📭 No session @${tag} connected. Message queued — next @${tag} to connect will pick it up.`;
-                        }
-                        else if (!anyoneListening) {
-                            ackText = `📭 No agents connected. Message queued — next agent to connect will pick it up.`;
-                        }
-                        else {
-                            ackText = tag
-                                ? `📬 Routed to @${tag}. Waiting for reply.`
-                                : `📬 Broadcast to ${sseCount} listener${sseCount === 1 ? "" : "s"}. Waiting for reply.`;
-                        }
+                        const ackText = ingestTelegramEntry(entry);
                         fetch(`https://api.telegram.org/bot${token}/sendMessage`, {
                             method: "POST", headers: { "Content-Type": "application/json" },
                             body: JSON.stringify({
@@ -2284,7 +2293,6 @@ 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);
@@ -2300,17 +2308,36 @@ function decodeB64Fields(obj) {
     }
     return obj;
 }
+async function sendNotificationSummary(message, priority, client) {
+    const out = await sendNotification(message, priority, client);
+    return out.text;
+}
 function loadSecrets() {
-    if (!existsSync(SLACK_SECRETS_PATH))
+    const path = secretsFilePath();
+    if (!path)
         return {};
     try {
-        return decodeB64Fields(JSON.parse(readFileSync(SLACK_SECRETS_PATH, "utf8")));
+        return decodeB64Fields(JSON.parse(readFileSync(path, "utf8")));
     }
     catch (err) {
-        log("·", "secrets", `load failed: ${err instanceof Error ? err.message : String(err)}`);
-        return {};
+        throw new SecretsUnreadable(path, err);
+    }
+}
+// A secrets file that EXISTS but cannot be read is a hard defect, not an empty
+// result: the caller would otherwise import nothing and believe the user has no
+// credentials, which is the silent-escalation failure this file exists to stop.
+class SecretsUnreadable extends Error {
+    constructor(path, cause) {
+        super(`secrets file at ${path} exists but could not be read: ${cause instanceof Error ? cause.message : String(cause)}`);
     }
 }
+function secretsFilePath() {
+    if (existsSync(SECRETS_PATH))
+        return SECRETS_PATH;
+    if (existsSync(LEGACY_SECRETS_PATH))
+        return LEGACY_SECRETS_PATH;
+    return undefined;
+}
 function slackCreds() {
     const s = loadSecrets().slack ?? {};
     const cfgSlack = loadConfig().slack ?? {};
@@ -2319,20 +2346,34 @@ function slackCreds() {
     const webhook = (s.webhookUrl ?? cfgSlack.webhookUrl ?? "").trim() || undefined;
     return { token, channel, webhook };
 }
-// Brainless config: on startup, copy any credentials already present in
-// notify-secrets.json (decoded) into config.json's EMPTY fields, so a user who
-// has the shared secrets file gets every channel pre-wired without touching the
-// UI. Never overwrites a value the user already set. Idempotent.
+// Brainless config: on startup, copy any credentials already present in the
+// secrets file (decoded) into config.json's EMPTY fields, so a user who has the
+// shared secrets file gets every channel pre-wired without touching the UI.
+// Never overwrites a value the user already set. Idempotent. Reports which
+// channel names were filled — a name list only, never a value.
+//
+// OWNER: a secrets file that exists but cannot be read must be REPORTED, not
+// treated as "no credentials" — silent absence is how every escalation reached
+// nobody. The recourse is an explicit LOUD line naming the file and the parse
+// error, so a channel-left-off is diagnosable from the console; the process
+// still boots, because a broken secrets file must not take the whole server
+// down. Nothing propagates from this catch.
 function importCredsOnStart() {
     let secrets;
     try {
         secrets = loadSecrets();
     }
-    catch {
+    catch (err) {
+        log("·", "secrets", `UNREADABLE — ${err instanceof Error ? err.message : String(err)}. No credentials were imported, so every channel stays as configured.`);
         return;
     }
-    if (!secrets || Object.keys(secrets).length === 0)
+    const filled = [];
+    if (Object.keys(secrets).length === 0) {
+        log("·", "import", secretsFilePath()
+            ? "secrets file is present but holds no credentials — nothing to import"
+            : `no secrets file at ${SECRETS_PATH} (set NOTIFY_MCP_SECRETS_PATH to point at one) — nothing to import`);
         return;
+    }
     const cfg = loadConfig();
     let changed = false;
     const fill = (sec, key, val) => {
@@ -2342,6 +2383,7 @@ function importCredsOnStart() {
         if (cfg[sec][key] === undefined || cfg[sec][key] === "") {
             cfg[sec][key] = val;
             changed = true;
+            filled.push(`${sec}.${key}`);
         }
     };
     const fillArrayFromScalar = (sec, arrKey, val) => {
@@ -2351,8 +2393,18 @@ function importCredsOnStart() {
         if (!Array.isArray(cfg[sec][arrKey]) || cfg[sec][arrKey].length === 0) {
             cfg[sec][arrKey] = [String(val)];
             changed = true;
+            filled.push(`${sec}.${arrKey}`);
         }
     };
+    const enableIfPopulated = (sec, required) => {
+        if (cfg[sec]?.enabled === true)
+            return;
+        if (!required.every((k) => { const v = cfg[sec]?.[k]; return Array.isArray(v) ? v.length > 0 : (v !== undefined && v !== null && v !== ""); }))
+            return;
+        cfg[sec].enabled = true;
+        changed = true;
+        filled.push(`${sec}.enabled`);
+    };
     if (secrets.telegram) {
         fill("telegram", "token", secrets.telegram.token);
         fillArrayFromScalar("telegram", "chatIds", secrets.telegram.chatId);
@@ -2372,14 +2424,22 @@ function importCredsOnStart() {
     if (secrets.sms) {
         for (const k of ["accessKeyId", "secretAccessKey", "region", "originationNumber"])
             fill("sms", k, secrets.sms[k]);
-        if (secrets.sms.enabled && cfg.sms?.accessKeyId && cfg.sms.enabled !== true) {
-            cfg.sms.enabled = true;
-            changed = true;
-        }
     }
+    // Credentials that reach config.json but leave the channel switched off are
+    // invisible: the routing reads `enabled`, so imported creds alone still send
+    // to nobody. Free channels are switched on when fully populated; a channel
+    // that reaches a real phone (SMS) or a real inbox (email) stays the user's
+    // explicit opt-in, exactly as the shipped config.example.json has it.
+    enableIfPopulated("desktop", []);
+    enableIfPopulated("telegram", ["token", "chatIds"]);
+    enableIfPopulated("slack", ["channels"]);
+    enableIfPopulated("ntfy", ["topic"]);
     if (changed) {
         saveConfig(cfg);
-        log("·", "import", "imported credentials from notify-secrets.json into config.json (empty fields only)");
+        log("·", "import", `imported from ${secretsFilePath()} into ${CONFIG_PATH} (empty fields only): ${filled.join(", ")}`);
+    }
+    else {
+        log("·", "import", "secrets file present but every config field it maps to is already set — nothing imported");
     }
 }
 async function slackPost(text) {
@@ -2525,17 +2585,17 @@ async function startSlackListener() {
 }
 app.get("/reply/:token", (req, res) => {
     const pending = pendingAsks.get(req.params.token);
-    res.send(`<!DOCTYPE html><html><head><title>Reply to Claude</title>
-<style>body{font-family:sans-serif;background:#0a0a0b;color:#f0f0f0;display:flex;align-items:center;justify-content:center;height:100vh;margin:0}
-.box{background:#111113;border:1px solid #222226;border-radius:9px;padding:24px;max-width:500px;width:90%}
-h2{color:#7c6dfa;margin:0 0 16px}textarea{width:100%;background:#0d0d10;border:1px solid #222226;border-radius:7px;color:#f0f0f0;padding:8px;font-size:14px;resize:vertical;min-height:80px;box-sizing:border-box}
-button{background:#7c6dfa;color:white;border:none;border-radius:7px;padding:8px 20px;font-size:14px;cursor:pointer;margin-top:10px}
-.ok{color:#10b981;margin-top:12px}.err{color:#ef4444}</style></head>
+    res.send(`<!DOCTYPE html><html><head><title>Reply to Claude</title>
+<style>body{font-family:sans-serif;background:#0a0a0b;color:#f0f0f0;display:flex;align-items:center;justify-content:center;height:100vh;margin:0}
+.box{background:#111113;border:1px solid #222226;border-radius:9px;padding:24px;max-width:500px;width:90%}
+h2{color:#7c6dfa;margin:0 0 16px}textarea{width:100%;background:#0d0d10;border:1px solid #222226;border-radius:7px;color:#f0f0f0;padding:8px;font-size:14px;resize:vertical;min-height:80px;box-sizing:border-box}
+button{background:#7c6dfa;color:white;border:none;border-radius:7px;padding:8px 20px;font-size:14px;cursor:pointer;margin-top:10px}
+.ok{color:#10b981;margin-top:12px}.err{color:#ef4444}</style></head>
 <body><div class="box">${pending
-        ? `<h2>Reply to Claude</h2><textarea id="r" placeholder="Type your response…"></textarea>
-       <button onclick="send()">Send</button><div id="s"></div>
-       <script>async function send(){const r=document.getElementById('r').value.trim();if(!r)return;
-       const res=await fetch('/reply/${req.params.token}',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({response:r})});
+        ? `<h2>Reply to Claude</h2><textarea id="r" placeholder="Type your response…"></textarea>
+       <button onclick="send()">Send</button><div id="s"></div>
+       <script>async function send(){const r=document.getElementById('r').value.trim();if(!r)return;
+       const res=await fetch('/reply/${req.params.token}',{method:'POST',headers:{'Content-Type':'application/json'},body:JSON.stringify({response:r})});
        const el=document.getElementById('s');el.textContent=res.ok?'✓ Sent!':'Error';el.className=res.ok?'ok':'err';}</script>`
         : `<h2>Expired</h2><p class="err">This link has already been used or timed out.</p>`}</div></body></html>`);
 });
@@ -2574,171 +2634,190 @@ function appendInbox(baseText, sessionTag, clientId) {
     const inbox = messages.map(m => `[${m.ts}] ${m.text}`).join("\n");
     return `${baseText}\n\n⚠️ USER SENT YOU A MESSAGE — STOP AND RESPOND BEFORE CONTINUING:\n${inbox}`;
 }
-const MCP_INSTRUCTIONS = `
-This server delivers notifications to the user through whatever channels the
-user has configured on the server side. The client never needs to know which
-channels are in use — just call 'notify' or 'ask' with a generic message.
-
-BEHAVIORAL RULES for every client that connects:
-
-1. ALWAYS call 'notify' in these three situations — idle or not, DND or not,
-   the server decides routing, you decide whether to fire:
-
-   (a) LONG PROCESSING FINISHED. Any single task that took more than ~60
-       seconds of wall-clock time (long build, test run, backtest, migration,
-       big refactor, multi-step plan) gets a 'notify' the moment it completes
-       — success OR failure. Rule of thumb: if the user could have reasonably
-       walked away to grab coffee while you ran, they need a ping on the way
-       back. Don't try to guess whether they were watching. Just notify.
-
-   (b) YOU HAVE A QUESTION OR NEED A DECISION. Any time you're about to ask
-       the user something — "should I delete these?", "which branch?",
-       "proceed with plan B?" — fire 'notify' (or 'ask' for blocking
-       two-way). Silent questions in the terminal get missed; a notification
-       does not.
-
-   (c) SOMETHING IMPORTANT HAPPENED that the user needs to know about right
-       now. Examples: a test suddenly failed after being green, a destructive
-       operation is about to run, you found a security issue, a deploy
-       succeeded, a production service looks degraded, you hit an
-       unrecoverable error. When in doubt on importance, ERR ON THE SIDE OF
-       NOTIFYING — the server's idle gating will automatically downgrade a
-       mis-judged 'normal' to a silent desktop banner if the user is active,
-       so the cost of over-notifying is near zero. The cost of missing a
-       real event is that the user finds out 4 hours later.
-
-   The SERVER handles all routing (DND, idle threshold, channel selection,
-   priority escalation). You do NOT need to pre-flight with
-   'get_idle_seconds' before these three triggers — fire 'notify' and let
-   the server decide. get_idle_seconds is the HEARTBEAT primitive (rule 6),
-   not a gate on legitimate milestones.
-
-2. Use priority correctly:
-   - 'low'    = email only — for low-stakes status (background completion).
-   - 'normal' = desktop + Telegram + email — the default.
-   - 'high'   = all channels including SMS — bypasses DND AND idle gating.
-                Use ONLY for catastrophic findings or decisions that block
-                progress. Misuse will train the user to ignore your notifs.
-
-3. Echo the COMPLETE, UNTRUNCATED message body in your own chat / conversation
-   output as well as sending it through 'notify'. The user may be reading the
-   terminal directly; don't rely on them checking their phone / email. Do NOT
-   shorten, summarise, or cut off the message with "…" in your chat output —
-   show every word exactly as sent.
-
-4. The message body should be channel-agnostic. Never name 'Telegram', 'SMS',
-   'email', 'desktop', etc. in your messages or in your chat output — those are
-   server delivery details the user has already configured and the client has
-   no business surfacing. Do NOT echo "Sent via: <channel list>" or any
-   variant of it. Just say 'notif' or 'notification' if you need to refer to
-   the act of notifying.
-
-5. When the user sends you an unsolicited message (visible as INBOX items in
-   the 'notify' response, via 'poll', via 'wait_for_inbox', via
-   'get_idle_seconds' piggy-back, or via the /api/inbox/stream SSE), reply to
-   them THROUGH 'notify' so the reply
-   actually reaches them — not just in your chat output. Multiple agents may
-   be connected simultaneously — the server broadcasts every untagged inbox
-   message to all of them, so the user can see who is listening. Your reply
-   MUST identify which session you are (start with your own tag or client id,
-   e.g. "[@alphawave]" or "[sess-abcd]") and give a brief status so the user
-   can pick whom to respond to. If the user tagged their message (@<tag>),
-   only the session with that tag should reply. If you are untagged and
-   another session with the same project/workdir is already tagged, let the
-   tagged one reply.
-
-5a. BUSY-ACK RULE (hard requirement): The moment you notice a user inbox
-    message — whether via notify response, heartbeat piggy-back, or poll —
-    REPLY IMMEDIATELY via 'notify' with a terse status, EVEN IF YOU CAN'T
-    ACT ON THE REQUEST YET. Do not finish the current tool/task first.
-    Drop what you're doing long enough to fire one 'notify' call, THEN
-    resume. Format: "[<your-session-id>] busy on <current-task>; will
-    respond at <milestone>". The user needs to know (a) you heard them,
-    (b) you're not the stuck one, (c) when to expect a real answer. An
-    inbox message that gets a delayed reply is worse than no reply — it
-    wastes the user's time waiting on silence.
-
-6. The 'get_idle_seconds', 'get_idle_config', and 'get_dnd_status' tools are
-   informational reads, but they ALSO drain pending inbox messages. Use them
-   as a cheap heartbeat during long work: call 'get_idle_seconds' EVERY 15-
-   30 SECONDS while a long task runs (loop iteration, backtest, scan, build,
-   etc.). If the user sent you a message while you were busy, it comes back
-   piggy-backed on the response — you don't need to separately call 'poll'.
-   This is a lightweight local read (no network, no DND or channel routing),
-   so the cost is near zero. Without this heartbeat pattern, a busy agent is
-   deaf to the user until its next 'notify' call — which may be minutes or
-   hours away during long work. Treat 'get_idle_seconds' as the "check for
-   user input" primitive, not an idle-gate check.
-
-   If your work is naturally idle (waiting for the user, between loop iters),
-   prefer 'wait_for_inbox' instead — it blocks up to 50s and returns the
-   moment the user types anything, as a tool result. That's the most reliable
-   delivery path across every MCP client (notifications over SSE are silently
-   dropped by Claude Code, Cursor, and others). Loop pattern:
-     while (true) {
-       const r = await wait_for_inbox({ timeout_seconds: 50 });
-       if (r !== "inbox:empty") handle(r);
-     }
-
-7. If your tool call fails with "MCP server not connected" / "transport
-   closed" / similar — the SERVER IS ALMOST CERTAINLY FINE. Other clients are
-   connected to the same server right now. Only YOUR client's transport
-   broke (commonly: stdio child process died, or HTTP client gave up after a
-   transient slow response at startup). DO NOT tell the user "notify is down"
-   without first probing the server directly.
-
-   Probe before declaring the server dead:
-     curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3737/mcp
-   - 406 (Not Acceptable) = server is healthy, doing MCP protocol
-     negotiation. Your client is the broken party. Use the bypass below.
-   - Connection refused / timeout = server is genuinely down. Tell the user.
-
-   HTTP-transport bypass when your MCP client is broken (works from any
-   shell that has curl). Three calls, stateful — the session id from step 1
-   must be passed in mcp-session-id on every subsequent call:
-
-     # 1) initialize and capture session id from response headers
-     SID=$(curl -s -i -X POST http://localhost:3737/mcp \
-       -H "Content-Type: application/json" \
-       -H "Accept: application/json, text/event-stream" \
-       -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"curl-bridge","version":"1.0"}}}' \
-       | grep -i "^mcp-session-id:" | awk '{print $2}' | tr -d '\r')
-
-     # 2) ack initialized (no response body, fire-and-forget)
-     curl -s -X POST http://localhost:3737/mcp \
-       -H "Content-Type: application/json" \
-       -H "Accept: application/json, text/event-stream" \
-       -H "mcp-session-id: $SID" \
-       -d '{"jsonrpc":"2.0","method":"notifications/initialized"}' >/dev/null
-
-     # 3) call any tool — successful response includes "Sent via: <channel>"
-     curl -s -X POST http://localhost:3737/mcp \
-       -H "Content-Type: application/json" \
-       -H "Accept: application/json, text/event-stream" \
-       -H "mcp-session-id: $SID" \
-       -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"notify","arguments":{"message":"YOUR MESSAGE","priority":"normal"}}}'
-
-   Same pattern works for 'ask', 'poll', 'get_idle_seconds', etc. — change
-   the "name" and "arguments" in step 3. Reuse the same $SID for all calls
-   in one bypass session.
-
-   Bottom line: rule #1 still applies. If you owe the user a notify and your
-   MCP client is broken, you owe them the bypass — not an excuse.
+const MCP_INSTRUCTIONS = `
+This server is how you reach the user — and only you can decide to use it:
+nothing here delivers a message the user never asked for unless you or your
+own loop calls a tool. The channels are configured on the server side, so
+just call 'notify' or 'ask' with a generic message and let the server route
+it.
+
+BEHAVIORAL RULES for every client that connects:
+
+1. ALWAYS call 'notify' in these three situations — idle or not, DND or not,
+   the server decides routing, you decide whether to fire:
+
+   (a) LONG PROCESSING FINISHED. Any single task that took more than ~60
+       seconds of wall-clock time (long build, test run, backtest, migration,
+       big refactor, multi-step plan) gets a 'notify' the moment it completes
+       — success OR failure. Rule of thumb: if the user could have reasonably
+       walked away to grab coffee while you ran, they need a ping on the way
+       back. Don't try to guess whether they were watching. Just notify.
+
+   (b) YOU HAVE A QUESTION OR NEED A DECISION. Any time you're about to ask
+       the user something — "should I delete these?", "which branch?",
+       "proceed with plan B?" — fire 'notify' (or 'ask' for blocking
+       two-way). Silent questions in the terminal get missed; a notification
+       does not.
+
+   (c) SOMETHING IMPORTANT HAPPENED that the user needs to know about right
+       now. Examples: a test suddenly failed after being green, a destructive
+       operation is about to run, you found a security issue, a deploy
+       succeeded, a production service looks degraded, you hit an
+       unrecoverable error. When in doubt on importance, ERR ON THE SIDE OF
+       NOTIFYING — the server's idle gating automatically holds a mis-judged
+       'normal' back to local delivery while the user is active, so the
+       cost of over-notifying is near zero. The cost of missing a
+       real event is that the user finds out 4 hours later.
+
+   The SERVER handles all routing (DND, idle threshold, channel selection,
+   priority escalation). You do NOT need to pre-flight with
+   'get_idle_seconds' before these three triggers — fire 'notify' and let
+   the server decide. get_idle_seconds is the HEARTBEAT primitive (rule 6),
+   not a gate on legitimate milestones.
+
+2. Use priority correctly. Channels each priority reaches, when enabled:
+   ${describePriorityRouting()}
+   - 'low'    = low-stakes status (background completion).
+   - 'normal' = the default.
+   - 'high'   = bypasses DND AND idle gating.
+                Use ONLY for catastrophic findings or decisions that block
+                progress. Misuse will train the user to ignore your notifs.
+
+3. Echo the COMPLETE, UNTRUNCATED message body in your own chat / conversation
+   output as well as sending it through 'notify'. The user may be reading the
+   terminal directly; don't rely on them checking their phone / email. Do NOT
+   shorten, summarise, or cut off the message with "…" in your chat output —
+   show every word exactly as sent.
+
+3a. NEVER TRUNCATE — 500 CHARACTERS IS THE LIMIT ON ONE 'notify' MESSAGE.
+    A longer message goes as numbered parts — '(1/N) ...', '(2/N) ...' — in
+    separate 'notify' calls, in order, each at or under 500 characters. A
+    single call over the cap is rejected as 'too_big': that means split it,
+    never shorten it. Every fact, file path, line number and recommendation
+    the user needs must be in the parts you send — a shortened notification
+    is a defect, not a saving.
+    (The Claude Code bridge is the one exception: it accepts up to 5000
+    characters in a single call and produces those numbered parts itself, so
+    there you send the whole message and never hand-split.)
+
+4. The message body should be channel-agnostic. Never name 'Telegram', 'SMS',
+   'email', 'desktop', etc. in your messages or in your chat output — those are
+   server delivery details the user has already configured and the client has
+   no business surfacing. Do NOT echo "Sent via: <channel list>" or any
+   variant of it. Just say 'notif' or 'notification' if you need to refer to
+   the act of notifying.
+
+5. When the user sends you an unsolicited message (visible as INBOX items in
+   the 'notify' response, via 'poll', via 'wait_for_inbox', via
+   'get_idle_seconds' piggy-back, or via the /api/inbox/stream SSE), reply to
+   them THROUGH 'notify' so the reply
+   actually reaches them — not just in your chat output. Multiple agents may
+   be connected simultaneously — the server broadcasts every untagged inbox
+   message to all of them, so the user can see who is listening. Your reply
+   MUST identify which session you are (start with your own tag or client id,
+   e.g. "[@alphawave]" or "[sess-abcd]") and give a brief status so the user
+   can pick whom to respond to. If the user tagged their message (@<tag>),
+   only the session with that tag should reply. If you are untagged and
+   another session with the same project/workdir is already tagged, let the
+   tagged one reply.
+
+5a. BUSY-ACK RULE (hard requirement): The moment you notice a user inbox
+    message — whether via notify response, heartbeat piggy-back, or poll —
+    REPLY IMMEDIATELY via 'notify' with a terse status, EVEN IF YOU CAN'T
+    ACT ON THE REQUEST YET. Do not finish the current tool/task first.
+    Drop what you're doing long enough to fire one 'notify' call, THEN
+    resume. Format: "[<your-session-id>] busy on <current-task>; will
+    respond at <milestone>". The user needs to know (a) you heard them,
+    (b) you're not the stuck one, (c) when to expect a real answer. An
+    inbox message that gets a delayed reply is worse than no reply — it
+    wastes the user's time waiting on silence.
+
+6. The 'get_idle_seconds', 'get_idle_config', and 'get_dnd_status' tools are
+   informational reads, but they ALSO drain pending inbox messages. Use them
+   as a cheap heartbeat during long work: call 'get_idle_seconds' EVERY 15-
+   30 SECONDS while a long task runs (loop iteration, backtest, scan, build,
+   etc.). If the user sent you a message while you were busy, it comes back
+   piggy-backed on the response — you don't need to separately call 'poll'.
+   This is a lightweight local read (no network, no DND or channel routing),
+   so the cost is near zero. Without this heartbeat pattern, a busy agent is
+   deaf to the user until its next 'notify' call — which may be minutes or
+   hours away during long work. Treat 'get_idle_seconds' as the "check for
+   user input" primitive, not an idle-gate check.
+
+   If your work is naturally idle (waiting for the user, between loop iters),
+   prefer 'wait_for_inbox' instead — it blocks up to 50s and returns the
+   moment the user types anything, as a tool result. That's the most reliable
+   delivery path across every MCP client (notifications over SSE are silently
+   dropped by Claude Code, Cursor, and others). Loop pattern:
+     while (true) {
+       const r = await wait_for_inbox({ timeout_seconds: 50 });
+       if (r !== "inbox:empty") handle(r);
+     }
+
+7. If your tool call fails with "MCP server not connected" / "transport
+   closed" / similar — the SERVER IS ALMOST CERTAINLY FINE. Other clients are
+   connected to the same server right now. Only YOUR client's transport
+   broke (commonly: stdio child process died, or HTTP client gave up after a
+   transient slow response at startup). DO NOT tell the user "notify is down"
+   without first probing the server directly.
+
+   Probe before declaring the server dead:
+     curl -s -o /dev/null -w "%{http_code}\n" http://localhost:3737/mcp
+   - 406 (Not Acceptable) = server is healthy, doing MCP protocol
+     negotiation. Your client is the broken party. Use the bypass below.
+   - Connection refused / timeout = server is genuinely down. Tell the user.
+
+   HTTP-transport bypass when your MCP client is broken (works from any
+   shell that has curl). Three calls, stateful — the session id from step 1
+   must be passed in mcp-session-id on every subsequent call:
+
+     # 1) initialize and capture session id from response headers
+     SID=$(curl -s -i -X POST http://localhost:3737/mcp \
+       -H "Content-Type: application/json" \
+       -H "Accept: application/json, text/event-stream" \
+       -d '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"curl-bridge","version":"1.0"}}}' \
+       | grep -i "^mcp-session-id:" | awk '{print $2}' | tr -d '\r')
+
+     # 2) ack initialized (no response body, fire-and-forget)
+     curl -s -X POST http://localhost:3737/mcp \
+       -H "Content-Type: application/json" \
+       -H "Accept: application/json, text/event-stream" \
+       -H "mcp-session-id: $SID" \
+       -d '{"jsonrpc":"2.0","method":"notifications/initialized"}' >/dev/null
+
+     # 3) call any tool — a delivered notify answers with outcome=delivered
+     curl -s -X POST http://localhost:3737/mcp \
+       -H "Content-Type: application/json" \
+       -H "Accept: application/json, text/event-stream" \
+       -H "mcp-session-id: $SID" \
+       -d '{"jsonrpc":"2.0","id":2,"method":"tools/call","params":{"name":"notify","arguments":{"message":"YOUR MESSAGE","priority":"normal"}}}'
+
+   Same pattern works for 'ask', 'poll', 'get_idle_seconds', etc. — change
+   the "name" and "arguments" in step 3. Reuse the same $SID for all calls
+   in one bypass session.
+
+   Bottom line: rule #1 still applies. If you owe the user a notify and your
+   MCP client is broken, you owe them the bypass — not an excuse.
 `.trim();
 function createMcpServer(clientId, sessionTag) {
     const identity = `@${clientId}`;
     const identityLine = `\nYOUR SESSION IDENTITY: "${identity}" — use this as your prefix in all notify replies (e.g. "[${identity}] done with build").\n`;
     const server = new McpServer({ name: "notify-mcp", version: "1.0.0" }, { instructions: identityLine + MCP_INSTRUCTIONS });
     server.tool("notify", "Send a notification to the user. Delivery channels and DND are server-configured. " +
-        "Before calling, check get_idle_seconds against get_idle_config.thresholdSeconds; " +
-        "skip the call if the user is active (unless priority='high'). " +
-        "Use for: task milestones, questions needing input, catastrophic findings, long task completion.", {
+        "The server applies DND and user-activity gating itself, so call it whenever a trigger fires — never pre-check idle. " +
+        "Use for: task milestones, questions needing input, catastrophic findings, long task completion. " +
+        "One message is limited to 500 characters — send anything longer as numbered parts, " +
+        "'(1/N) ...', '(2/N) ...', as separate calls in order, each at or under 500 characters. " +
+        "Never shorten the message to fit; 'too_big' means split it.", {
         message: z.string().max(500).describe("Notification message, max 500 chars"),
         priority: z.enum(["low", "normal", "high"]).default("normal")
-            .describe("low=email only; normal=desktop+telegram+email; high=all channels"),
+            .describe(`Channels per priority, each only when enabled: ${describePriorityRouting()} — high also bypasses DND and activity gating`),
     }, async ({ message, priority }) => {
         const outbound = `[${clientId}] ${message}`;
-        const summary = await sendNotification(outbound, priority, clientId);
+        const out = await sendNotification(outbound, priority, clientId);
+        const prefix = out.outcome === "delivered" ? "" : `⚠️ NOT DELIVERED — this notification reached nobody.\n${out.text}`;
+        const summary = prefix
+            + `${prefix ? "\n\n" : ""}outcome=${out.outcome} attempted=[${out.attempted.join(", ")}] delivered=[${out.delivered.join(", ")}]`;
         const messages = drainInboxFor(sessionTag);
         if (messages.length === 0) {
             return { content: [{ type: "text", text: summary }] };
@@ -2796,7 +2875,7 @@ function createMcpServer(clientId, sessionTag) {
                         from: email.connectedEmail ?? email.user ?? email.to,
                         to: email.to,
                         subject: `Claude asks: ${question.slice(0, 60)}`,
-                        html: `<p style="font-size:16px">${question}</p>
+                        html: `<p style="font-size:16px">${question}</p>
                      <p><a href="${replyUrl}" style="background:#7c6dfa;color:white;padding:10px 20px;border-radius:6px;text-decoration:none;display:inline-block;margin-top:8px">Reply to Claude</a></p>`,
                     });
                     log("→", "ask:email", `question sent to ${email.to}, reply URL: ${replyUrl}`, clientId);
@@ -2863,14 +2942,18 @@ function createMcpServer(clientId, sessionTag) {
         const body = entries.map(m => `[${m.ts}] ${m.text}`).join("\n");
         return { content: [{ type: "text", text: `⚠️ USER SENT YOU A MESSAGE — STOP AND RESPOND BEFORE CONTINUING:\n${body}` }] };
     });
-    server.tool("get_idle_seconds", "Returns the number of seconds since the user's last keyboard/mouse input. " +
+    server.tool("get_idle_seconds", "Returns how long it has been since the user's last keyboard/mouse input. " +
         "Call this periodically during long work as a cheap heartbeat — the server " +
         "will piggy-back any pending inbox messages in the response, so you stay " +
-        "responsive to the user without having to call poll. Returns -1 if idle " +
-        "detection is unsupported on this platform — in that case, proceed without " +
-        "gating (fail-open).", {}, async () => {
-        const secs = getOsIdleSeconds();
-        return { content: [{ type: "text", text: appendInbox(String(secs), sessionTag, clientId) }] };
+        "responsive to the user without having to call poll. The answer is either " +
+        "'idle: measured N seconds since the last keyboard/mouse input' or " +
+        "'idle: could not measure — user activity unknown, so activity gating is " +
+        "skipped'. Those are two DIFFERENT states: the first is a reading, the " +
+        "second means this machine cannot report user activity at all and the " +
+        "server therefore delivers instead of gating. Neither is a number to " +
+        "compare against a threshold yourself — the server gates internally.", {}, async () => {
+        const reading = idleReading(getOsIdleSeconds());
+        return { content: [{ type: "text", text: appendInbox(formatIdleReading(reading), sessionTag, clientId) }] };
     });
     server.tool("get_idle_config", "Returns the server's idle gating policy: { enabled, thresholdSeconds, alwaysDesktopWhenActive }. " +
         "Informational only — the server gates internally on every notify call. " +
@@ -3183,14 +3266,28 @@ function trackReconnect(clientId) {
             const count = reconnectedClients.length;
             const msg = `${count} client${count === 1 ? "" : "s"} reconnected and received updated instructions: ${list}`;
             try {
-                await sendNotification(msg, "low", "omni-notify-mcp");
+                await sendNotificationSummary(msg, "low", "omni-notify-mcp");
             }
             catch { /* best effort */ }
         }, RECONNECT_WINDOW_MS);
     }
 }
 // ── Start ─────────────────────────────────────────────────────────────────────
-const httpServer = app.listen(PORT, "0.0.0.0", () => {
+// The Telegram poller needs `getUpdates` over the outbound network and stays
+// off under NOTIFY_MCP_TEST_ENDPOINTS. The other two have no such dependency:
+// importCredsOnStart only reads a local file, and the Slack listener is inert
+// until Slack credentials exist, so a fresh install with populated secrets can
+// still import them from a TEST_ENDPOINTS process.
+const TEST_ENDPOINTS = process.env.NOTIFY_MCP_TEST_ENDPOINTS === "1";
+// Bound to EVERY interface, IPv4 and IPv6.
+//
+// This was `app.listen(PORT, "0.0.0.0", …)`, which is IPv4-only. On Windows a client that resolves
+// `localhost` to `::1` first then reaches a socket that is not listening — `[::1]:3737` answers nothing
+// while `127.0.0.1:3737` is fine — so the MCP endpoint was unreachable for any client whose resolver
+// prefers IPv6, and VS Code reported "unable to start" for a server that was running correctly. Binding
+// the hostname instead of the IPv4 wildcard opens both families, so `localhost`, `127.0.0.1` and `::1`
+// all work and no client has to know which one this process happens to speak.
+const httpServer = app.listen(PORT, () => {
     const ip = getLocalIp();
     console.log(`\n  Claude Notify config UI  → http://localhost:${PORT}`);
     if (ENABLE_MCP) {
@@ -3199,9 +3296,12 @@ const httpServer = app.listen(PORT, "0.0.0.0", () => {
     else {
         console.log("  MCP endpoint (remote)    → disabled (set ENABLE_MCP=1 to enable)\n");
     }
-    // Live Slack/Telegram pollers hit real external channels — never under test.
-    if (process.env.NOTIFY_MCP_TEST_ENDPOINTS !== "1") {
-        importCredsOnStart();
+    // Import runs on EVERY boot path, before the listeners start, so an empty
+    // config.json cannot serve a process whose secrets file IS populated. It
+    // reports the channel names it filled — never a secret value.
+    importCredsOnStart();
+    // Live Telegram/Slack pollers hit real external channels — never under test.
+    if (!TEST_ENDPOINTS) {
         startTelegramListener();
         startSlackListener();
     }