feat(core): ntfy.sh notification dispatcher module

Adds a transport-agnostic NotificationDispatcher and a fire-and-forget
ntfy.sh transport (no SDK; just fetch). Configuration is persisted as a
single global JSON blob under the 'ntfy_config' settings key.

Event taxonomy (per-event toggles):
- turn-completed   — assistant turn finished cleanly
- turn-error       — final turn error (after all fallbacks)
- permission-required — new permission prompt was created
- agent-spawned    — top-level user-agent tab spawned via 'summon'

Design:
- Single internal notify(event) interface so a future transport (email,
  webhook) plugs in without changing call sites.
- attachToAgentManager + attachToPermissionManager subscribe to the
  existing event streams via narrow listener interfaces (no @dispatch/api
  dependency back into core).
- 5s in-memory dedupe window on dedupeKey suppresses permission re-emits.
- 10s per-request abort timeout so a hung ntfy server can't pin a worker.
- All sends are fire-and-forget: void Promise.resolve(...).catch(warn).

Tests (39 new):
- ntfy transport: URL/headers/body/auth/click, header sanitization,
  per-event-type defaults, error paths.
- config: defaults, normalization tolerance, round-trip, redaction.
- dispatcher: master switch, per-event toggle, dedupe, agent/permission
  hookups, top-level-only filtering for agent-spawned, dispose.

9 files changed, 1196 insertions, 0 deletions

