@interactive-inc/claude-funnel 0.49.0 → 0.50.0

package/dist/memory-connector-diagnostic-log-CrW1ltLM.js

@@ -0,0 +1,2245 @@
+import { n as NodeFunnelProcessRunner } from "./gh-connector-schema-o3Q1-ojL.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BcrmWN9I.js";
+import { n as FUNNEL_DIR, o as resolveFunnelPort } from "./settings-store-D2XSXTyt.js";
+import { dirname, join } from "node:path";
+import { chmodSync, existsSync, mkdirSync } from "node:fs";
+import { z } from "zod";
+import { homedir, tmpdir } from "node:os";
+import { timingSafeEqual } from "node:crypto";
+import { createFactory } from "hono/factory";
+import { Database } from "bun:sqlite";
+import { HTTPException } from "hono/http-exception";
+import { zValidator } from "@hono/zod-validator";
+//#region lib/engine/settings/tmp-dir.ts
+/**
+* Resolves the funnel temp/log root for the current OS. Defaults to
+* `<os.tmpdir()>/funnel` so Windows lands under `%TEMP%\funnel` and POSIX
+* lands under `/tmp/funnel`. Callers may override via `FUNNEL_TMP_DIR`.
+*/
+function funnelTmpDir() {
+	const override = process.env.FUNNEL_TMP_DIR;
+	if (override && override.length > 0) return override;
+	return join(tmpdir(), "funnel");
+}
+//#endregion
+//#region lib/gateway/publish-schema.ts
+/**
+* Shared schema for `POST /channels/:channel/publish` — used by both the
+* gateway route handler (input validation) and the CLI / programmable client
+* (request shape). The route resolves `channel` from the path; this body
+* covers everything else.
+*/
+const publishRequestSchema = z.object({
+	content: z.string().min(1),
+	meta: z.record(z.string(), z.string()).optional(),
+	connector: z.string().min(1).optional(),
+	/**
+	* Address the event to a single subscriber. When set, only the WS client that
+	* declared this id at upgrade time (`?id=<subscriberId>`) receives it. Omit for
+	* the default fanout. The route surfaces it to subscribers as `meta.target`.
+	*/
+	target: z.string().min(1).optional()
+});
+const publishResponseSchema = z.object({
+	ok: z.literal(true),
+	offset: z.number().int().nonnegative()
+});
+//#endregion
+//#region lib/gateway/channel-publisher.ts
+const OFFLINE = { state: "offline" };
+/**
+* HTTP client for `POST /channels/:channel/publish` on a running gateway
+* daemon. Returns `{ state: "offline" }` when the daemon isn't up so callers
+* can branch without exceptions, mirroring `FunnelListenersClient`.
+*/
+var FunnelChannelPublisher = class {
+	port;
+	isDaemonRunning;
+	getToken;
+	constructor(deps) {
+		this.port = deps.port;
+		this.isDaemonRunning = deps.isDaemonRunning;
+		this.getToken = deps.getToken ?? (() => null);
+		Object.freeze(this);
+	}
+	async publish(channelName, request) {
+		if (!this.isDaemonRunning()) return OFFLINE;
+		try {
+			const url = `http://127.0.0.1:${this.port}/channels/${encodeURIComponent(channelName)}/publish`;
+			const res = await fetch(url, {
+				method: "POST",
+				headers: {
+					...this.authHeaders(),
+					"content-type": "application/json"
+				},
+				body: JSON.stringify(request)
+			});
+			if (!res.ok) return {
+				state: "error",
+				reason: await res.text() || `HTTP ${res.status}`
+			};
+			const parsed = publishResponseSchema.safeParse(await res.json());
+			if (!parsed.success) return {
+				state: "error",
+				reason: "malformed daemon response"
+			};
+			return {
+				state: "ok",
+				offset: parsed.data.offset
+			};
+		} catch (error) {
+			return {
+				state: "error",
+				reason: error instanceof Error ? error.message : String(error)
+			};
+		}
+	}
+	authHeaders() {
+		const token = this.getToken();
+		return token ? { authorization: `Bearer ${token}` } : {};
+	}
+};
+//#endregion
+//#region lib/gateway/auth-middleware.ts
+/**
+* Verifies `Authorization: Bearer <token>` against the daemon's gateway token.
+* Mounted on the routes that mutate listener state or expose detailed status.
+* `/health` is intentionally left unauthenticated so the daemon manager can
+* probe liveness without needing the token.
+*/
+const requireBearerToken = (deps) => {
+	return async (c, next) => {
+		if (!constantTimeEqual((c.req.header("authorization") ?? "").match(/^Bearer\s+(.+)$/i)?.[1] ?? "", deps.expected)) return c.text("unauthorized", 401);
+		return await next();
+	};
+};
+const constantTimeEqual = (a, b) => {
+	const bufA = Buffer.from(a, "utf-8");
+	const bufB = Buffer.from(b, "utf-8");
+	const maxLen = Math.max(bufA.length, bufB.length, 1);
+	const padA = Buffer.alloc(maxLen);
+	const padB = Buffer.alloc(maxLen);
+	bufA.copy(padA);
+	bufB.copy(padB);
+	return timingSafeEqual(padA, padB) && bufA.length === bufB.length;
+};
+//#endregion
+//#region lib/gateway/factory.ts
+const factory = createFactory();
+//#endregion
+//#region lib/gateway/broadcaster.ts
+const byteLengthOf = (event) => {
+	let bytes = Buffer.byteLength(event.content, "utf-8");
+	if (event.meta) for (const [k, v] of Object.entries(event.meta)) bytes += Buffer.byteLength(k, "utf-8") + Buffer.byteLength(v, "utf-8");
+	return bytes;
+};
+const DEFAULT_MAX_BUFFERED_BYTES = 1024 * 1024;
+const DEFAULT_REPLAY_BUFFER_SIZE = 200;
+const DEFAULT_REPLAY_BUFFER_MAX_BYTES = 4 * 1024 * 1024;
+const defaultOnError$2 = () => {};
+/**
+* In-process pub/sub for connector events.
+*
+* Two outbound paths:
+*   - WS clients connected via the gateway's `/ws` endpoint, scoped per channel
+*   - In-process subscribers registered via `subscribe()` (programmable API)
+*
+* Backpressure: if a WS client's `bufferedAmount` exceeds `maxBufferedBytes`
+* (default 1 MiB), the client is closed with code 1009 and dropped from the
+* registry to keep one slow consumer from blocking the daemon.
+*
+* Replay: every emitted event gets a strictly increasing `offset`. The latest
+* `replayBufferSize` events are kept in memory; reconnecting WS clients can
+* pass `?since=<offset>` and the broadcaster resends matching events before
+* resuming the live stream. The in-memory ring covers short reconnects;
+* older history is served from the event log wired in as `persistentReplay`.
+*/
+var FunnelBroadcaster = class {
+	clients = /* @__PURE__ */ new Map();
+	subscribers = /* @__PURE__ */ new Set();
+	logger;
+	onError;
+	maxBufferedBytes;
+	now;
+	replayBufferSize;
+	replayBufferMaxBytes;
+	replayBuffer = [];
+	persistentReplay;
+	exclusiveCursor = /* @__PURE__ */ new Map();
+	replayBufferBytes = 0;
+	eventsBroadcast = 0;
+	droppedSlowClients = 0;
+	lastBroadcastAt = null;
+	latestOffset = 0;
+	constructor(deps = {}) {
+		this.logger = deps.logger;
+		this.onError = deps.onError ?? defaultOnError$2;
+		this.maxBufferedBytes = deps.maxBufferedBytes ?? DEFAULT_MAX_BUFFERED_BYTES;
+		this.now = deps.now ?? (() => Date.now());
+		this.replayBufferSize = Math.max(0, deps.replayBufferSize ?? DEFAULT_REPLAY_BUFFER_SIZE);
+		this.replayBufferMaxBytes = Math.max(0, deps.replayBufferMaxBytes ?? DEFAULT_REPLAY_BUFFER_MAX_BYTES);
+		this.persistentReplay = deps.persistentReplay ?? null;
+	}
+	getMetrics() {
+		return {
+			clients: this.clients.size,
+			subscribers: this.subscribers.size,
+			eventsBroadcast: this.eventsBroadcast,
+			droppedSlowClients: this.droppedSlowClients,
+			lastBroadcastAt: this.lastBroadcastAt ? new Date(this.lastBroadcastAt).toISOString() : null,
+			latestOffset: this.latestOffset,
+			oldestReplayableOffset: this.replayBuffer[0]?.offset ?? null
+		};
+	}
+	/**
+	* Returns events with offset > since, filtered by the connector subscription
+	* rules of `data`. Used at WS upgrade time when the client passes `?since=<offset>`.
+	*
+	* Two-tier lookup:
+	*   1. The in-memory ring buffer (covers short reconnects, last `replayBufferSize` events).
+	*   2. If `since` predates the oldest in-memory entry and a persistent replay source
+	*      is wired in (SQLite by default), the gap is filled from it. This covers reconnects
+	*      across daemon restarts where the in-memory buffer was lost.
+	*
+	* Result is sorted ascending by offset and de-duplicated against the in-memory buffer.
+	*/
+	replaySince(since, data) {
+		const oldestInMemory = this.replayBuffer[0]?.offset;
+		const needFallback = this.persistentReplay && (oldestInMemory === void 0 || since < oldestInMemory - 1);
+		const fromMemory = this.replayBuffer.filter((event) => event.offset > since && this.matchesClient(event, data));
+		if (!needFallback) return fromMemory;
+		const persisted = this.persistentReplay ? this.persistentReplay.loadSince(since).filter((event) => this.matchesClient(event, data)) : [];
+		const cutoff = oldestInMemory ?? Number.POSITIVE_INFINITY;
+		return [...persisted.filter((event) => event.offset < cutoff), ...fromMemory];
+	}
+	matchesClient(event, data) {
+		const target = event.meta?.target;
+		if (target && target !== data.subscriberId) return false;
+		const channelId = event.meta?.channelId;
+		if (channelId && channelId !== data.channel) return false;
+		const connector = event.meta?.connector;
+		if (!connector) return true;
+		return data.connectors.includes(connector);
+	}
+	/**
+	* Returns the list of WS clients that should receive `event`. For each per-channel group:
+	*   - fanout → every matching client receives
+	*   - exclusive → exactly one client receives, picked round-robin per channel
+	*
+	* `meta.target` narrows the recipient set via `matchesClient`: only the subscriber
+	* whose `subscriberId` equals `target` receives a targeted event.
+	*/
+	pickRecipients(event) {
+		const exclusiveByChannel = /* @__PURE__ */ new Map();
+		const recipients = [];
+		for (const [ws, data] of this.clients) {
+			if (!this.matchesClient(event, data)) continue;
+			if (data.delivery === "exclusive") {
+				const list = exclusiveByChannel.get(data.channel) ?? [];
+				list.push(ws);
+				exclusiveByChannel.set(data.channel, list);
+				continue;
+			}
+			recipients.push(ws);
+		}
+		for (const [channel, candidates] of exclusiveByChannel) {
+			if (candidates.length === 0) continue;
+			const cursor = this.exclusiveCursor.get(channel) ?? 0;
+			const picked = candidates[cursor % candidates.length];
+			if (picked) recipients.push(picked);
+			this.exclusiveCursor.set(channel, cursor + 1);
+		}
+		return recipients;
+	}
+	addClient(ws, data) {
+		this.clients.set(ws, data);
+	}
+	removeClient(ws) {
+		this.clients.delete(ws);
+	}
+	getClientCount() {
+		return this.clients.size;
+	}
+	listChannels() {
+		return [...this.clients.values()].map((d) => ({ ...d }));
+	}
+	subscribe(handler) {
+		this.subscribers.add(handler);
+		return () => {
+			this.subscribers.delete(handler);
+		};
+	}
+	broadcast(content, meta) {
+		this.latestOffset += 1;
+		const event = {
+			content,
+			meta,
+			offset: this.latestOffset
+		};
+		const payload = JSON.stringify(event);
+		meta?.connector;
+		this.eventsBroadcast += 1;
+		this.lastBroadcastAt = this.now();
+		if (this.replayBufferSize > 0) {
+			const eventBytes = byteLengthOf(event);
+			this.replayBuffer.push(event);
+			this.replayBufferBytes += eventBytes;
+			while ((this.replayBuffer.length > this.replayBufferSize || this.replayBufferBytes > this.replayBufferMaxBytes) && this.replayBuffer.length > 0) {
+				const dropped = this.replayBuffer.shift();
+				if (dropped) this.replayBufferBytes -= byteLengthOf(dropped);
+			}
+		}
+		const recipients = this.pickRecipients(event);
+		for (const ws of recipients) {
+			const buffered = ws.getBufferedAmount();
+			if (buffered > this.maxBufferedBytes) {
+				const data = this.clients.get(ws);
+				this.logger?.warn("dropping slow WS client (backpressure)", {
+					channel: data?.channel,
+					buffered,
+					max: this.maxBufferedBytes
+				});
+				try {
+					ws.close(1009, "backpressure");
+				} catch {}
+				this.clients.delete(ws);
+				this.droppedSlowClients += 1;
+				continue;
+			}
+			ws.send(payload);
+		}
+		for (const handler of this.subscribers) try {
+			handler(event);
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.logger?.error("broadcast subscriber threw", { error: err.message });
+			this.onError(err, {
+				component: "broadcaster.subscriber",
+				offset: event.offset,
+				connector: event.meta?.connector ?? null,
+				channel: event.meta?.channel ?? null
+			});
+		}
+		return event;
+	}
+	/** Forward-seed the offset counter (used at startup from the persisted event store). */
+	seedLatestOffset(offset) {
+		if (offset > this.latestOffset) this.latestOffset = offset;
+	}
+};
+//#endregion
+//#region lib/gateway/funnel-event-log.ts
+/**
+* Replayable event payload persisted by the gateway. Domain events the
+* broadcaster emits to WS clients land here so reconnects across daemon
+* restarts can be served from disk. System events (gateway start, channel
+* connected, etc.) are routed to `FunnelLogger` instead — they never go
+* through this log, which keeps the offset space clean for replay.
+*/
+const funnelEventSchema = z.object({
+	type: z.string(),
+	content: z.string(),
+	channel_id: z.string().nullable(),
+	connector_id: z.string().nullable(),
+	meta: z.record(z.string(), z.string()).nullable()
+});
+/**
+* Durable, append-only log of broadcaster events keyed by the offset the
+* broadcaster assigns. The gateway persists every domain event here, and
+* across restarts it both seeds the broadcaster's offset counter
+* (`findMaxOffset`) and serves reconnect replay (`loadSince`) from it.
+*
+* `loadSince` is the only method the broadcaster itself needs, which makes
+* any implementation assignable to the broadcaster's narrow `ReplaySource`.
+*
+* Implementations:
+*   - `SqliteFunnelEventLog` — the default; durable across daemon restarts.
+*   - `MemoryFunnelEventLog` — an in-process double for tests and embedders
+*     that do not need durability (replay is lost when the process exits).
+*/
+var FunnelEventLog = class {};
+//#endregion
+//#region lib/logger/leuco-logger-sqlite-sink.ts
+/** Conservative whitelist for column names interpolated into SQL. */
+const COLUMN_NAME_RE = /^[a-z_][a-z0-9_]*$/;
+/** How many inserts between on-disk size checks (see insertsSinceByteCheck). */
+const BYTE_CHECK_INTERVAL = 500;
+const RESERVED_COLUMNS = new Set([
+	"seq",
+	"ts",
+	"type",
+	"event"
+]);
+/**
+* Schema versions. Each entry is the list of DDL statements that take the
+* database from version i to version i + 1. Migrations run in a transaction
+* so a partial failure rolls back. Adding a new version is append-only —
+* never edit a published one. Caller-defined index columns are added
+* dynamically on construct (independent of versioned migrations) because
+* they are configuration, not schema evolution.
+*/
+const MIGRATIONS = [[
+	"CREATE TABLE IF NOT EXISTS leuco_log (seq INTEGER PRIMARY KEY, ts INTEGER NOT NULL, type TEXT, event TEXT NOT NULL)",
+	"CREATE INDEX IF NOT EXISTS idx_leuco_log_ts ON leuco_log (ts)",
+	"CREATE INDEX IF NOT EXISTS idx_leuco_log_type ON leuco_log (type)"
+]];
+/**
+* SQLite-backed sink built on `bun:sqlite`. Implements both primary and
+* relay roles so the same instance can own seq generation for one bus and
+* mirror records from another (e.g. cross-process replication, restore
+* from a backup stream).
+*
+* Concurrency model: seq is `INTEGER PRIMARY KEY`, so SQLite assigns it
+* atomically via `lastInsertRowid`. Two `LeucoLogger` instances pointed
+* at the same database file therefore see one monotonically increasing
+* seq stream without any bus-level coordination — the database itself is
+* the synchronization point.
+*
+* Schema is version-managed via `PRAGMA user_version`. Migrations are
+* append-only and run in a transaction on every construct so a partial
+* upgrade rolls back cleanly. Caller-defined `indexes` are layered on top
+* via `ALTER TABLE ADD COLUMN` + `CREATE INDEX IF NOT EXISTS`, so adding
+* a new index to an existing database is a no-downtime operation.
+*
+* Type safety: the second generic parameter `I` is the literal tuple of
+* index column names. `extractIndexes` and `getRecords({ where })` are
+* both type-checked against this tuple, so a typo at the call site is a
+* compile-time error rather than a silent miss at runtime.
+*
+* Retention is bounded by `maxRows` and/or `maxAgeMs`. Both run on every
+* insert as a single indexed DELETE that no-ops below the cap.
+*
+* Bulk inserts use `insertMany`, which wraps the batch in one transaction
+* for ~10–100x throughput at the cost of one fsync per batch instead of
+* one per row.
+*/
+var LeucoLoggerSqliteSink = class {
+	db;
+	maxRows;
+	maxAgeMs;
+	maxBytes;
+	targetBytes;
+	now;
+	indexes;
+	extractIndexes;
+	insertStmt;
+	insertWithSeqStmt;
+	maxSeqStmt;
+	countStmt;
+	trimRowsStmt;
+	trimAgeStmt;
+	trimOldestStmt;
+	insertsSinceByteCheck = 0;
+	constructor(props) {
+		this.db = new Database(props.path);
+		this.db.run("PRAGMA journal_mode = WAL");
+		this.migrate();
+		this.maxRows = props.maxRows ?? null;
+		this.maxAgeMs = props.maxAgeMs ?? null;
+		this.maxBytes = props.maxBytes ?? null;
+		this.targetBytes = props.targetBytes ?? (props.maxBytes !== void 0 ? Math.floor(props.maxBytes / 4) : null);
+		this.now = props.now ?? (() => Date.now());
+		this.indexes = props.indexes ?? [];
+		if (this.indexes.length > 0) {
+			validateIndexNames(this.indexes);
+			this.extractIndexes = props.extractIndexes ?? null;
+			this.syncIndexColumns();
+		} else this.extractIndexes = null;
+		const cols = [
+			"ts",
+			"type",
+			"event",
+			...this.indexes
+		];
+		const placeholders = cols.map(() => "?").join(", ");
+		this.insertStmt = this.db.prepare(`INSERT INTO leuco_log (${cols.join(", ")}) VALUES (${placeholders})`);
+		const colsWithSeq = ["seq", ...cols];
+		const placeholdersWithSeq = colsWithSeq.map(() => "?").join(", ");
+		this.insertWithSeqStmt = this.db.prepare(`INSERT INTO leuco_log (${colsWithSeq.join(", ")}) VALUES (${placeholdersWithSeq})`);
+		this.maxSeqStmt = this.db.prepare("SELECT COALESCE(MAX(seq), 0) AS max FROM leuco_log");
+		this.countStmt = this.db.prepare("SELECT COUNT(*) AS n FROM leuco_log");
+		this.trimRowsStmt = this.db.prepare("DELETE FROM leuco_log WHERE seq <= (SELECT seq FROM leuco_log ORDER BY seq DESC LIMIT 1 OFFSET ?)");
+		this.trimAgeStmt = this.db.prepare("DELETE FROM leuco_log WHERE ts < ?");
+		this.trimOldestStmt = this.db.prepare("DELETE FROM leuco_log WHERE seq IN (SELECT seq FROM leuco_log ORDER BY seq ASC LIMIT ?)");
+	}
+	insert(input) {
+		try {
+			const params = this.buildInsertParams(input.ts, input.event);
+			const result = this.insertStmt.run(...params);
+			const seq = Number(result.lastInsertRowid);
+			this.trim();
+			return {
+				seq,
+				ts: input.ts,
+				event: input.event
+			};
+		} catch (e) {
+			return e instanceof Error ? e : new Error(String(e));
+		}
+	}
+	insertMany(inputs) {
+		if (inputs.length === 0) return [];
+		try {
+			const records = [];
+			this.db.transaction((batch) => {
+				for (const input of batch) {
+					const params = this.buildInsertParams(input.ts, input.event);
+					const result = this.insertStmt.run(...params);
+					records.push({
+						seq: Number(result.lastInsertRowid),
+						ts: input.ts,
+						event: input.event
+					});
+				}
+			})(inputs);
+			this.trim();
+			return records;
+		} catch (e) {
+			return e instanceof Error ? e : new Error(String(e));
+		}
+	}
+	write(record) {
+		try {
+			const params = [record.seq, ...this.buildInsertParams(record.ts, record.event)];
+			this.insertWithSeqStmt.run(...params);
+			this.trim();
+		} catch (e) {
+			return e instanceof Error ? e : new Error(String(e));
+		}
+	}
+	getMaxSeq() {
+		const row = this.maxSeqStmt.get();
+		return row ? row.max : 0;
+	}
+	getRecords(props = {}) {
+		const conditions = ["seq > ?"];
+		const params = [props.sinceSeq ?? 0];
+		if (typeof props.type === "string") {
+			conditions.push("type = ?");
+			params.push(props.type);
+		}
+		if (props.where) this.appendWhereConditions(props.where, conditions, params);
+		const limit = props.limit ?? 1e3;
+		params.push(limit);
+		const dir = props.order === "desc" ? "DESC" : "ASC";
+		const sql = `SELECT seq, ts, type, event FROM leuco_log WHERE ${conditions.join(" AND ")} ORDER BY seq ${dir} LIMIT ?`;
+		const rows = this.db.prepare(sql).all(...params);
+		if (dir === "DESC") rows.reverse();
+		return rows.map(toRecord);
+	}
+	/**
+	* Current schema version. Useful for diagnostics and for tests that want
+	* to verify migrations ran. Reads `PRAGMA user_version` once per call.
+	*/
+	getSchemaVersion() {
+		return this.db.prepare("PRAGMA user_version").get()?.user_version ?? 0;
+	}
+	close() {
+		this.db.close();
+	}
+	buildInsertParams(ts, event) {
+		const type = extractType(event);
+		const json = JSON.stringify(event);
+		if (this.indexes.length === 0) return [
+			ts,
+			type,
+			json
+		];
+		const values = this.extractIndexes ? this.extractIndexes(event) : null;
+		return [
+			ts,
+			type,
+			json,
+			...this.indexes.map((col) => values?.[col] ?? null)
+		];
+	}
+	appendWhereConditions(where, conditions, params) {
+		const widened = where;
+		for (const col of this.indexes) {
+			const value = widened[col];
+			if (value === void 0) continue;
+			if (value === null) conditions.push(`${col} IS NULL`);
+			else {
+				conditions.push(`${col} = ?`);
+				params.push(value);
+			}
+		}
+	}
+	trim() {
+		if (this.maxRows !== null) {
+			const row = this.countStmt.get();
+			if (row && row.n > this.maxRows) this.trimRowsStmt.run(this.maxRows);
+		}
+		if (this.maxAgeMs !== null) this.trimAgeStmt.run(this.now() - this.maxAgeMs);
+		this.maybeTrimBytes();
+	}
+	/**
+	* Throttled byte-size enforcement. Only every BYTE_CHECK_INTERVAL inserts do
+	* we measure the file; on overflow we estimate how many of the oldest rows to
+	* drop to land near targetBytes (by the byte/row ratio), delete them in one
+	* statement, then VACUUM once to return the freed pages to the filesystem (a
+	* plain DELETE only frees pages inside the file). One DELETE + one VACUUM per
+	* overflow keeps the expensive rewrite rare — the file must refill the whole
+	* maxBytes→targetBytes delta before the next overflow can trigger.
+	*/
+	maybeTrimBytes() {
+		if (this.maxBytes === null || this.targetBytes === null) return;
+		this.insertsSinceByteCheck += 1;
+		if (this.insertsSinceByteCheck < BYTE_CHECK_INTERVAL) return;
+		this.insertsSinceByteCheck = 0;
+		const bytes = this.byteSize();
+		if (bytes <= this.maxBytes) return;
+		const rows = this.countStmt.get()?.n ?? 0;
+		if (rows === 0) return;
+		const bytesToFree = bytes - this.targetBytes;
+		const bytesPerRow = bytes / rows;
+		const rowsToDrop = Math.min(rows, Math.ceil(bytesToFree / bytesPerRow));
+		this.trimOldestStmt.run(rowsToDrop);
+		this.db.run("VACUUM");
+	}
+	byteSize() {
+		return (this.db.prepare("PRAGMA page_count").get()?.n ?? 0) * (this.db.prepare("PRAGMA page_size").get()?.n ?? 0);
+	}
+	/** Drop every row and reclaim the file space. Used by `<log>.clear()`. */
+	clear() {
+		this.db.run("DELETE FROM leuco_log");
+		this.db.run("VACUUM");
+		this.insertsSinceByteCheck = 0;
+	}
+	syncIndexColumns() {
+		const existing = new Set(this.db.prepare("PRAGMA table_info(leuco_log)").all().map((r) => r.name));
+		for (const col of this.indexes) {
+			if (!existing.has(col)) this.db.run(`ALTER TABLE leuco_log ADD COLUMN ${col} TEXT`);
+			this.db.run(`CREATE INDEX IF NOT EXISTS idx_leuco_log_${col} ON leuco_log (${col})`);
+		}
+	}
+	migrate() {
+		const current = this.db.prepare("PRAGMA user_version").get()?.user_version ?? 0;
+		if (current >= MIGRATIONS.length) return;
+		const pending = MIGRATIONS.slice(current);
+		let version = current;
+		for (const stmts of pending) {
+			version += 1;
+			this.db.transaction(() => {
+				for (const stmt of stmts) this.db.run(stmt);
+				this.db.run(`PRAGMA user_version = ${version}`);
+			})();
+		}
+	}
+};
+function validateIndexNames(names) {
+	for (const name of names) {
+		if (!COLUMN_NAME_RE.test(name)) throw new Error(`invalid index column name: ${name}`);
+		if (RESERVED_COLUMNS.has(name)) throw new Error(`reserved index column name: ${name}`);
+	}
+}
+function extractType(event) {
+	if (typeof event !== "object" || event === null) return null;
+	if (!("type" in event)) return null;
+	const t = event.type;
+	return typeof t === "string" ? t : null;
+}
+function toRecord(row) {
+	return {
+		seq: row.seq,
+		ts: row.ts,
+		event: JSON.parse(row.event)
+	};
+}
+//#endregion
+//#region lib/gateway/sqlite-funnel-event-log.ts
+const MAX_CONTENT_CHARS = 2e3;
+/**
+* SQLite-backed `FunnelEventLog`. One indexed table holds every broadcaster
+* event with `channel_id` and `connector_id` as dedicated columns, so
+* per-channel and per-connector replay is an indexed range scan.
+*
+* Concurrency: `seq` is `INTEGER PRIMARY KEY`, so SQLite assigns it
+* atomically. The broadcaster owns its own offset counter at runtime
+* (seeded from `findMaxOffset()` at startup); each broadcaster event
+* flows in here via `record()` with that pre-assigned offset, which the
+* sink stores via `write()` — PK uniqueness catches double-emit bugs.
+*
+* System events (gateway lifecycle, channel connect/disconnect, etc.) do
+* NOT go through this store. They are diagnostic only and live in
+* `FunnelLogger`'s file so the seq space here stays exclusive to
+* broadcaster traffic. This is what makes the broadcaster's seq seeding
+* (`getMaxSeq()` at startup) correct without per-event coordination.
+*/
+var SqliteFunnelEventLog = class extends FunnelEventLog {
+	sink;
+	now;
+	constructor(props) {
+		super();
+		this.now = props.now ?? (() => Date.now());
+		this.sink = new LeucoLoggerSqliteSink({
+			path: props.path,
+			indexes: ["channel_id", "connector_id"],
+			extractIndexes: (event) => ({
+				channel_id: event.channel_id,
+				connector_id: event.connector_id
+			}),
+			now: this.now,
+			...props.maxRows !== void 0 ? { maxRows: props.maxRows } : {},
+			...props.maxAgeMs !== void 0 ? { maxAgeMs: props.maxAgeMs } : {},
+			...props.maxBytes !== void 0 ? { maxBytes: props.maxBytes } : {},
+			...props.targetBytes !== void 0 ? { targetBytes: props.targetBytes } : {}
+		});
+	}
+	/**
+	* Persist a broadcaster-driven event with its assigned offset. Caller
+	* (the gateway-server) supplies the offset from `broadcaster.broadcast()`
+	* so this store and the broadcaster's in-memory ring stay aligned.
+	*/
+	record(record) {
+		const event = {
+			type: record.meta?.event_type ?? "unknown",
+			content: truncate(record.content),
+			channel_id: record.channelId,
+			connector_id: record.connectorId,
+			meta: record.meta
+		};
+		this.sink.write({
+			seq: record.offset,
+			ts: this.now(),
+			event
+		});
+	}
+	/**
+	* Returns events with offset > since. Filtering by channel/connector is
+	* the broadcaster's responsibility (it knows the client's subscription),
+	* so this returns the full slice and lets the caller filter.
+	*/
+	loadSince(since) {
+		const records = this.sink.getRecords({ sinceSeq: since });
+		const out = [];
+		for (const record of records) out.push({
+			content: record.event.content,
+			meta: record.event.meta ?? void 0,
+			offset: record.seq
+		});
+		return out;
+	}
+	/**
+	* Returns events for one channel (and optionally one connector). Used
+	* by the gateway logs CLI for scoped queries. Channel/connector filters
+	* are indexed columns, so this is an indexed range scan.
+	*/
+	loadForChannel(props) {
+		const where = { channel_id: props.channelId };
+		if (props.connectorId !== void 0) where.connector_id = props.connectorId;
+		const records = this.sink.getRecords({
+			where,
+			...props.sinceSeq !== void 0 ? { sinceSeq: props.sinceSeq } : {},
+			...props.limit !== void 0 ? { limit: props.limit } : {}
+		});
+		const out = [];
+		for (const record of records) out.push({
+			content: record.event.content,
+			meta: record.event.meta ?? void 0,
+			offset: record.seq
+		});
+		return out;
+	}
+	findMaxOffset() {
+		return this.sink.getMaxSeq();
+	}
+	clear() {
+		this.sink.clear();
+	}
+	close() {
+		this.sink.close();
+	}
+};
+function truncate(content) {
+	if (content.length <= MAX_CONTENT_CHARS) return content;
+	return `${content.slice(0, MAX_CONTENT_CHARS)}...`;
+}
+//#endregion
+//#region lib/gateway/listener-supervisor.ts
+const defaultOnError$1 = () => {};
+const DEFAULT_HEALTH_INTERVAL_MS = 3e4;
+const DEFAULT_MAX_BACKOFF_MS = 6e4;
+const defaultSleep = (ms) => new Promise((r) => {
+	setTimeout(r, ms);
+});
+/**
+* Owns the running listener instances and their lifecycle.
+*
+* Lives in the gateway process and is the only place that calls
+* `listener.start()` / `listener.stop()`. Each entry is keyed by
+* `${channelName}/${connectorName}` so the same connector name can exist in
+* multiple channels without colliding.
+*
+* Periodically polls each running listener's `isAlive()` and auto-restarts
+* dead listeners with exponential backoff (1s, 2s, 4s, ... capped). Resets
+* the backoff counter on successful restart.
+*/
+var FunnelListenerSupervisor = class FunnelListenerSupervisor {
+	channels;
+	notify;
+	logger;
+	onError;
+	running = /* @__PURE__ */ new Map();
+	failureCounts = /* @__PURE__ */ new Map();
+	stats = /* @__PURE__ */ new Map();
+	healthCheckIntervalMs;
+	maxBackoffMs;
+	sleep;
+	now;
+	healthCheckTimer = null;
+	healthCheckInFlight = false;
+	constructor(deps) {
+		this.channels = deps.channels;
+		this.notify = deps.notify;
+		this.logger = deps.logger;
+		this.onError = deps.onError ?? defaultOnError$1;
+		this.healthCheckIntervalMs = deps.healthCheckIntervalMs ?? DEFAULT_HEALTH_INTERVAL_MS;
+		this.maxBackoffMs = deps.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+		this.sleep = deps.sleep ?? defaultSleep;
+		this.now = deps.now ?? (() => Date.now());
+	}
+	static keyOf(channelName, connectorName) {
+		return `${channelName}/${connectorName}`;
+	}
+	isRunning(channelName, connectorName) {
+		return this.running.has(FunnelListenerSupervisor.keyOf(channelName, connectorName));
+	}
+	list() {
+		return [...this.running.entries()].map(([key, entry]) => {
+			const stats = this.stats.get(key);
+			return {
+				channelName: entry.channelName,
+				channelId: entry.channelId,
+				name: entry.config.name,
+				type: entry.config.type,
+				alive: entry.listener.isAlive(),
+				events: stats?.events ?? 0,
+				errors: stats?.errors ?? 0,
+				failureCount: this.failureCounts.get(key) ?? 0,
+				lastEventAt: stats?.lastEventAt ?? null
+			};
+		});
+	}
+	async start(channelName, connectorName) {
+		const key = FunnelListenerSupervisor.keyOf(channelName, connectorName);
+		if (this.running.has(key)) return {
+			ok: true,
+			reason: "already running"
+		};
+		const created = this.channels.createListener(channelName, connectorName);
+		if (!created) return {
+			ok: false,
+			reason: `connector "${connectorName}" not found in channel "${channelName}"`
+		};
+		const bind = async (content, meta) => {
+			try {
+				await this.notify(channelName, connectorName, content, meta);
+				this.recordEvent(key);
+			} catch (error) {
+				this.recordError(key);
+				throw error;
+			}
+		};
+		try {
+			await created.listener.start(bind);
+			this.running.set(key, {
+				config: created.config,
+				channelName,
+				channelId: created.channelId,
+				listener: created.listener
+			});
+			this.ensureStats(key);
+			this.logger?.info(`${created.config.type} listener started`, {
+				channel: channelName,
+				connector: connectorName
+			});
+			return { ok: true };
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.logger?.error(`${created.config.type} listener failed to start`, {
+				channel: channelName,
+				connector: connectorName,
+				error: err.message
+			});
+			this.onError(err, {
+				component: "listener-supervisor.start",
+				channel: channelName,
+				connector: connectorName,
+				type: created.config.type
+			});
+			return {
+				ok: false,
+				reason: err.message
+			};
+		}
+	}
+	async stop(channelName, connectorName) {
+		const key = FunnelListenerSupervisor.keyOf(channelName, connectorName);
+		const entry = this.running.get(key);
+		if (!entry) return {
+			ok: true,
+			reason: "not running"
+		};
+		try {
+			await entry.listener.stop();
+			this.running.delete(key);
+			this.failureCounts.delete(key);
+			this.logger?.info(`${entry.config.type} listener stopped`, {
+				channel: channelName,
+				connector: connectorName
+			});
+			return { ok: true };
+		} catch (error) {
+			const err = error instanceof Error ? error : new Error(String(error));
+			this.logger?.error(`${entry.config.type} listener failed to stop`, {
+				channel: channelName,
+				connector: connectorName,
+				error: err.message
+			});
+			this.onError(err, {
+				component: "listener-supervisor.stop",
+				channel: channelName,
+				connector: connectorName,
+				type: entry.config.type
+			});
+			return {
+				ok: false,
+				reason: err.message
+			};
+		}
+	}
+	async restart(channelName, connectorName) {
+		const stopped = await this.stop(channelName, connectorName);
+		if (!stopped.ok) return stopped;
+		return await this.start(channelName, connectorName);
+	}
+	async startAll() {
+		const all = this.channels.listAllConnectors();
+		for (const view of all) await this.start(view.channelName, view.name);
+		this.startHealthCheck();
+	}
+	async stopAll() {
+		this.stopHealthCheck();
+		for (const [, entry] of [...this.running.entries()]) await this.stop(entry.channelName, entry.config.name);
+	}
+	ensureStats(key) {
+		const existing = this.stats.get(key);
+		if (existing) return existing;
+		const fresh = {
+			events: 0,
+			errors: 0,
+			failureCount: 0,
+			lastEventAt: null
+		};
+		this.stats.set(key, fresh);
+		return fresh;
+	}
+	recordEvent(key) {
+		const stats = this.ensureStats(key);
+		stats.events += 1;
+		stats.lastEventAt = new Date(this.now()).toISOString();
+	}
+	recordError(key) {
+		this.ensureStats(key).errors += 1;
+	}
+	startHealthCheck() {
+		if (this.healthCheckTimer) return;
+		this.healthCheckTimer = setInterval(() => {
+			this.runHealthCheck();
+		}, this.healthCheckIntervalMs);
+		this.healthCheckTimer.unref();
+	}
+	stopHealthCheck() {
+		if (!this.healthCheckTimer) return;
+		clearInterval(this.healthCheckTimer);
+		this.healthCheckTimer = null;
+	}
+	async runHealthCheck() {
+		if (this.healthCheckInFlight) return;
+		this.healthCheckInFlight = true;
+		try {
+			for (const [key, entry] of [...this.running.entries()]) {
+				if (entry.listener.isAlive()) {
+					this.failureCounts.delete(key);
+					continue;
+				}
+				await this.recoverDead(entry.channelName, entry.config.name, entry.config.type);
+			}
+		} finally {
+			this.healthCheckInFlight = false;
+		}
+	}
+	async recoverDead(channelName, connectorName, type) {
+		const key = FunnelListenerSupervisor.keyOf(channelName, connectorName);
+		const failureCount = this.failureCounts.get(key) ?? 0;
+		const backoffMs = Math.min(1e3 * 2 ** failureCount, this.maxBackoffMs);
+		this.logger?.warn(`${type} listener unhealthy, restarting`, {
+			channel: channelName,
+			connector: connectorName,
+			attempt: failureCount + 1,
+			backoffMs
+		});
+		await this.stop(channelName, connectorName);
+		await this.sleep(backoffMs);
+		if ((await this.start(channelName, connectorName)).ok) {
+			this.failureCounts.delete(key);
+			this.logger?.info(`${type} listener recovered`, {
+				channel: channelName,
+				connector: connectorName
+			});
+		} else this.failureCounts.set(key, failureCount + 1);
+	}
+};
+//#endregion
+//#region lib/gateway/kill-competing-slack-gateways.ts
+const defaultProcess = new NodeFunnelProcessRunner();
+const titleFor = (dir) => `funnel-gateway[${dir}]`;
+/**
+* Kills other funnel daemon processes that share the SAME funnel home dir,
+* which is the only situation that causes a real conflict (duplicate Slack
+* Socket Mode connections with the same tokens). Daemons rooted at a
+* different `~/.funnel/` are left alone — they hold different tokens and
+* speak to different Slack apps. The daemon advertises its dir via the
+* `funnel-gateway[<dir>]` marker appended to argv (also assigned to
+* `process.title` on POSIX). `FunnelProcessRunner.listProcessesContaining`
+* absorbs the POSIX/Windows enumeration difference behind the marker match.
+*/
+const killCompetingSlackGateways = async (props) => {
+	const runner = props.process ?? defaultProcess;
+	const logger = props.logger;
+	const expectedTitle = titleFor(props.dir);
+	const snapshots = runner.listProcessesContaining(expectedTitle);
+	const killed = [];
+	for (const snapshot of snapshots) {
+		if (snapshot.pid === props.selfPid) continue;
+		runner.kill(snapshot.pid, "SIGTERM");
+		killed.push(snapshot.pid);
+		logger?.info("killed competing Slack gateway process", {
+			pid: snapshot.pid,
+			args: snapshot.command.slice(0, 160)
+		});
+	}
+	return killed;
+};
+//#endregion
+//#region lib/gateway/routes/validator.ts
+/**
+* Path-param validator for gateway routes. On failure it answers with the same
+* `{ ok: false, reason }` shape the listener routes already use, so
+* `FunnelListenersClient` can surface the message without special-casing.
+*/
+const zParam = (schema) => zValidator("param", schema, (result, c) => {
+	if (result.success) return;
+	const issue = result.error.issues[0];
+	const reason = issue ? `${issue.path.join(".")}: ${issue.message}` : "invalid request";
+	return c.json({
+		ok: false,
+		reason
+	}, 400);
+});
+//#endregion
+//#region lib/gateway/routes/channels.connectors.call.ts
+const bodySchema = z.object({
+	method: z.string().min(1),
+	path: z.string().min(1),
+	body: z.unknown().optional()
+});
+/**
+* POST /channels/:channel/connectors/:connector/call
+*
+* Generic adapter call. Used by the funnel MCP server (running in the Claude
+* Code process) to send replies/reactions/etc. without spawning a CLI
+* subprocess. Mirrors the CLI's `funnel channels <c> connectors <conn> request
+* --method=...` but with a structured JSON body and no shell.
+*/
+const channelsConnectorsCallHandler = factory.createHandlers(zParam(z.object({
+	channel: z.string().min(1),
+	connector: z.string().min(1)
+})), async (c) => {
+	const param = c.req.valid("param");
+	const raw = await c.req.json().catch(() => null);
+	const parsed = bodySchema.safeParse(raw);
+	if (!parsed.success) throw new HTTPException(400, { message: parsed.error.issues[0]?.message ?? "invalid body" });
+	const result = await c.var.deps.channels.call(param.channel, param.connector, {
+		method: parsed.data.method,
+		path: parsed.data.path,
+		body: parsed.data.body ?? {}
+	});
+	return c.json({
+		ok: true,
+		result
+	});
+});
+//#endregion
+//#region lib/gateway/routes/channels.publish.ts
+/**
+* POST /channels/:channel/publish
+*
+* Inject arbitrary content into a channel. Mirrors the connector-driven `notify`
+* path: events go through `broadcaster.broadcast` + `eventLog.record`, so
+* subscribers see them exactly as if a listener had produced them.
+*
+* Body validation is Zod-shared with the client (`publishRequestSchema`); the
+* response (`publishResponseSchema`) carries the assigned offset so callers can
+* correlate with the persistent event store.
+*/
+const channelsPublishHandler = factory.createHandlers(zParam(z.object({ channel: z.string().min(1) })), zValidator("json", publishRequestSchema, (result, c) => {
+	if (result.success) return;
+	const issue = result.error.issues[0];
+	const reason = issue ? `${issue.path.join(".")}: ${issue.message}` : "invalid body";
+	return c.json({
+		ok: false,
+		reason
+	}, 400);
+}), (c) => {
+	const param = c.req.valid("param");
+	const body = c.req.valid("json");
+	const meta = body.target ? {
+		...body.meta,
+		target: body.target
+	} : body.meta;
+	const response = {
+		ok: true,
+		offset: c.var.deps.emit({
+			channel: param.channel,
+			connector: body.connector,
+			content: body.content,
+			meta
+		}).offset
+	};
+	return c.json(response);
+});
+//#endregion
+//#region lib/gateway/connector-diagnostic-sql-reader.ts
+/**
+* Read-only SQL surface over the three diagnostic tables, for Claude to query
+* the log with arbitrary `SELECT`s. It opens all files read-only and exposes
+* three views — `raw`, `processed`, `connection` — that hide the storage
+* details (the physical table is `leuco_log` and each row's columns live
+* inside a JSON `event` blob): the views surface the columns as plain fields,
+* with `payload` already pulled out of the nested JSON.
+*
+* The tables are separate files. `raw` and `processed` share an `event_id`,
+* so a `JOIN` answers "the event arrived, but what verdict did it get?";
+* `connection` answers the other half — "did the listener ever connect at
+* all?". Writes are impossible: the connection is read-only and `query`
+* rejects anything but a single `SELECT`.
+*/
+var ConnectorDiagnosticSqlReader = class {
+	db;
+	constructor(props) {
+		const db = new Database(props.rawPath, { readonly: true });
+		try {
+			db.run("PRAGMA busy_timeout = 500");
+			db.prepare("ATTACH DATABASE ? AS processeddb").run(props.processedPath);
+			db.prepare("ATTACH DATABASE ? AS connectiondb").run(props.connectionPath);
+			db.run(rawViewSql);
+			db.run(processedViewSql);
+			db.run(connectionViewSql);
+		} catch (error) {
+			db.close();
+			throw error;
+		}
+		this.db = db;
+		Object.freeze(this);
+	}
+	/**
+	* Run one read-only `SELECT` and return the rows. Returns an `Error` (rather
+	* than throwing) for a non-SELECT statement or a SQL error, so the caller
+	* can surface the message without a stack trace.
+	*/
+	query(sql, params = []) {
+		const trimmed = sql.trim().replace(/;$/, "").trim();
+		if (!/^select\b/i.test(trimmed)) return /* @__PURE__ */ new Error("only a single SELECT statement is allowed");
+		if (trimmed.includes(";")) return /* @__PURE__ */ new Error("only a single statement is allowed (remove the ';')");
+		try {
+			return this.db.prepare(trimmed).all(...params);
+		} catch (error) {
+			return error instanceof Error ? error : new Error(String(error));
+		}
+	}
+	close() {
+		this.db.close();
+	}
+};
+const rawViewSql = `CREATE TEMP VIEW raw AS SELECT
+  seq,
+  ts,
+  json_extract(event, '$.event_id')     AS event_id,
+  json_extract(event, '$.type')         AS type,
+  json_extract(event, '$.connector_id') AS connector_id,
+  json_extract(event, '$.channel_id')   AS channel_id,
+  json_extract(event, '$.payload')      AS payload
+FROM main.leuco_log`;
+const processedViewSql = `CREATE TEMP VIEW processed AS SELECT
+  seq,
+  ts,
+  json_extract(event, '$.event_id')     AS event_id,
+  json_extract(event, '$.type')         AS type,
+  json_extract(event, '$.connector_id') AS connector_id,
+  json_extract(event, '$.channel_id')   AS channel_id,
+  json_extract(event, '$.outcome')      AS outcome,
+  json_extract(event, '$.payload')      AS payload
+FROM processeddb.leuco_log`;
+const connectionViewSql = `CREATE TEMP VIEW connection AS SELECT
+  seq,
+  ts,
+  json_extract(event, '$.type')         AS type,
+  json_extract(event, '$.connector_id') AS connector_id,
+  json_extract(event, '$.channel_id')   AS channel_id,
+  json_extract(event, '$.status')       AS status,
+  json_extract(event, '$.detail')       AS detail
+FROM connectiondb.leuco_log`;
+//#endregion
+//#region lib/gateway/routes/debug.ts
+const extractPreview = (payload) => {
+	if (typeof payload !== "string" || payload.length === 0) return null;
+	try {
+		const parsed = JSON.parse(payload);
+		if (parsed !== null && typeof parsed === "object" && "text" in parsed) {
+			const text = String(parsed.text);
+			return text.length > 80 ? `${text.slice(0, 80)}…` : text;
+		}
+	} catch {
+		return payload.length > 80 ? `${payload.slice(0, 80)}…` : payload;
+	}
+	return payload.length > 80 ? `${payload.slice(0, 80)}…` : payload;
+};
+const buildChannelDiagnosis = (channel) => {
+	const rootCause = (channel.connectionErrors[channel.connectionErrors.length - 1] ?? null)?.detail ?? null;
+	if (channel.connectors.length === 0) return {
+		status: "warn",
+		message: "no connectors configured on this channel",
+		nextActions: [`fnl channels ${channel.name} connectors add <name> --type=slack ...`],
+		rootCause: null
+	};
+	if (!channel.listener) return {
+		status: "error",
+		message: "no listener running for this channel",
+		nextActions: ["fnl gateway restart"],
+		rootCause
+	};
+	if (!channel.listener.alive) return {
+		status: "error",
+		message: "listener is dead",
+		nextActions: ["fnl gateway logs", "fnl gateway restart"],
+		rootCause
+	};
+	if (channel.claudeClients === 0) return {
+		status: "warn",
+		message: "no Claude connected to this channel",
+		nextActions: [`fnl claude --channel ${channel.name}`],
+		rootCause: null
+	};
+	if (channel.listener.errors > 0) return {
+		status: "warn",
+		message: "listener has errors",
+		nextActions: ["fnl gateway logs"],
+		rootCause
+	};
+	return {
+		status: "ok",
+		message: "healthy",
+		nextActions: [],
+		rootCause: null
+	};
+};
+/** GET /debug[?channel=<name>] — per-channel diagnosis with recent events. Used by MCP fnl_debug tool. */
+const debugHandler = factory.createHandlers(async (c) => {
+	const deps = c.var.deps;
+	const channelFilter = c.req.query("channel") ?? null;
+	const allChannels = deps.channels.list();
+	const targetChannels = channelFilter ? allChannels.filter((ch) => ch.name === channelFilter || ch.id === channelFilter) : allChannels;
+	const gatewayListeners = deps.supervisor.list();
+	const gatewayClients = deps.broadcaster.listChannels();
+	const metrics = deps.broadcaster.getMetrics();
+	const tmpDir = funnelTmpDir();
+	const rawPath = join(tmpDir, "connector-raw.db");
+	const processedPath = join(tmpDir, "connector-processed.db");
+	const connectionPath = join(tmpDir, "connector-connection.db");
+	const hasStore = existsSync(rawPath) && existsSync(processedPath) && existsSync(connectionPath);
+	const channels = targetChannels.map((ch) => {
+		const listenerEntry = gatewayListeners.find((l) => l.channelName === ch.name) ?? null;
+		const listener = listenerEntry ? {
+			alive: listenerEntry.alive,
+			events: listenerEntry.events,
+			errors: listenerEntry.errors,
+			lastEventAt: listenerEntry.lastEventAt
+		} : null;
+		const claudeClients = gatewayClients.filter((cl) => cl.channel === ch.id || cl.channel === ch.name).length;
+		const recentEvents = [];
+		const connectionErrors = [];
+		if (hasStore) {
+			const reader = new ConnectorDiagnosticSqlReader({
+				rawPath,
+				processedPath,
+				connectionPath
+			});
+			const rows = (() => {
+				try {
+					return reader.query("SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT 10", [ch.id]);
+				} finally {
+					reader.close();
+				}
+			})();
+			if (!(rows instanceof Error)) for (const row of [...rows].reverse()) {
+				const rawPayload = typeof row.payload === "string" ? row.payload : null;
+				let payloadParsed = null;
+				if (rawPayload) try {
+					const parsed = JSON.parse(rawPayload);
+					if (parsed !== null && typeof parsed === "object" && !Array.isArray(parsed)) payloadParsed = parsed;
+				} catch {
+					payloadParsed = null;
+				}
+				recentEvents.push({
+					seq: typeof row.seq === "number" ? row.seq : null,
+					ts: typeof row.ts === "number" ? row.ts : null,
+					type: typeof row.type === "string" ? row.type : "?",
+					outcome: typeof row.outcome === "string" ? row.outcome : "?",
+					payload: rawPayload,
+					payloadParsed,
+					preview: extractPreview(row.payload)
+				});
+			}
+			if (listener && (!listener.alive || listener.errors > 0) || !listener) {
+				const errReader = new ConnectorDiagnosticSqlReader({
+					rawPath,
+					processedPath,
+					connectionPath
+				});
+				const errRows = (() => {
+					try {
+						return errReader.query("SELECT ts, type, status, detail FROM connection WHERE channel_id = ? AND status IN ('auth-failed','error') ORDER BY seq DESC LIMIT 3", [ch.id]);
+					} finally {
+						errReader.close();
+					}
+				})();
+				if (!(errRows instanceof Error)) for (const row of [...errRows].reverse()) connectionErrors.push({
+					ts: typeof row.ts === "number" ? row.ts : null,
+					type: typeof row.type === "string" ? row.type : "?",
+					status: typeof row.status === "string" ? row.status : "?",
+					detail: typeof row.detail === "string" && row.detail.length > 0 ? row.detail : null
+				});
+			}
+		}
+		const base = {
+			id: ch.id,
+			name: ch.name,
+			connectors: ch.connectors.map((conn) => conn.name),
+			listener,
+			claudeClients,
+			recentEvents,
+			connectionErrors
+		};
+		return {
+			...base,
+			diagnosis: buildChannelDiagnosis(base)
+		};
+	});
+	return c.json({
+		pid: deps.selfPid,
+		uptimeMs: deps.uptimeMs(),
+		eventsBroadcast: metrics.eventsBroadcast,
+		channels
+	});
+});
+//#endregion
+//#region lib/gateway/routes/health.ts
+/** GET /health — liveness + listener registry snapshot. */
+const healthHandler = factory.createHandlers((c) => {
+	const deps = c.var.deps;
+	return c.json({
+		ok: true,
+		pid: deps.selfPid,
+		clients: deps.broadcaster.getClientCount(),
+		listeners: deps.supervisor.list()
+	});
+});
+//#endregion
+//#region lib/gateway/routes/listeners.list.ts
+/** GET /listeners — running connector listeners with alive/dead status. */
+const listenersListHandler = factory.createHandlers((c) => {
+	return c.json({ listeners: c.var.deps.supervisor.list() });
+});
+//#endregion
+//#region lib/gateway/routes/listeners.restart.ts
+/** POST /listeners/:channel/:connector/restart — stop + start a connector listener. */
+const listenersRestartHandler = factory.createHandlers(zParam(z.object({
+	channel: z.string().min(1),
+	connector: z.string().min(1)
+})), async (c) => {
+	const param = c.req.valid("param");
+	const result = await c.var.deps.supervisor.restart(param.channel, param.connector);
+	return c.json(result, result.ok ? 200 : 400);
+});
+//#endregion
+//#region lib/gateway/routes/listeners.start.ts
+/** POST /listeners/:channel/:connector/start — start a connector listener. */
+const listenersStartHandler = factory.createHandlers(zParam(z.object({
+	channel: z.string().min(1),
+	connector: z.string().min(1)
+})), async (c) => {
+	const param = c.req.valid("param");
+	const result = await c.var.deps.supervisor.start(param.channel, param.connector);
+	return c.json(result, result.ok ? 200 : 400);
+});
+//#endregion
+//#region lib/gateway/routes/listeners.stop.ts
+/** DELETE /listeners/:channel/:connector — stop a connector listener. */
+const listenersStopHandler = factory.createHandlers(zParam(z.object({
+	channel: z.string().min(1),
+	connector: z.string().min(1)
+})), async (c) => {
+	const param = c.req.valid("param");
+	const result = await c.var.deps.supervisor.stop(param.channel, param.connector);
+	return c.json(result, result.ok ? 200 : 400);
+});
+//#endregion
+//#region lib/gateway/routes/status.ts
+/** GET /status — listener registry, connected channels, and broadcaster metrics. */
+const statusHandler = factory.createHandlers((c) => {
+	const deps = c.var.deps;
+	return c.json({
+		ok: true,
+		pid: deps.selfPid,
+		uptimeMs: deps.uptimeMs(),
+		clients: deps.broadcaster.listChannels(),
+		listeners: deps.supervisor.list(),
+		broadcaster: deps.broadcaster.getMetrics()
+	});
+});
+//#endregion
+//#region lib/gateway/routes/index.ts
+function buildGatewayRoutes() {
+	return factory.createApp().get("/health", ...healthHandler).get("/status", ...statusHandler).get("/debug", ...debugHandler).get("/listeners", ...listenersListHandler).post("/listeners/:channel/:connector/start", ...listenersStartHandler).delete("/listeners/:channel/:connector", ...listenersStopHandler).post("/listeners/:channel/:connector/restart", ...listenersRestartHandler).post("/channels/:channel/connectors/:connector/call", ...channelsConnectorsCallHandler).post("/channels/:channel/publish", ...channelsPublishHandler);
+}
+const gatewayRoutes = buildGatewayRoutes();
+//#endregion
+//#region lib/gateway/gateway-server.ts
+const DEFAULT_HOST = "127.0.0.1";
+const LOOPBACK_HOSTS = new Set([
+	"127.0.0.1",
+	"localhost",
+	"::1",
+	"::ffff:127.0.0.1"
+]);
+const defaultDbPath = () => join(funnelTmpDir(), "events.db");
+const defaultOnError = () => {};
+/**
+* In-process gateway: runs `Bun.serve` (HTTP + WebSocket /ws), boots connector
+* listeners through `FunnelListenerSupervisor`, fans events out via
+* `FunnelBroadcaster`, and persists them via a `FunnelEventLog` (SQLite by default).
+* System events (gateway lifecycle, connect/disconnect) flow to `FunnelLogger`
+* instead — keeping the SQLite seq space exclusive to broadcaster traffic so
+* the broadcaster's offset counter and `getMaxSeq()` stay aligned without
+* per-event coordination. Exposes `/listeners` HTTP for runtime
+* start/stop/restart of individual connectors.
+*/
+var FunnelGatewayServer = class {
+	channels;
+	port;
+	hostname;
+	dbPath;
+	process;
+	logger;
+	onError;
+	selfPid;
+	dir;
+	killCompetingSlack;
+	token;
+	broadcaster;
+	eventLog;
+	supervisor;
+	nowMs;
+	extraRoutes;
+	startedAt = null;
+	server = null;
+	constructor(deps) {
+		this.channels = deps.channels;
+		this.port = deps.port ?? resolveFunnelPort();
+		this.hostname = deps.hostname ?? DEFAULT_HOST;
+		this.dbPath = deps.dbPath ?? defaultDbPath();
+		this.process = deps.process;
+		this.logger = deps.logger;
+		this.onError = deps.onError ?? defaultOnError;
+		this.selfPid = deps.selfPid ?? globalThis.process.pid;
+		this.dir = deps.dir ?? FUNNEL_DIR;
+		this.killCompetingSlack = deps.killCompetingSlack ?? true;
+		this.token = deps.token ?? "";
+		this.extraRoutes = deps.extraRoutes ?? null;
+		const clock = deps.clock;
+		this.nowMs = clock ? () => clock.millis() : () => Date.now();
+		if (deps.eventLog) this.eventLog = deps.eventLog;
+		else {
+			const dbDir = dirname(this.dbPath);
+			if (!existsSync(dbDir)) mkdirSync(dbDir, { recursive: true });
+			this.eventLog = new SqliteFunnelEventLog({
+				path: this.dbPath,
+				now: this.nowMs
+			});
+		}
+		this.broadcaster = new FunnelBroadcaster({
+			logger: this.logger,
+			onError: this.onError,
+			now: this.nowMs,
+			persistentReplay: this.eventLog
+		});
+		this.broadcaster.seedLatestOffset(this.eventLog.findMaxOffset());
+		this.supervisor = new FunnelListenerSupervisor({
+			channels: this.channels,
+			logger: this.logger,
+			onError: this.onError,
+			notify: async (channelName, connectorName, content, meta) => {
+				this.emit({
+					channel: channelName,
+					connector: connectorName,
+					content,
+					meta
+				});
+			},
+			now: this.nowMs
+		});
+	}
+	async start() {
+		if (this.server) return this.server;
+		if (!this.token && !LOOPBACK_HOSTS.has(this.hostname)) this.logger?.warn("gateway auth is disabled on a non-loopback bind — every endpoint is reachable without a token", { hostname: this.hostname });
+		const app = this.buildApp();
+		this.startedAt = this.nowMs();
+		this.server = Bun.serve({
+			port: this.port,
+			hostname: this.hostname,
+			development: false,
+			fetch: (request, server) => this.handleFetch(request, server, app),
+			websocket: {
+				open: (ws) => this.handleWsOpen(ws),
+				close: (ws) => this.handleWsClose(ws),
+				message() {}
+			}
+		});
+		this.logServerStarted();
+		await this.bootListeners();
+		return this.server;
+	}
+	async stop() {
+		await this.supervisor.stopAll();
+		if (this.server) {
+			this.server.stop();
+			this.server = null;
+		}
+	}
+	getStatus() {
+		return {
+			clients: this.broadcaster.getClientCount(),
+			channels: this.broadcaster.listChannels()
+		};
+	}
+	getBroadcaster() {
+		return this.broadcaster;
+	}
+	getSupervisor() {
+		return this.supervisor;
+	}
+	getEventLog() {
+		return this.eventLog;
+	}
+	/**
+	* Register an in-process observer for every broadcast event. Fires after
+	* the event is fanned out to WS clients and recorded in the event log.
+	* Returns an unsubscribe function. Only meaningful in-process (embedded
+	* hosts / `new Funnel(...)` running their own gateway-server); a separate
+	* daemon process cannot be observed this way — use a WS client for that.
+	*/
+	onEvent(handler) {
+		return this.broadcaster.subscribe(handler);
+	}
+	handleFetch(request, server, app) {
+		const url = new URL(request.url);
+		if (url.pathname === "/ws" && request.headers.get("upgrade") === "websocket") {
+			if (this.token && !this.tokenMatchesUpgrade(request)) return new Response("unauthorized", { status: 401 });
+			const requestedChannel = url.searchParams.get("channel") ?? "";
+			const channel = requestedChannel ? this.resolveChannel(requestedChannel) : null;
+			const channelId = channel?.id ?? requestedChannel;
+			const channelName = channel?.name ?? null;
+			const connectors = channel?.connectors ?? [];
+			const delivery = channel?.delivery ?? "fanout";
+			const sinceRaw = url.searchParams.get("since");
+			const sinceParsed = sinceRaw === null ? NaN : Number.parseInt(sinceRaw, 10);
+			const since = Number.isFinite(sinceParsed) && sinceParsed >= 0 ? sinceParsed : void 0;
+			const subscriberId = url.searchParams.get("id") ?? void 0;
+			if (server.upgrade(request, { data: {
+				channel: channelId,
+				channelName,
+				connectors,
+				delivery,
+				subscriberId,
+				since
+			} })) return void 0;
+			return new Response("WebSocket upgrade failed", { status: 400 });
+		}
+		return app.fetch(request);
+	}
+	handleWsOpen(ws) {
+		if (typeof ws.data.since === "number") {
+			const replay = this.broadcaster.replaySince(ws.data.since, ws.data);
+			for (const event of replay) ws.send(JSON.stringify(event));
+		}
+		this.broadcaster.addClient(ws, ws.data);
+		this.logger?.info("channel connected", {
+			event_type: "system",
+			action: "channel_connect",
+			channel: ws.data.channelName ?? "",
+			channelId: ws.data.channel,
+			connectors: ws.data.connectors.join(","),
+			total: String(this.broadcaster.getClientCount())
+		});
+	}
+	handleWsClose(ws) {
+		this.broadcaster.removeClient(ws);
+		this.logger?.info("channel disconnected", {
+			event_type: "system",
+			action: "channel_disconnect",
+			channel: ws.data.channelName ?? "",
+			channelId: ws.data.channel,
+			total: String(this.broadcaster.getClientCount())
+		});
+	}
+	logServerStarted() {
+		this.logger?.info("gateway started", {
+			event_type: "system",
+			action: "gateway_start",
+			port: String(this.port),
+			pid: String(this.selfPid)
+		});
+		this.logger?.info("funnel gateway listening", {
+			url: `http://localhost:${this.port}`,
+			websocket: `ws://localhost:${this.port}/ws`,
+			health: `http://localhost:${this.port}/health`
+		});
+	}
+	buildApp() {
+		const base = factory.createApp();
+		base.use((c, next) => {
+			c.set("deps", {
+				selfPid: this.selfPid,
+				broadcaster: this.broadcaster,
+				supervisor: this.supervisor,
+				channels: this.channels,
+				uptimeMs: () => this.startedAt ? this.nowMs() - this.startedAt : 0,
+				emit: (input) => this.emit(input)
+			});
+			return next();
+		});
+		if (this.token) {
+			base.use("/listeners/*", requireBearerToken({ expected: this.token }));
+			base.use("/status", requireBearerToken({ expected: this.token }));
+			base.use("/debug", requireBearerToken({ expected: this.token }));
+			base.use("/channels/*", requireBearerToken({ expected: this.token }));
+		}
+		return (this.extraRoutes ? base.route("/", this.extraRoutes) : base).route("/", gatewayRoutes);
+	}
+	/**
+	* Reads the bearer token from the WebSocket upgrade request. Accepts:
+	*   - `Sec-WebSocket-Protocol: funnel.token.<value>` (preferred — header, never logged in URLs)
+	*   - `Authorization: Bearer <value>` (also header-based)
+	* Returns true on a constant-time match against the daemon token.
+	*/
+	tokenMatchesUpgrade(request) {
+		const protocols = (request.headers.get("sec-websocket-protocol") ?? "").split(",").map((p) => p.trim()).filter((p) => p.length > 0);
+		for (const proto of protocols) if (proto.startsWith("funnel.token.") && constantTimeEqual(proto.slice(13), this.token)) return true;
+		const match = (request.headers.get("authorization") ?? "").match(/^Bearer\s+(.+)$/i);
+		if (match && constantTimeEqual(match[1] ?? "", this.token)) return true;
+		return false;
+	}
+	resolveChannel(requested) {
+		const channel = this.channels.get(requested) ?? this.channels.getById(requested);
+		if (!channel) return null;
+		return {
+			id: channel.id,
+			name: channel.name,
+			connectors: channel.connectors.map((c) => c.name),
+			delivery: channel.delivery
+		};
+	}
+	async bootListeners() {
+		const allConnectors = this.channels.listAllConnectors();
+		if (this.killCompetingSlack && allConnectors.some((c) => c.type === "slack")) {
+			const killed = await killCompetingSlackGateways({
+				selfPid: this.selfPid,
+				dir: this.dir,
+				process: this.process,
+				logger: this.logger
+			});
+			if (killed.length > 0) this.logger?.info("killed competing Slack gateway processes", {
+				event_type: "system",
+				action: "kill_competing",
+				pids: killed.join(",")
+			});
+		}
+		await this.supervisor.startAll();
+		for (const entry of this.supervisor.list()) this.logger?.info(`${entry.type} listener started: ${entry.name}`, {
+			event_type: "system",
+			action: `${entry.type}_connect`,
+			channel: entry.channelName,
+			connector: entry.name
+		});
+		this.logger?.info(`event store: ${this.dbPath}`);
+		this.logger?.info("funnel gateway running");
+	}
+	/**
+	* Broadcast `content` to subscribers of `channel`, persisting the event in
+	* the SQLite store and stamping `meta.channel{,Id}` / `meta.connector{,Id}`
+	* when they resolve. Used by both the connector-listener path (via the
+	* supervisor's `notify` callback) and the public `/channels/:channel/publish`
+	* route. Returns the assigned event offset.
+	*/
+	emit(input) {
+		const channelId = this.lookupChannelId(input.channel);
+		const connectorId = channelId && input.connector ? this.lookupConnectorId(channelId, input.connector) : null;
+		const enriched = {
+			...input.meta,
+			channel: input.channel
+		};
+		if (input.connector) enriched.connector = input.connector;
+		if (channelId) enriched.channelId = channelId;
+		if (connectorId) enriched.connectorId = connectorId;
+		const event = this.broadcaster.broadcast(input.content, enriched);
+		this.eventLog.record({
+			content: input.content,
+			channelId: channelId ?? null,
+			connectorId: connectorId ?? null,
+			meta: enriched,
+			offset: event.offset
+		});
+		return { offset: event.offset };
+	}
+	lookupChannelId(channelName) {
+		return this.channels.get(channelName)?.id ?? null;
+	}
+	lookupConnectorId(channelId, connectorName) {
+		return this.channels.getById(channelId)?.connectors.find((c) => c.name === connectorName)?.id ?? null;
+	}
+};
+//#endregion
+//#region lib/gateway/gateway-token.ts
+const TOKEN_FILE_NAME = "gateway.token";
+const TOKEN_BYTES = 32;
+const defaultFs = new NodeFunnelFileSystem();
+const defaultGenerate = () => {
+	const buf = new Uint8Array(TOKEN_BYTES);
+	crypto.getRandomValues(buf);
+	return [...buf].map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+/**
+* Reads / generates the gateway daemon token used to authenticate
+* `/listeners*`, `/status`, and `/ws` connections.
+*
+* Token file: `<dir>/gateway.token` (default `~/.funnel/gateway.token`),
+* written with mode 0600. Clients on the same machine as the daemon read
+* the file directly; the token never leaves the user's home directory.
+*/
+var FunnelGatewayToken = class {
+	fs;
+	path;
+	generate;
+	constructor(deps = {}) {
+		this.fs = deps.fs ?? defaultFs;
+		this.path = join(deps.dir ?? FUNNEL_DIR, TOKEN_FILE_NAME);
+		this.generate = deps.generate ?? defaultGenerate;
+		Object.freeze(this);
+	}
+	read() {
+		if (!this.fs.existsSync(this.path)) return null;
+		const value = this.fs.readFileSync(this.path).trim();
+		return value.length > 0 ? value : null;
+	}
+	/**
+	* Returns the existing token or, if missing, generates one and writes it with mode 0600.
+	*
+	* NOTE: not atomic — two concurrent `ensure()` calls (e.g., `fnl gateway start` racing
+	* itself before the PID lock is acquired) could each generate independent tokens. The
+	* gateway PID file makes this practically a non-issue; if you need stronger guarantees,
+	* take a file lock around this call externally.
+	*/
+	ensure() {
+		const existing = this.read();
+		if (existing) return existing;
+		const token = this.generate();
+		this.fs.mkdirSync(dirname(this.path), { recursive: true });
+		this.fs.writeSecretFileSync(this.path, `${token}\n`);
+		return token;
+	}
+	getPath() {
+		return this.path;
+	}
+};
+const DEFAULT_GATEWAY_TOKEN_PATH = join(homedir(), ".funnel", TOKEN_FILE_NAME);
+//#endregion
+//#region lib/gateway/memory-funnel-event-log.ts
+/**
+* In-process `FunnelEventLog` backed by a plain array. Used by tests and by
+* embedders that do not need durability — replay works within the process
+* lifetime but is lost when the process exits. Unlike the SQLite log it does
+* not truncate content or prune, so it is not meant for unbounded production
+* traffic.
+*/
+var MemoryFunnelEventLog = class extends FunnelEventLog {
+	events = [];
+	constructor() {
+		super();
+		Object.freeze(this);
+	}
+	record(record) {
+		this.events.push({
+			offset: record.offset,
+			content: record.content,
+			meta: record.meta ?? void 0,
+			channelId: record.channelId,
+			connectorId: record.connectorId
+		});
+	}
+	loadSince(since) {
+		const out = [];
+		for (const event of this.events) if (event.offset > since) out.push({
+			content: event.content,
+			meta: event.meta,
+			offset: event.offset
+		});
+		return out;
+	}
+	findMaxOffset() {
+		let max = 0;
+		for (const event of this.events) if (event.offset > max) max = event.offset;
+		return max;
+	}
+	clear() {
+		this.events.length = 0;
+	}
+	close() {}
+};
+//#endregion
+//#region lib/gateway/connector-diagnostic-log.ts
+/**
+* Points in the listener's connection lifecycle. The single source of truth
+* for the value set: the `status` column schema, the `ConnectorConnectionStatus`
+* union, and the runtime Set used to narrow on read-back all derive from this
+* array, so adding a status is a one-line change that cannot drift out of sync.
+*
+*   started       start() was called
+*   connected     the socket opened and events can flow
+*   disconnected  the socket was closed by a stop() call (a clean teardown)
+*   auth-failed   the token was rejected before the socket opened
+*   stopped       the listener was fully torn down (always follows a stop(),
+*                 paired with the disconnected/error that preceded it)
+*   error         start/stop threw, or Bolt surfaced an error frame — this is
+*                 also where an unsolicited socket drop shows up when Bolt
+*                 reports it (an `error` with no following `stopped` means the
+*                 supervisor recycled the listener, not a clean stop)
+*
+* A connection row is independent of any single inbound event, so it carries
+* no `eventId`. This is how "no notification arrived because the listener
+* never connected (or dropped, or failed auth)" becomes visible: the
+* raw/processed tables only hold events that *did* arrive.
+*/
+const CONNECTOR_CONNECTION_STATUSES = [
+	"started",
+	"connected",
+	"disconnected",
+	"auth-failed",
+	"stopped",
+	"error"
+];
+/**
+* Rows stored in the diagnostic tables. Connector-agnostic on purpose: `type`
+* carries the listener kind ("slack" | "discord" | "gh" | "schedule") so new
+* connectors land in the same tables without a schema change. `event_id` is
+* the correlation key the listener mints once per inbound event and stamps
+* onto both the raw and processed rows, so the two are joinable even though
+* they live in separate tables with independent `seq` counters.
+*
+* These schemas mirror the stored shape (snake_case columns) the way
+* `FunnelEvent` does for the replay log; they exist for `z.infer` and to
+* document the column set, not as a parse boundary.
+*/
+const connectorRawEventSchema = z.object({
+	event_id: z.string(),
+	type: z.string(),
+	connector_id: z.string().nullable(),
+	channel_id: z.string().nullable(),
+	payload: z.string()
+});
+const connectorProcessedEventSchema = z.object({
+	event_id: z.string(),
+	type: z.string(),
+	connector_id: z.string().nullable(),
+	channel_id: z.string().nullable(),
+	outcome: z.string(),
+	payload: z.string()
+});
+const connectorConnectionEventSchema = z.object({
+	type: z.string(),
+	connector_id: z.string().nullable(),
+	channel_id: z.string().nullable(),
+	status: z.enum(CONNECTOR_CONNECTION_STATUSES),
+	detail: z.string()
+});
+/**
+* Three-table diagnostic log of everything a connector listener does, so
+* "why was there no notification?" is answerable whichever way it failed:
+*   - `raw` — every inbound event, before any filtering, with the listener's
+*     untouched payload (the Slack Bolt event, the GH webhook, …)
+*   - `processed` — the verdict for that event: `outcome` (emitted, or the
+*     reason it was dropped) and, when emitted, the body that was delivered.
+*     Shares an `eventId` with its raw row, so the two join into one story.
+*   - `connection` — the listener's lifecycle (started, connected, dropped,
+*     auth-failed, stopped, errored). This is the half the event tables can't
+*     show: an event that never arrived leaves no raw row, but a listener that
+*     never connected leaves a `connection` trail that says so.
+*
+* The three are physically separate (independent retention and payload-size
+* policy) so a query never crosses them by accident and a huge raw payload
+* never bloats the verdict or lifecycle trails. None flow to WS clients or the
+* MCP channel — this is a separate store from `FunnelEventLog` (replay) and
+* exists solely for debugging.
+*
+* Implementations:
+*   - `SqliteConnectorDiagnosticLog` — the default; survives daemon restarts,
+*     bounded by per-table row/age caps.
+*   - `MemoryConnectorDiagnosticLog` — an in-process double for tests.
+*/
+var ConnectorDiagnosticLog = class {};
+//#endregion
+//#region lib/gateway/sqlite-connector-diagnostic-log.ts
+/**
+* Cap on a raw payload kept verbatim. The point of the raw table is to see
+* what Slack/Discord actually sent, and a typical event is a few KB — so 256
+* KiB keeps essentially everything intact while bounding the rare giant
+* payload (a huge Block Kit message, a file dump) that would otherwise let a
+* single row bloat the debug database without limit.
+*/
+const RAW_PAYLOAD_CAP = 256 * 1024;
+/**
+* Default `ConnectorDiagnosticLog`: three independent `LeucoLoggerSqliteSink`s, one
+* per table (raw / processed / connection), in separate files. Each sink
+* indexes the columns its queries filter on — `event_id` / `connector_id` /
+* `channel_id` for raw, plus `outcome` for processed and `status` for
+* connection — so those lookups are indexed scans (`type` is a fixed column
+* the sink extracts separately, not an index, so filtering by it is a scan).
+*
+* The raw table offloads any payload over `RAW_PAYLOAD_CAP`: rather than
+* truncating mid-string (which yields unparseable JSON), it replaces the
+* body with a small JSON object that keeps the diagnostic essentials and
+* records the dropped size under `_funnel_oversized`. Every stored payload
+* therefore stays valid JSON.
+*/
+var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
+	raw;
+	processed;
+	connection;
+	now;
+	logger;
+	constructor(props) {
+		super();
+		this.now = props.now ?? (() => Date.now());
+		this.logger = props.logger;
+		const ageCap = props.maxAgeMs !== void 0 ? { maxAgeMs: props.maxAgeMs } : {};
+		const verdictCap = {
+			now: this.now,
+			...ageCap,
+			...props.maxRows !== void 0 ? { maxRows: props.maxRows } : {}
+		};
+		const rawMax = props.rawMaxRows ?? props.maxRows;
+		const rawCap = {
+			now: this.now,
+			...ageCap,
+			...rawMax !== void 0 ? { maxRows: rawMax } : {}
+		};
+		this.raw = new LeucoLoggerSqliteSink({
+			path: props.rawPath,
+			indexes: [
+				"event_id",
+				"connector_id",
+				"channel_id"
+			],
+			extractIndexes: (event) => ({
+				event_id: event.event_id,
+				connector_id: event.connector_id,
+				channel_id: event.channel_id
+			}),
+			...rawCap
+		});
+		this.processed = new LeucoLoggerSqliteSink({
+			path: props.processedPath,
+			indexes: [
+				"event_id",
+				"connector_id",
+				"channel_id",
+				"outcome"
+			],
+			extractIndexes: (event) => ({
+				event_id: event.event_id,
+				connector_id: event.connector_id,
+				channel_id: event.channel_id,
+				outcome: event.outcome
+			}),
+			...verdictCap
+		});
+		this.connection = new LeucoLoggerSqliteSink({
+			path: props.connectionPath,
+			indexes: [
+				"connector_id",
+				"channel_id",
+				"status"
+			],
+			extractIndexes: (event) => ({
+				connector_id: event.connector_id,
+				channel_id: event.channel_id,
+				status: event.status
+			}),
+			...verdictCap
+		});
+		restrictPermissions(props.rawPath);
+		restrictPermissions(props.processedPath);
+		restrictPermissions(props.connectionPath);
+		Object.freeze(this);
+	}
+	recordRaw(record) {
+		const event = {
+			event_id: record.eventId,
+			type: record.type,
+			connector_id: record.connectorId,
+			channel_id: record.channelId,
+			payload: capPayload(record.payload, record.type)
+		};
+		this.report("raw", this.raw.insert({
+			ts: this.now(),
+			event
+		}));
+	}
+	recordProcessed(record) {
+		const event = {
+			event_id: record.eventId,
+			type: record.type,
+			connector_id: record.connectorId,
+			channel_id: record.channelId,
+			outcome: record.outcome,
+			payload: record.payload
+		};
+		this.report("processed", this.processed.insert({
+			ts: this.now(),
+			event
+		}));
+	}
+	recordConnection(record) {
+		const event = {
+			type: record.type,
+			connector_id: record.connectorId,
+			channel_id: record.channelId,
+			status: record.status,
+			detail: record.detail
+		};
+		this.report("connection", this.connection.insert({
+			ts: this.now(),
+			event
+		}));
+	}
+	report(table, result) {
+		if (result instanceof Error) this.logger?.error("diagnostic log insert failed", {
+			table,
+			error: result.message
+		});
+	}
+	queryRaw(query) {
+		return this.raw.getRecords({
+			...query.type !== void 0 ? { type: query.type } : {},
+			...query.limit !== void 0 ? { limit: query.limit } : {},
+			where: buildWhere(query),
+			order: "desc"
+		}).map((record) => ({
+			seq: record.seq,
+			ts: record.ts,
+			eventId: record.event.event_id,
+			type: record.event.type,
+			connectorId: record.event.connector_id,
+			channelId: record.event.channel_id,
+			payload: record.event.payload
+		}));
+	}
+	queryProcessed(query) {
+		const where = buildWhere(query);
+		if (query.outcome !== void 0) where.outcome = query.outcome;
+		return this.processed.getRecords({
+			...query.type !== void 0 ? { type: query.type } : {},
+			...query.limit !== void 0 ? { limit: query.limit } : {},
+			where,
+			order: "desc"
+		}).map((record) => ({
+			seq: record.seq,
+			ts: record.ts,
+			eventId: record.event.event_id,
+			type: record.event.type,
+			connectorId: record.event.connector_id,
+			channelId: record.event.channel_id,
+			outcome: record.event.outcome,
+			payload: record.event.payload
+		}));
+	}
+	queryConnection(query) {
+		const where = buildWhere(query);
+		if (query.status !== void 0) where.status = query.status;
+		return this.connection.getRecords({
+			...query.type !== void 0 ? { type: query.type } : {},
+			...query.limit !== void 0 ? { limit: query.limit } : {},
+			where,
+			order: "desc"
+		}).map((record) => ({
+			seq: record.seq,
+			ts: record.ts,
+			type: record.event.type,
+			connectorId: record.event.connector_id,
+			channelId: record.event.channel_id,
+			status: statusOf(record.event.status),
+			detail: record.event.detail
+		}));
+	}
+	clear() {
+		this.raw.clear();
+		this.processed.clear();
+		this.connection.clear();
+	}
+	close() {
+		this.raw.close();
+		this.processed.close();
+		this.connection.close();
+	}
+};
+const restrictPermissions = (path) => {
+	if (path === ":memory:") return;
+	for (const suffix of [
+		"",
+		"-wal",
+		"-shm"
+	]) try {
+		chmodSync(`${path}${suffix}`, 384);
+	} catch {}
+};
+const buildWhere = (query) => {
+	const where = {};
+	if (query.connectorId !== void 0) where.connector_id = query.connectorId;
+	if (query.channelId !== void 0) where.channel_id = query.channelId;
+	return where;
+};
+const statusField = connectorConnectionEventSchema.shape.status;
+const statusOf = (value) => {
+	const parsed = statusField.safeParse(value);
+	return parsed.success ? parsed.data : "error";
+};
+const capPayload = (payload, type) => {
+	const size = Buffer.byteLength(payload, "utf8");
+	if (size <= RAW_PAYLOAD_CAP) return payload;
+	return JSON.stringify({
+		...headFields(payload),
+		_funnel_oversized: size,
+		_funnel_type: type
+	});
+};
+const HEAD_KEYS = [
+	"type",
+	"subtype",
+	"ts",
+	"channel",
+	"channel_type",
+	"user",
+	"bot_id"
+];
+const headFields = (payload) => {
+	try {
+		const parsed = JSON.parse(payload);
+		if (typeof parsed !== "object" || parsed === null) return {};
+		const source = parsed;
+		const head = {};
+		for (const key of HEAD_KEYS) if (source[key] !== void 0) head[key] = source[key];
+		return head;
+	} catch {
+		return {};
+	}
+};
+//#endregion
+//#region lib/gateway/memory-connector-diagnostic-log.ts
+/**
+* In-process `ConnectorDiagnosticLog` backed by one array per table. Used by tests
+* and embedders that do not need durability. Like the SQLite log it keeps
+* `seq` per-table (each array's 1-based position) and returns the most recent
+* `limit` rows oldest-first; unlike it, it never prunes and never offloads
+* oversized payloads — it keeps whatever the caller hands it, which is fine
+* for the bounded volumes a test produces. Payload-validity is therefore a
+* SQLite-only guarantee; do not write a test that leans on this double
+* rejecting a malformed payload.
+*/
+var MemoryConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
+	raws = [];
+	processeds = [];
+	connections = [];
+	constructor(now = () => Date.now()) {
+		super();
+		this.now = now;
+		Object.freeze(this);
+	}
+	recordRaw(record) {
+		this.raws.push({
+			...record,
+			seq: this.raws.length + 1,
+			ts: this.now()
+		});
+	}
+	recordProcessed(record) {
+		this.processeds.push({
+			...record,
+			seq: this.processeds.length + 1,
+			ts: this.now()
+		});
+	}
+	recordConnection(record) {
+		this.connections.push({
+			...record,
+			seq: this.connections.length + 1,
+			ts: this.now()
+		});
+	}
+	queryRaw(query) {
+		return takeRecent(this.raws.filter((event) => matches(event, query)), query.limit);
+	}
+	queryProcessed(query) {
+		return takeRecent(this.processeds.filter((event) => {
+			if (!matches(event, query)) return false;
+			if (query.outcome !== void 0 && event.outcome !== query.outcome) return false;
+			return true;
+		}), query.limit);
+	}
+	queryConnection(query) {
+		return takeRecent(this.connections.filter((event) => {
+			if (!matches(event, query)) return false;
+			if (query.status !== void 0 && event.status !== query.status) return false;
+			return true;
+		}), query.limit);
+	}
+	clear() {
+		this.raws.length = 0;
+		this.processeds.length = 0;
+		this.connections.length = 0;
+	}
+	close() {}
+};
+const matches = (event, query) => {
+	if (query.type !== void 0 && event.type !== query.type) return false;
+	if (query.connectorId !== void 0 && event.connectorId !== query.connectorId) return false;
+	if (query.channelId !== void 0 && event.channelId !== query.channelId) return false;
+	return true;
+};
+const takeRecent = (events, limit) => {
+	if (limit === void 0) return events;
+	if (limit <= 0) return [];
+	return events.slice(-limit);
+};
+//#endregion
+export { FunnelBroadcaster as _, connectorConnectionEventSchema as a, publishResponseSchema as b, MemoryFunnelEventLog as c, FunnelGatewayServer as d, ConnectorDiagnosticSqlReader as f, funnelEventSchema as g, FunnelEventLog as h, ConnectorDiagnosticLog as i, DEFAULT_GATEWAY_TOKEN_PATH as l, SqliteFunnelEventLog as m, SqliteConnectorDiagnosticLog as n, connectorProcessedEventSchema as o, FunnelListenerSupervisor as p, CONNECTOR_CONNECTION_STATUSES as r, connectorRawEventSchema as s, MemoryConnectorDiagnosticLog as t, FunnelGatewayToken as u, FunnelChannelPublisher as v, funnelTmpDir as x, publishRequestSchema as y };