diff --git a/packages/core/src/index.ts b/packages/core/src/index.ts
index b1b17cc..327b0a5 100644
--- a/packages/core/src/index.ts
+++ b/packages/core/src/index.ts
@@ -68,6 +68,8 @@ export {
 export { createProvider } from "./llm/provider.js";
 // Models
 export { ModelRegistry } from "./models/index.js";
+// Notifications (ntfy.sh)
+export * from "./notifications/index.js";
 export * from "./permission/index.js";
 // Skills
 export {
diff --git a/packages/core/src/notifications/config.ts b/packages/core/src/notifications/config.ts
new file mode 100644
index 0000000..310c606
--- /dev/null
+++ b/packages/core/src/notifications/config.ts
@@ -0,0 +1,74 @@
+// Persisted ntfy config — single global JSON blob under one settings key.
+//
+// One global config (no per-user split): the rest of Dispatch's settings
+// table is global today (cf. `title_model_*`, `perm_*`), so notification
+// config follows the same pattern.
+
+import { deleteSetting, getSetting, setSetting } from "../db/settings.js";
+import type { NotificationEventType, NtfyConfig } from "./types.js";
+import { NTFY_DEFAULT_EVENTS, NTFY_EVENT_TYPES } from "./types.js";
+
+export const NTFY_CONFIG_KEY = "ntfy_config";
+
+/** Defaults returned when nothing is persisted yet. */
+export function defaultNtfyConfig(): NtfyConfig {
+	return {
+		enabled: false,
+		topicUrl: "",
+		authToken: "",
+		events: { ...NTFY_DEFAULT_EVENTS },
+	};
+}
+
+/**
+ * Normalize an arbitrary parsed JSON value into a complete `NtfyConfig`.
+ * Tolerant of missing / unexpected fields so a config from an older build
+ * never throws — missing event toggles fall back to defaults.
+ */
+export function normalizeNtfyConfig(raw: unknown): NtfyConfig {
+	const base = defaultNtfyConfig();
+	if (!raw || typeof raw !== "object") return base;
+	const obj = raw as Record<string, unknown>;
+	const out: NtfyConfig = {
+		enabled: typeof obj.enabled === "boolean" ? obj.enabled : base.enabled,
+		topicUrl: typeof obj.topicUrl === "string" ? obj.topicUrl : base.topicUrl,
+		authToken: typeof obj.authToken === "string" ? obj.authToken : base.authToken,
+		events: { ...base.events },
+	};
+	const rawEvents = obj.events;
+	if (rawEvents && typeof rawEvents === "object") {
+		const evObj = rawEvents as Record<string, unknown>;
+		for (const key of NTFY_EVENT_TYPES) {
+			const v = evObj[key];
+			if (typeof v === "boolean") out.events[key as NotificationEventType] = v;
+		}
+	}
+	return out;
+}
+
+/** Load the persisted config (or defaults if none/corrupt). */
+export function loadNtfyConfig(): NtfyConfig {
+	const raw = getSetting(NTFY_CONFIG_KEY);
+	if (!raw) return defaultNtfyConfig();
+	try {
+		return normalizeNtfyConfig(JSON.parse(raw));
+	} catch {
+		return defaultNtfyConfig();
+	}
+}
+
+/** Persist a complete config (after server-side normalization). */
+export function saveNtfyConfig(config: NtfyConfig): void {
+	const normalized = normalizeNtfyConfig(config);
+	setSetting(NTFY_CONFIG_KEY, JSON.stringify(normalized));
+}
+
+/** Wipe the persisted config (revert to defaults on next load). */
+export function clearNtfyConfig(): void {
+	deleteSetting(NTFY_CONFIG_KEY);
+}
+
+/** Strip the auth token from a config before returning it over the API. */
+export function redactNtfyConfig(config: NtfyConfig): NtfyConfig & { hasAuthToken: boolean } {
+	return { ...config, authToken: "", hasAuthToken: config.authToken.trim().length > 0 };
+}
diff --git a/packages/core/src/notifications/dispatcher.ts b/packages/core/src/notifications/dispatcher.ts
new file mode 100644
index 0000000..4f4fc79
--- /dev/null
+++ b/packages/core/src/notifications/dispatcher.ts
@@ -0,0 +1,238 @@
+// NotificationDispatcher — turns high-level Dispatch events into
+// `sendNtfy(...)` calls, gated by the persisted user config.
+//
+// The dispatcher is transport-agnostic at the `notify(event)` interface
+// boundary: only `sendNtfy` is wired today, but adding another transport
+// (email, webhook, etc.) means changing this one file, not the call sites.
+//
+// All sends are non-blocking (fire-and-forget). A 10-second timeout in
+// `sendNtfy` bounds the worst case; the dispatcher additionally guards
+// every send in a try/catch so a transport bug can never propagate into
+// the agent loop.
+
+import { loadNtfyConfig } from "./config.js";
+import { type FetchLike, sendNtfy } from "./ntfy.js";
+import type { NotificationEvent, NtfyConfig } from "./types.js";
+
+/** Minimal shape of an `AgentManager`-style event stream we hook into. */
+export interface AgentEventSource {
+	onEvent(
+		listener: (event: { type: string; tabId: string; [key: string]: unknown }) => void,
+	): () => void;
+}
+
+/** Minimal shape of a `PermissionManager`-style prompt source. */
+export interface PermissionPromptSource {
+	onPromptAdded(
+		listener: (prompt: { id: string; permission: string; description: string }) => void,
+	): () => void;
+}
+
+/** Look up a human-readable tab title for nicer notification text. */
+export type TabTitleLookup = (tabId: string) => string | null;
+
+export interface DispatcherOptions {
+	/** Override the config loader (tests). Defaults to `loadNtfyConfig`. */
+	loadConfig?: () => NtfyConfig;
+	/** Override the transport (tests). Defaults to the real `sendNtfy`. */
+	send?: (config: NtfyConfig, event: NotificationEvent) => Promise<unknown>;
+	/** Optional fetch override (forwarded to `sendNtfy` when `send` not set). */
+	fetchImpl?: FetchLike;
+	/** Look up a tab title for richer titles. */
+	getTabTitle?: TabTitleLookup;
+	/**
+	 * How long (ms) a dedupeKey is suppressed for. Permission prompts re-emit
+	 * the whole pending list on every change, so dedupe is essential.
+	 */
+	dedupeWindowMs?: number;
+}
+
+export class NotificationDispatcher {
+	private loadConfig: () => NtfyConfig;
+	private send: (config: NtfyConfig, event: NotificationEvent) => Promise<unknown>;
+	private getTabTitle: TabTitleLookup | undefined;
+	private dedupeWindowMs: number;
+	/** Recently-sent dedupeKey → expiresAt epoch ms. */
+	private recentlySent = new Map<string, number>();
+	private unsubs: Array<() => void> = [];
+
+	constructor(opts: DispatcherOptions = {}) {
+		this.loadConfig = opts.loadConfig ?? loadNtfyConfig;
+		this.send =
+			opts.send ?? ((config, event) => sendNtfy(config, event, opts.fetchImpl ?? undefined));
+		this.getTabTitle = opts.getTabTitle;
+		this.dedupeWindowMs = opts.dedupeWindowMs ?? 5_000;
+	}
+
+	/**
+	 * Single internal entry point — every public hook funnels through here.
+	 * Public so a future caller can synthesize an arbitrary notification
+	 * (e.g. a CLI `dispatch notify` command); kept narrow.
+	 */
+	notify(event: NotificationEvent): void {
+		const config = this.loadConfig();
+		if (!config.enabled) return;
+		if (!config.events[event.type]) return;
+		if (event.dedupeKey && this.isDuplicate(event.dedupeKey)) return;
+		if (event.dedupeKey) this.markSent(event.dedupeKey);
+
+		// Fire-and-forget: never await, never throw.
+		try {
+			void Promise.resolve(this.send(config, event)).catch((err) => {
+				console.warn(
+					`[ntfy] send failed for ${event.type}: ${err instanceof Error ? err.message : String(err)}`,
+				);
+			});
+		} catch (err) {
+			// Guard the synchronous portion of `send` too.
+			console.warn(
+				`[ntfy] dispatch threw for ${event.type}: ${err instanceof Error ? err.message : String(err)}`,
+			);
+		}
+	}
+
+	/**
+	 * Hook into an `AgentManager`-style event stream.
+	 *
+	 * Maps:
+	 *   - `done`            → `turn-completed`
+	 *   - `error`           → `turn-error`
+	 *   - `tab-created`     → `agent-spawned` (only top-level user-agent tabs)
+	 *
+	 * `status` events are ignored — they fire on every transition and we'd
+	 * either spam or duplicate the `done`/`error` notifications.
+	 */
+	attachToAgentManager(source: AgentEventSource): () => void {
+		const unsub = source.onEvent((event) => {
+			if (event.type === "done") {
+				this.notify(this.buildTurnCompleted(event));
+			} else if (event.type === "error") {
+				this.notify(this.buildTurnError(event));
+			} else if (event.type === "tab-created") {
+				const ev = event as unknown as {
+					tabId: string;
+					id: string;
+					title: string;
+					parentTabId: string | null;
+					agentSlug?: string | null;
+				};
+				// Only notify for top-level user-agent tabs spawned via `summon`.
+				// Filtering on `agentSlug` skips "blank" new tabs the user opened
+				// manually, which would be noisy.
+				if (ev.parentTabId === null && ev.agentSlug) {
+					this.notify(this.buildAgentSpawned(ev));
+				}
+			}
+		});
+		this.unsubs.push(unsub);
+		return unsub;
+	}
+
+	/** Hook into a `PermissionManager`-style prompt source. */
+	attachToPermissionManager(source: PermissionPromptSource): () => void {
+		const unsub = source.onPromptAdded((prompt) => {
+			this.notify(this.buildPermissionRequired(prompt));
+		});
+		this.unsubs.push(unsub);
+		return unsub;
+	}
+
+	/** Release all hooks acquired via `attachTo*`. */
+	dispose(): void {
+		for (const u of this.unsubs) {
+			try {
+				u();
+			} catch {
+				// best-effort
+			}
+		}
+		this.unsubs = [];
+		this.recentlySent.clear();
+	}
+
+	// ─── Event builders (internal) ────────────────────────────────
+
+	private buildTurnCompleted(event: { tabId: string }): NotificationEvent {
+		const tabLabel = this.tabLabel(event.tabId);
+		return {
+			type: "turn-completed",
+			title: `Turn complete — ${tabLabel}`,
+			message: `Assistant finished a turn in ${tabLabel}.`,
+			tabId: event.tabId,
+		};
+	}
+
+	private buildTurnError(event: {
+		tabId: string;
+		error?: unknown;
+		statusCode?: unknown;
+	}): NotificationEvent {
+		const tabLabel = this.tabLabel(event.tabId);
+		const errText = typeof event.error === "string" ? event.error : "Unknown error";
+		const statusText = typeof event.statusCode === "number" ? ` (status ${event.statusCode})` : "";
+		return {
+			type: "turn-error",
+			title: `Turn failed — ${tabLabel}`,
+			message: `${errText}${statusText}`,
+			tabId: event.tabId,
+		};
+	}
+
+	private buildPermissionRequired(prompt: {
+		id: string;
+		permission: string;
+		description: string;
+	}): NotificationEvent {
+		return {
+			type: "permission-required",
+			title: `Permission required: ${prompt.permission}`,
+			message: prompt.description || `Agent is requesting ${prompt.permission} permission.`,
+			// Permission prompts can re-emit (e.g. another prompt arrives while
+			// this one is still pending) — dedupe on the prompt id.
+			dedupeKey: `permission:${prompt.id}`,
+		};
+	}
+
+	private buildAgentSpawned(ev: {
+		tabId: string;
+		id: string;
+		title: string;
+		agentSlug?: string | null;
+	}): NotificationEvent {
+		return {
+			type: "agent-spawned",
+			title: `User agent spawned — ${ev.agentSlug ?? "agent"}`,
+			message: ev.title,
+			tabId: ev.tabId ?? ev.id,
+		};
+	}
+
+	private tabLabel(tabId: string): string {
+		const title = this.getTabTitle?.(tabId);
+		if (title?.trim()) return title.trim();
+		return `tab ${tabId.slice(0, 8)}`;
+	}
+
+	// ─── Dedupe helpers ───────────────────────────────────────────
+
+	private isDuplicate(key: string): boolean {
+		const expires = this.recentlySent.get(key);
+		if (expires === undefined) return false;
+		if (expires <= Date.now()) {
+			this.recentlySent.delete(key);
+			return false;
+		}
+		return true;
+	}
+
+	private markSent(key: string): void {
+		// Lazy-evict expired entries when the map gets large.
+		if (this.recentlySent.size > 256) {
+			const now = Date.now();
+			for (const [k, exp] of this.recentlySent) {
+				if (exp <= now) this.recentlySent.delete(k);
+			}
+		}
+		this.recentlySent.set(key, Date.now() + this.dedupeWindowMs);
+	}
+}
diff --git a/packages/core/src/notifications/index.ts b/packages/core/src/notifications/index.ts
new file mode 100644
index 0000000..ea99a58
--- /dev/null
+++ b/packages/core/src/notifications/index.ts
@@ -0,0 +1,29 @@
+// @dispatch/core — ntfy.sh push notifications
+
+export {
+	clearNtfyConfig,
+	defaultNtfyConfig,
+	loadNtfyConfig,
+	NTFY_CONFIG_KEY,
+	normalizeNtfyConfig,
+	redactNtfyConfig,
+	saveNtfyConfig,
+} from "./config.js";
+export {
+	type AgentEventSource,
+	type DispatcherOptions,
+	NotificationDispatcher,
+	type PermissionPromptSource,
+	type TabTitleLookup,
+} from "./dispatcher.js";
+export { type FetchLike, type NtfySendResult, sendNtfy, validateTopicUrl } from "./ntfy.js";
+export {
+	type NotificationEvent,
+	type NotificationEventType,
+	NTFY_DEFAULT_EVENTS,
+	NTFY_DEFAULT_PRIORITIES,
+	NTFY_DEFAULT_TAGS,
+	NTFY_EVENT_TYPES,
+	type NtfyConfig,
+	type NtfyPriority,
+} from "./types.js";
diff --git a/packages/core/src/notifications/ntfy.ts b/packages/core/src/notifications/ntfy.ts
new file mode 100644
index 0000000..07ce33b
--- /dev/null
+++ b/packages/core/src/notifications/ntfy.ts
@@ -0,0 +1,136 @@
+// ntfy.sh HTTP transport.
+//
+// ntfy's API is a simple POST to `https://<server>/<topic>` with the body
+// as the message and metadata passed via HTTP headers:
+//   Title:    notification title
+//   Priority: 1..5 (3 = default)
+//   Tags:     comma-separated emoji shortcodes
+//   Click:    URL opened when the notification is tapped
+//
+// We intentionally use `fetch` directly — no SDK, no extra deps.
+
+import type { NotificationEvent, NtfyConfig } from "./types.js";
+import { NTFY_DEFAULT_PRIORITIES, NTFY_DEFAULT_TAGS } from "./types.js";
+
+export interface NtfySendResult {
+	ok: boolean;
+	status?: number;
+	error?: string;
+}
+
+/**
+ * Lightweight fetch shape so callers (and tests) can inject a mock without
+ * pulling in the DOM `fetch` type from a `Headers` instance.
+ */
+export type FetchLike = (
+	input: string,
+	init: { method: string; headers: Record<string, string>; body: string; signal?: AbortSignal },
+) => Promise<{ ok: boolean; status: number; statusText?: string; text(): Promise<string> }>;
+
+/**
+ * Validate a ntfy topic URL. Accepts only `http(s)://host/topic` with a
+ * non-empty topic path. Returns `null` on success, a human-readable error
+ * string on failure.
+ */
+export function validateTopicUrl(topicUrl: string): string | null {
+	const trimmed = topicUrl.trim();
+	if (!trimmed) return "Topic URL is required";
+	let url: URL;
+	try {
+		url = new URL(trimmed);
+	} catch {
+		return "Topic URL is not a valid URL";
+	}
+	if (url.protocol !== "http:" && url.protocol !== "https:") {
+		return "Topic URL must use http:// or https://";
+	}
+	// Path must be a non-empty topic (more than just "/")
+	const topic = url.pathname.replace(/^\/+|\/+$/g, "");
+	if (!topic) return "Topic URL must include a topic name (e.g. https://ntfy.sh/my-topic)";
+	return null;
+}
+
+/**
+ * Send a single notification to the configured ntfy topic.
+ *
+ * Fire-and-forget at call sites: the dispatcher uses
+ * `void sendNtfy(...).catch(...)` so a slow/broken ntfy server never blocks
+ * a turn. We still return a structured result so the explicit
+ * `POST /notifications/test` route can surface failures back to the UI.
+ *
+ * Pure with respect to `config` / `event` — no DB, no module state.
+ */
+export async function sendNtfy(
+	config: NtfyConfig,
+	event: NotificationEvent,
+	fetchImpl: FetchLike = globalThis.fetch as unknown as FetchLike,
+	timeoutMs = 10_000,
+): Promise<NtfySendResult> {
+	if (!config.enabled) return { ok: false, error: "Notifications are disabled" };
+	const topicErr = validateTopicUrl(config.topicUrl);
+	if (topicErr) return { ok: false, error: topicErr };
+
+	const priority = event.priority ?? NTFY_DEFAULT_PRIORITIES[event.type] ?? 3;
+	const baseTags = event.tags ?? NTFY_DEFAULT_TAGS[event.type] ?? [];
+	const tags = [...baseTags];
+	if (event.tabId) {
+		// Short, ASCII-only tag so ntfy's comma-separated header parser is happy.
+		tags.push(`tab-${event.tabId.slice(0, 8)}`);
+	}
+
+	const headers: Record<string, string> = {
+		// ntfy treats the title/priority/tags/click headers as ASCII-only. Strip
+		// control chars from the title; the body is sent UTF-8 verbatim.
+		Title: sanitizeHeader(event.title),
+		Priority: String(priority),
+		"Content-Type": "text/plain; charset=utf-8",
+	};
+	if (tags.length > 0) headers.Tags = tags.map(sanitizeHeader).join(",");
+	if (event.clickUrl) headers.Click = event.clickUrl;
+	if (config.authToken && config.authToken.trim() !== "") {
+		headers.Authorization = `Bearer ${config.authToken.trim()}`;
+	}
+
+	// Per-request abort so a hung server doesn't pin a Bun worker forever.
+	const controller = new AbortController();
+	const timer = setTimeout(() => controller.abort(), timeoutMs);
+
+	try {
+		const res = await fetchImpl(config.topicUrl.trim(), {
+			method: "POST",
+			headers,
+			body: event.message,
+			signal: controller.signal,
+		});
+		if (!res.ok) {
+			const text = await safeReadText(res);
+			return {
+				ok: false,
+				status: res.status,
+				error: `ntfy responded ${res.status} ${res.statusText ?? ""}: ${text}`.trim(),
+			};
+		}
+		return { ok: true, status: res.status };
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		return { ok: false, error: msg };
+	} finally {
+		clearTimeout(timer);
+	}
+}
+
+function sanitizeHeader(value: string): string {
+	// Strip CR/LF (header injection guard) and trim. ntfy is tolerant of
+	// non-ASCII in titles, but we still drop control chars.
+	// biome-ignore lint/suspicious/noControlCharactersInRegex: intentional
+	return value.replace(/[\r\n\u0000-\u001f]+/g, " ").trim();
+}
+
+async function safeReadText(res: { text(): Promise<string> }): Promise<string> {
+	try {
+		const t = await res.text();
+		return t.length > 200 ? `${t.slice(0, 200)}…` : t;
+	} catch {
+		return "";
+	}
+}
diff --git a/packages/core/src/notifications/types.ts b/packages/core/src/notifications/types.ts
new file mode 100644
index 0000000..f6baa27
--- /dev/null
+++ b/packages/core/src/notifications/types.ts
@@ -0,0 +1,98 @@
+// ntfy.sh push notifications — types
+
+/**
+ * Catalog of notification-worthy events.
+ *
+ * Kept intentionally small and stable: each entry is something a human
+ * actually wants pushed to their phone. New event types should be added
+ * with a sensible default (`NTFY_DEFAULT_EVENTS`) and a mapping in the
+ * dispatcher.
+ */
+export type NotificationEventType =
+	| "turn-completed"
+	| "turn-error"
+	| "permission-required"
+	| "agent-spawned";
+
+/** ntfy priority levels (1=min … 5=max). */
+export type NtfyPriority = 1 | 2 | 3 | 4 | 5;
+
+/**
+ * A single notification request. Synthesised by the dispatcher from a
+ * higher-level event source (AgentManager / PermissionManager); fed to
+ * the ntfy transport.
+ *
+ * `dedupeKey` lets the dispatcher suppress duplicate sends (e.g. the
+ * permission system re-emits the pending list on every change).
+ */
+export interface NotificationEvent {
+	type: NotificationEventType;
+	/** Notification title (short). */
+	title: string;
+	/** Notification body. */
+	message: string;
+	/** Optional ntfy tags (emoji shortcodes — e.g. `["white_check_mark"]`). */
+	tags?: string[];
+	/** Optional priority override. Defaults are per-event-type. */
+	priority?: NtfyPriority;
+	/** Optional URL the notification deep-links to when tapped. */
+	clickUrl?: string;
+	/** Origin tab id (informational; included in tags as `tab:<short>`). */
+	tabId?: string;
+	/**
+	 * Stable key for suppressing duplicates. Same key + same type within a
+	 * short window ⇒ dropped silently.
+	 */
+	dedupeKey?: string;
+}
+
+/**
+ * Persisted ntfy configuration. Lives in the `settings` table under a
+ * single key (`ntfy_config`) — one global config, matching the codebase's
+ * existing single-user assumption (cf. `title_model_*`, `perm_*`).
+ *
+ * - `enabled` — master switch. Off ⇒ dispatcher never sends.
+ * - `topicUrl` — full URL, e.g. `https://ntfy.sh/my-secret-topic`. Missing
+ *   ⇒ dispatcher never sends.
+ * - `authToken` — optional bearer token for private ntfy servers.
+ * - `events` — per-event-type enable map. Missing entries default to OFF
+ *   so a newly-added event type doesn't silently start firing.
+ */
+export interface NtfyConfig {
+	enabled: boolean;
+	topicUrl: string;
+	authToken: string;
+	events: Record<NotificationEventType, boolean>;
+}
+
+/** All event types this build knows about (the source of truth for UI). */
+export const NTFY_EVENT_TYPES: NotificationEventType[] = [
+	"turn-completed",
+	"turn-error",
+	"permission-required",
+	"agent-spawned",
+];
+
+/** Default per-event-type toggles. */
+export const NTFY_DEFAULT_EVENTS: Record<NotificationEventType, boolean> = {
+	"turn-completed": true,
+	"turn-error": true,
+	"permission-required": true,
+	"agent-spawned": false,
+};
+
+/** Default priority per event type (when the event itself doesn't override). */
+export const NTFY_DEFAULT_PRIORITIES: Record<NotificationEventType, NtfyPriority> = {
+	"turn-completed": 3,
+	"turn-error": 4,
+	"permission-required": 4,
+	"agent-spawned": 2,
+};
+
+/** Default tag (emoji) per event type. */
+export const NTFY_DEFAULT_TAGS: Record<NotificationEventType, string[]> = {
+	"turn-completed": ["white_check_mark"],
+	"turn-error": ["rotating_light"],
+	"permission-required": ["lock"],
+	"agent-spawned": ["sparkles"],
+};
diff --git a/packages/core/tests/notifications/config.test.ts b/packages/core/tests/notifications/config.test.ts
new file mode 100644
index 0000000..64a9637
--- /dev/null
+++ b/packages/core/tests/notifications/config.test.ts
@@ -0,0 +1,128 @@
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+// In-memory fake for the settings table — mounted before the module under
+// test is imported (vi.mock is hoisted).
+const fakeSettings = new Map<string, string>();
+
+vi.mock("../../src/db/settings.js", () => ({
+	getSetting: vi.fn((key: string) => fakeSettings.get(key) ?? null),
+	setSetting: vi.fn((key: string, value: string) => {
+		fakeSettings.set(key, value);
+	}),
+	deleteSetting: vi.fn((key: string) => {
+		fakeSettings.delete(key);
+	}),
+}));
+
+const {
+	clearNtfyConfig,
+	defaultNtfyConfig,
+	loadNtfyConfig,
+	normalizeNtfyConfig,
+	NTFY_CONFIG_KEY,
+	redactNtfyConfig,
+	saveNtfyConfig,
+} = await import("../../src/notifications/config.js");
+
+describe("defaultNtfyConfig", () => {
+	it("disables notifications and ships sane per-event defaults", () => {
+		const cfg = defaultNtfyConfig();
+		expect(cfg.enabled).toBe(false);
+		expect(cfg.topicUrl).toBe("");
+		expect(cfg.authToken).toBe("");
+		expect(cfg.events["turn-completed"]).toBe(true);
+		expect(cfg.events["turn-error"]).toBe(true);
+		expect(cfg.events["permission-required"]).toBe(true);
+		expect(cfg.events["agent-spawned"]).toBe(false);
+	});
+});
+
+describe("normalizeNtfyConfig", () => {
+	it("returns defaults for non-object input", () => {
+		expect(normalizeNtfyConfig(null)).toEqual(defaultNtfyConfig());
+		expect(normalizeNtfyConfig(undefined)).toEqual(defaultNtfyConfig());
+		expect(normalizeNtfyConfig(42)).toEqual(defaultNtfyConfig());
+	});
+
+	it("fills in missing event toggles with defaults (newly-added types default OFF)", () => {
+		const normalized = normalizeNtfyConfig({
+			enabled: true,
+			topicUrl: "https://ntfy.sh/x",
+			events: { "turn-completed": false },
+		});
+		expect(normalized.events["turn-completed"]).toBe(false);
+		// Defaults preserved for fields the persisted blob doesn't have.
+		expect(normalized.events["turn-error"]).toBe(true);
+		expect(normalized.events["agent-spawned"]).toBe(false);
+	});
+
+	it("ignores extraneous fields and wrong-typed values", () => {
+		const normalized = normalizeNtfyConfig({
+			enabled: "yes", // wrong type ⇒ default
+			topicUrl: 42, // wrong type ⇒ default
+			authToken: null, // wrong type ⇒ default
+			events: { "turn-completed": "no", bogus: true },
+			extra: "ignored",
+		});
+		expect(normalized.enabled).toBe(false);
+		expect(normalized.topicUrl).toBe("");
+		expect(normalized.authToken).toBe("");
+		expect(normalized.events["turn-completed"]).toBe(true); // default kept
+		expect((normalized.events as Record<string, boolean>).bogus).toBeUndefined();
+	});
+});
+
+describe("load/save round-trip", () => {
+	beforeEach(() => {
+		fakeSettings.clear();
+	});
+
+	it("returns defaults when nothing is persisted", () => {
+		expect(loadNtfyConfig()).toEqual(defaultNtfyConfig());
+	});
+
+	it("round-trips a complete config", () => {
+		const cfg = {
+			enabled: true,
+			topicUrl: "https://ntfy.sh/team",
+			authToken: "tk_abc",
+			events: {
+				"turn-completed": false,
+				"turn-error": true,
+				"permission-required": true,
+				"agent-spawned": true,
+			},
+		} as const;
+		saveNtfyConfig({ ...cfg });
+		const loaded = loadNtfyConfig();
+		expect(loaded).toEqual(cfg);
+		// Persisted as a JSON string under the documented key.
+		expect(fakeSettings.has(NTFY_CONFIG_KEY)).toBe(true);
+	});
+
+	it("returns defaults when stored JSON is corrupt", () => {
+		fakeSettings.set(NTFY_CONFIG_KEY, "{ not json");
+		expect(loadNtfyConfig()).toEqual(defaultNtfyConfig());
+	});
+
+	it("clearNtfyConfig removes the persisted entry", () => {
+		saveNtfyConfig({ ...defaultNtfyConfig(), enabled: true, topicUrl: "https://ntfy.sh/x" });
+		expect(fakeSettings.has(NTFY_CONFIG_KEY)).toBe(true);
+		clearNtfyConfig();
+		expect(fakeSettings.has(NTFY_CONFIG_KEY)).toBe(false);
+	});
+});
+
+describe("redactNtfyConfig", () => {
+	it("strips authToken and surfaces a hasAuthToken flag", () => {
+		const cfg = { ...defaultNtfyConfig(), authToken: "tk_secret" };
+		const redacted = redactNtfyConfig(cfg);
+		expect(redacted.authToken).toBe("");
+		expect(redacted.hasAuthToken).toBe(true);
+	});
+
+	it("hasAuthToken is false for blank tokens", () => {
+		expect(redactNtfyConfig({ ...defaultNtfyConfig(), authToken: "" }).hasAuthToken).toBe(false);
+		expect(redactNtfyConfig({ ...defaultNtfyConfig(), authToken: "   " }).hasAuthToken).toBe(false);
+	});
+});
diff --git a/packages/core/tests/notifications/dispatcher.test.ts b/packages/core/tests/notifications/dispatcher.test.ts
new file mode 100644
index 0000000..db05de4
--- /dev/null
+++ b/packages/core/tests/notifications/dispatcher.test.ts
@@ -0,0 +1,323 @@
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import type { NotificationEvent, NtfyConfig } from "../../src/notifications/types.js";
+
+// The dispatcher imports `loadNtfyConfig` from config.ts, which transitively
+// pulls in `db/index.js` (bun:sqlite). Stub the DB so vitest under Node can
+// load this file. All tests inject `loadConfig` explicitly, so the real
+// settings table is never read.
+vi.mock("../../src/db/index.js", () => ({
+	getDatabase: vi.fn(() => ({
+		query: () => ({ get: () => null, run: () => {} }),
+		run: () => {},
+	})),
+}));
+
+const { NotificationDispatcher } = await import("../../src/notifications/dispatcher.js");
+
+function makeConfig(overrides: Partial<NtfyConfig> = {}): NtfyConfig {
+	return {
+		enabled: true,
+		topicUrl: "https://ntfy.sh/topic",
+		authToken: "",
+		events: {
+			"turn-completed": true,
+			"turn-error": true,
+			"permission-required": true,
+			"agent-spawned": true,
+		},
+		...overrides,
+	};
+}
+
+interface FakeAgentSource {
+	onEvent(
+		listener: (event: { type: string; tabId: string; [k: string]: unknown }) => void,
+	): () => void;
+	emit(event: { type: string; tabId: string; [k: string]: unknown }): void;
+}
+
+function makeAgentSource(): FakeAgentSource {
+	let l: ((event: { type: string; tabId: string; [k: string]: unknown }) => void) | null = null;
+	return {
+		onEvent(listener) {
+			l = listener;
+			return () => {
+				l = null;
+			};
+		},
+		emit(event) {
+			l?.(event);
+		},
+	};
+}
+
+interface FakePermissionSource {
+	onPromptAdded(
+		listener: (prompt: { id: string; permission: string; description: string }) => void,
+	): () => void;
+	emit(prompt: { id: string; permission: string; description: string }): void;
+}
+
+function makePermissionSource(): FakePermissionSource {
+	let l: ((prompt: { id: string; permission: string; description: string }) => void) | null = null;
+	return {
+		onPromptAdded(listener) {
+			l = listener;
+			return () => {
+				l = null;
+			};
+		},
+		emit(p) {
+			l?.(p);
+		},
+	};
+}
+
+// Microtask flush so the dispatcher's `void Promise.resolve(...).catch(...)`
+// has a chance to settle before assertions.
+async function flush(): Promise<void> {
+	await Promise.resolve();
+	await Promise.resolve();
+}
+
+describe("NotificationDispatcher.notify", () => {
+	let warnSpy: ReturnType<typeof vi.spyOn>;
+	beforeEach(() => {
+		warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+	});
+	afterEach(() => {
+		warnSpy.mockRestore();
+	});
+
+	it("does not send when master switch is disabled", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const d = new NotificationDispatcher({
+			loadConfig: () => makeConfig({ enabled: false }),
+			send,
+		});
+		d.notify({ type: "turn-completed", title: "x", message: "y" });
+		await flush();
+		expect(send).not.toHaveBeenCalled();
+	});
+
+	it("does not send when per-event-type toggle is off", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const d = new NotificationDispatcher({
+			loadConfig: () =>
+				makeConfig({
+					events: {
+						"turn-completed": false,
+						"turn-error": true,
+						"permission-required": true,
+						"agent-spawned": false,
+					},
+				}),
+			send,
+		});
+		d.notify({ type: "turn-completed", title: "x", message: "y" });
+		await flush();
+		expect(send).not.toHaveBeenCalled();
+	});
+
+	it("sends when enabled and toggle is on", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const d = new NotificationDispatcher({ loadConfig: () => makeConfig(), send });
+		d.notify({ type: "turn-completed", title: "x", message: "y" });
+		await flush();
+		expect(send).toHaveBeenCalledTimes(1);
+	});
+
+	it("does not throw or block when the transport rejects", async () => {
+		const send = vi.fn(async () => {
+			throw new Error("boom");
+		});
+		const d = new NotificationDispatcher({ loadConfig: () => makeConfig(), send });
+		expect(() => d.notify({ type: "turn-completed", title: "x", message: "y" })).not.toThrow();
+		await flush();
+		expect(send).toHaveBeenCalledTimes(1);
+		expect(warnSpy).toHaveBeenCalled();
+	});
+
+	it("dedupes events with the same dedupeKey within the window", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const d = new NotificationDispatcher({
+			loadConfig: () => makeConfig(),
+			send,
+			dedupeWindowMs: 1000,
+		});
+		const event: NotificationEvent = {
+			type: "permission-required",
+			title: "p",
+			message: "p",
+			dedupeKey: "permission:42",
+		};
+		d.notify(event);
+		d.notify(event);
+		d.notify(event);
+		await flush();
+		expect(send).toHaveBeenCalledTimes(1);
+	});
+
+	it("does not dedupe events without a dedupeKey", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const d = new NotificationDispatcher({ loadConfig: () => makeConfig(), send });
+		d.notify({ type: "turn-completed", title: "x", message: "y" });
+		d.notify({ type: "turn-completed", title: "x", message: "y" });
+		await flush();
+		expect(send).toHaveBeenCalledTimes(2);
+	});
+});
+
+describe("NotificationDispatcher.attachToAgentManager", () => {
+	let warnSpy: ReturnType<typeof vi.spyOn>;
+	beforeEach(() => {
+		warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+	});
+	afterEach(() => {
+		warnSpy.mockRestore();
+	});
+
+	it("maps `done` → turn-completed (with tab title in the body)", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const source = makeAgentSource();
+		const d = new NotificationDispatcher({
+			loadConfig: () => makeConfig(),
+			send,
+			getTabTitle: (id) => (id === "tab-1" ? "My chat" : null),
+		});
+		d.attachToAgentManager(source);
+		source.emit({ type: "done", tabId: "tab-1", message: { role: "assistant", chunks: [] } });
+		await flush();
+		expect(send).toHaveBeenCalledTimes(1);
+		const event = send.mock.calls[0][1] as NotificationEvent;
+		expect(event.type).toBe("turn-completed");
+		expect(event.title).toContain("My chat");
+		expect(event.tabId).toBe("tab-1");
+	});
+
+	it("maps `error` → turn-error and includes the error text", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const source = makeAgentSource();
+		const d = new NotificationDispatcher({ loadConfig: () => makeConfig(), send });
+		d.attachToAgentManager(source);
+		source.emit({ type: "error", tabId: "tab-1", error: "Rate limit", statusCode: 429 });
+		await flush();
+		expect(send).toHaveBeenCalledTimes(1);
+		const event = send.mock.calls[0][1] as NotificationEvent;
+		expect(event.type).toBe("turn-error");
+		expect(event.message).toContain("Rate limit");
+		expect(event.message).toContain("429");
+	});
+
+	it("ignores `status` events (would spam every transition)", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const source = makeAgentSource();
+		const d = new NotificationDispatcher({ loadConfig: () => makeConfig(), send });
+		d.attachToAgentManager(source);
+		source.emit({ type: "status", tabId: "tab-1", status: "running" });
+		source.emit({ type: "status", tabId: "tab-1", status: "idle" });
+		await flush();
+		expect(send).not.toHaveBeenCalled();
+	});
+
+	it("maps `tab-created` to agent-spawned only for top-level user agents (parentTabId=null AND agentSlug set)", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const source = makeAgentSource();
+		const d = new NotificationDispatcher({ loadConfig: () => makeConfig(), send });
+		d.attachToAgentManager(source);
+
+		// Manual "new tab" with no agent slug ⇒ no notification.
+		source.emit({
+			type: "tab-created",
+			tabId: "tab-1",
+			id: "tab-1",
+			title: "New Tab",
+			parentTabId: null,
+			agentSlug: null,
+		});
+		// Subagent (has a parent) ⇒ no notification.
+		source.emit({
+			type: "tab-created",
+			tabId: "tab-2",
+			id: "tab-2",
+			title: "Subagent",
+			parentTabId: "tab-1",
+			agentSlug: "researcher",
+		});
+		// Top-level user agent ⇒ notify.
+		source.emit({
+			type: "tab-created",
+			tabId: "tab-3",
+			id: "tab-3",
+			title: "Refactor auth code",
+			parentTabId: null,
+			agentSlug: "engineer",
+		});
+		await flush();
+		expect(send).toHaveBeenCalledTimes(1);
+		const event = send.mock.calls[0][1] as NotificationEvent;
+		expect(event.type).toBe("agent-spawned");
+		expect(event.message).toBe("Refactor auth code");
+		expect(event.title).toContain("engineer");
+	});
+
+	it("respects the per-event-type toggle (turn-completed off ⇒ silent)", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const source = makeAgentSource();
+		const d = new NotificationDispatcher({
+			loadConfig: () =>
+				makeConfig({
+					events: {
+						"turn-completed": false,
+						"turn-error": true,
+						"permission-required": true,
+						"agent-spawned": false,
+					},
+				}),
+			send,
+		});
+		d.attachToAgentManager(source);
+		source.emit({ type: "done", tabId: "tab-1", message: { role: "assistant", chunks: [] } });
+		await flush();
+		expect(send).not.toHaveBeenCalled();
+	});
+});
+
+describe("NotificationDispatcher.attachToPermissionManager", () => {
+	let warnSpy: ReturnType<typeof vi.spyOn>;
+	beforeEach(() => {
+		warnSpy = vi.spyOn(console, "warn").mockImplementation(() => {});
+	});
+	afterEach(() => {
+		warnSpy.mockRestore();
+	});
+
+	it("notifies once per unique prompt id (dedupes re-emits)", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const source = makePermissionSource();
+		const d = new NotificationDispatcher({ loadConfig: () => makeConfig(), send });
+		d.attachToPermissionManager(source);
+
+		source.emit({ id: "1", permission: "bash", description: "Run git status" });
+		source.emit({ id: "1", permission: "bash", description: "Run git status" });
+		source.emit({ id: "2", permission: "read", description: "Read /etc/hosts" });
+		await flush();
+		expect(send).toHaveBeenCalledTimes(2);
+		const events = send.mock.calls.map((c) => c[1] as NotificationEvent);
+		expect(events.map((e) => e.type)).toEqual(["permission-required", "permission-required"]);
+		expect(events.every((e) => e.dedupeKey?.startsWith("permission:"))).toBe(true);
+	});
+});
+
+describe("NotificationDispatcher.dispose", () => {
+	it("releases attached subscriptions", async () => {
+		const send = vi.fn(async () => ({ ok: true }));
+		const source = makeAgentSource();
+		const d = new NotificationDispatcher({ loadConfig: () => makeConfig(), send });
+		d.attachToAgentManager(source);
+		d.dispose();
+		source.emit({ type: "done", tabId: "tab-1", message: { role: "assistant", chunks: [] } });
+		await flush();
+		expect(send).not.toHaveBeenCalled();
+	});
+});
diff --git a/packages/core/tests/notifications/ntfy.test.ts b/packages/core/tests/notifications/ntfy.test.ts
new file mode 100644
index 0000000..3fb1d51
--- /dev/null
+++ b/packages/core/tests/notifications/ntfy.test.ts
@@ -0,0 +1,168 @@
+import { describe, expect, it, vi } from "vitest";
+import { sendNtfy, validateTopicUrl } from "../../src/notifications/ntfy.js";
+import type { NotificationEvent, NtfyConfig } from "../../src/notifications/types.js";
+
+function makeConfig(overrides: Partial<NtfyConfig> = {}): NtfyConfig {
+	return {
+		enabled: true,
+		topicUrl: "https://ntfy.sh/my-topic",
+		authToken: "",
+		events: {
+			"turn-completed": true,
+			"turn-error": true,
+			"permission-required": true,
+			"agent-spawned": true,
+		},
+		...overrides,
+	};
+}
+
+function makeEvent(overrides: Partial<NotificationEvent> = {}): NotificationEvent {
+	return {
+		type: "turn-completed",
+		title: "Done",
+		message: "all good",
+		...overrides,
+	};
+}
+
+function makeFetch(
+	response: Partial<{ ok: boolean; status: number; statusText: string; body: string }> = {},
+) {
+	const fetchImpl = vi.fn(async () => ({
+		ok: response.ok ?? true,
+		status: response.status ?? 200,
+		statusText: response.statusText ?? "OK",
+		text: async () => response.body ?? "",
+	}));
+	return fetchImpl;
+}
+
+describe("validateTopicUrl", () => {
+	it("accepts ntfy.sh-style URLs", () => {
+		expect(validateTopicUrl("https://ntfy.sh/my-topic")).toBeNull();
+		expect(validateTopicUrl("http://ntfy.example.com/team-alerts")).toBeNull();
+	});
+
+	it("rejects empty / whitespace", () => {
+		expect(validateTopicUrl("")).toMatch(/required/);
+		expect(validateTopicUrl("   ")).toMatch(/required/);
+	});
+
+	it("rejects malformed URLs", () => {
+		expect(validateTopicUrl("not a url")).toMatch(/valid URL/);
+	});
+
+	it("rejects non-http(s) schemes", () => {
+		expect(validateTopicUrl("ftp://ntfy.sh/topic")).toMatch(/http/);
+	});
+
+	it("rejects URLs missing a topic path", () => {
+		expect(validateTopicUrl("https://ntfy.sh")).toMatch(/topic/);
+		expect(validateTopicUrl("https://ntfy.sh/")).toMatch(/topic/);
+	});
+});
+
+describe("sendNtfy", () => {
+	it("POSTs to the topic URL with Title/Priority/Tags/Content-Type headers and body", async () => {
+		const fetchImpl = makeFetch();
+		const result = await sendNtfy(
+			makeConfig(),
+			makeEvent({ title: "Hello", message: "World", tags: ["bell"], priority: 4 }),
+			fetchImpl,
+		);
+		expect(result.ok).toBe(true);
+		expect(fetchImpl).toHaveBeenCalledTimes(1);
+		const [url, init] = fetchImpl.mock.calls[0];
+		expect(url).toBe("https://ntfy.sh/my-topic");
+		expect(init.method).toBe("POST");
+		expect(init.headers.Title).toBe("Hello");
+		expect(init.headers.Priority).toBe("4");
+		expect(init.headers.Tags).toBe("bell");
+		expect(init.headers["Content-Type"]).toMatch(/text\/plain/);
+		expect(init.body).toBe("World");
+	});
+
+	it("uses per-event-type defaults for priority and tags", async () => {
+		const fetchImpl = makeFetch();
+		await sendNtfy(makeConfig(), makeEvent({ type: "turn-error" }), fetchImpl);
+		const init = fetchImpl.mock.calls[0][1];
+		expect(init.headers.Priority).toBe("4"); // NTFY_DEFAULT_PRIORITIES["turn-error"]
+		expect(init.headers.Tags).toBe("rotating_light");
+	});
+
+	it("attaches Authorization header when authToken is set", async () => {
+		const fetchImpl = makeFetch();
+		await sendNtfy(makeConfig({ authToken: "tk_secret " }), makeEvent(), fetchImpl);
+		const init = fetchImpl.mock.calls[0][1];
+		expect(init.headers.Authorization).toBe("Bearer tk_secret");
+	});
+
+	it("omits Authorization when authToken is blank", async () => {
+		const fetchImpl = makeFetch();
+		await sendNtfy(makeConfig({ authToken: "   " }), makeEvent(), fetchImpl);
+		const init = fetchImpl.mock.calls[0][1];
+		expect(init.headers.Authorization).toBeUndefined();
+	});
+
+	it("attaches Click header when clickUrl is set", async () => {
+		const fetchImpl = makeFetch();
+		await sendNtfy(makeConfig(), makeEvent({ clickUrl: "https://example.com/tab/abc" }), fetchImpl);
+		const init = fetchImpl.mock.calls[0][1];
+		expect(init.headers.Click).toBe("https://example.com/tab/abc");
+	});
+
+	it("appends short tab tag when tabId is set", async () => {
+		const fetchImpl = makeFetch();
+		await sendNtfy(
+			makeConfig(),
+			makeEvent({ tabId: "abcdef0123456789", tags: ["bell"] }),
+			fetchImpl,
+		);
+		const init = fetchImpl.mock.calls[0][1];
+		expect(init.headers.Tags).toBe("bell,tab-abcdef01");
+	});
+
+	it("strips CR/LF/control chars from header values (injection guard)", async () => {
+		const fetchImpl = makeFetch();
+		await sendNtfy(makeConfig(), makeEvent({ title: "line1\r\nInjected: yes" }), fetchImpl);
+		const init = fetchImpl.mock.calls[0][1];
+		expect(init.headers.Title).not.toContain("\n");
+		expect(init.headers.Title).not.toContain("\r");
+		expect(init.headers.Title).toBe("line1 Injected: yes");
+	});
+
+	it("returns ok:false when notifications are disabled", async () => {
+		const fetchImpl = makeFetch();
+		const result = await sendNtfy(makeConfig({ enabled: false }), makeEvent(), fetchImpl);
+		expect(result.ok).toBe(false);
+		expect(result.error).toMatch(/disabled/);
+		expect(fetchImpl).not.toHaveBeenCalled();
+	});
+
+	it("returns ok:false on invalid topic URL without calling fetch", async () => {
+		const fetchImpl = makeFetch();
+		const result = await sendNtfy(makeConfig({ topicUrl: "not a url" }), makeEvent(), fetchImpl);
+		expect(result.ok).toBe(false);
+		expect(result.error).toBeDefined();
+		expect(fetchImpl).not.toHaveBeenCalled();
+	});
+
+	it("returns ok:false with status on non-2xx response", async () => {
+		const fetchImpl = makeFetch({ ok: false, status: 403, statusText: "Forbidden", body: "nope" });
+		const result = await sendNtfy(makeConfig(), makeEvent(), fetchImpl);
+		expect(result.ok).toBe(false);
+		expect(result.status).toBe(403);
+		expect(result.error).toMatch(/403/);
+		expect(result.error).toMatch(/nope/);
+	});
+
+	it("returns ok:false with error message on fetch throwing", async () => {
+		const fetchImpl = vi.fn(async () => {
+			throw new Error("ECONNREFUSED");
+		});
+		const result = await sendNtfy(makeConfig(), makeEvent(), fetchImpl);
+		expect(result.ok).toBe(false);
+		expect(result.error).toMatch(/ECONNREFUSED/);
+	});
+});