@interactive-inc/claude-funnel 0.49.0 → 0.51.0

package/dist/index.js

@@ -1,209 +1,32 @@
-import { i as FunnelDiscordAdapter, n as FunnelDiscordListener, t as discordConnectorSchema } from "./discord-connector-schema-BeThExJp.js";
-import { n as FunnelConnectorListener, t as FunnelLogger } from "./logger-Czli2OKh.js";
-import { a as FunnelProcessRunner, i as NodeFunnelProcessRunner, n as FunnelGhListener, r as FunnelGhAdapter, t as ghConnectorSchema } from "./gh-connector-schema-eYE4g77K.js";
-import { a as ScheduleStateStore, i as FunnelScheduleListener, n as scheduleConnectorSchema, o as NodeFunnelFileSystem, r as scheduleEntrySchema, s as FunnelFileSystem, t as scheduleCatchupPolicySchema } from "./schedule-connector-schema-CM-sRkac.js";
-import { i as FunnelSlackAdapter, n as FunnelSlackListener, r as FunnelSlackEventProcessor, t as slackConnectorSchema } from "./slack-connector-schema-DDbSGPZn.js";
+import { r as FunnelDiscordAdapter, t as FunnelDiscordListener } from "./discord-listener-_jSE3HsQ.js";
+import { t as FunnelConnectorListener } from "./connector-listener-DU54DN-f.js";
+import { t as FunnelLogger } from "./logger-BP6SisKt.js";
+import { n as NodeFunnelProcessRunner, r as FunnelProcessRunner, t as ghConnectorSchema } from "./gh-connector-schema-o3Q1-ojL.js";
+import { n as FunnelGhAdapter, t as FunnelGhListener } from "./gh-listener-DH-fClQm.js";
+import { n as ScheduleStateStore, t as FunnelScheduleListener } from "./schedule-listener-ePAjians.js";
+import { t as FunnelFileSystem } from "./file-system-PWKKU7lA.js";
+import { t as NodeFunnelFileSystem } from "./node-file-system-BcrmWN9I.js";
+import { n as FunnelSlackEventProcessor, r as FunnelSlackAdapter, t as FunnelSlackListener } from "./slack-listener-ClQuHhEF.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-DPqrpV7s.js";
+import { a as resolveFunnelDir, c as channelConfigSchema, d as settingsSchema, f as connectorConfigSchema, i as SETTINGS_PATH, l as channelDeliveryModeSchema, n as FUNNEL_DIR, o as resolveFunnelPort, p as NodeFunnelIdGenerator, r as FunnelSettingsStore, s as SETTINGS_VERSION, t as DEFAULT_GATEWAY_PORT, u as profileConfigSchema } from "./settings-store-D2XSXTyt.js";
+import { t as discordConnectorSchema } from "./discord-connector-schema-CBDyGdOI.js";
+import { n as scheduleConnectorSchema, r as scheduleEntrySchema, t as scheduleCatchupPolicySchema } from "./schedule-connector-schema-iCI61gzU.js";
+import { t as slackConnectorSchema } from "./slack-connector-schema-BCNWluHM.js";
+import { a as FileProcessGuard, i as FunnelMcp, o as FunnelClaude } from "./mcp-Dr-nIBwN.js";
+import { a as FunnelLocalConfig, n as NodeFunnelTokenPrompter, r as FunnelLocalConfigSync, t as funnelJsonSchema } from "./local-config-json-schema-8IHjS4Q7.js";
+import { t as FunnelProfiles } from "./profiles-wMRnjSid.js";
+import { _ as FunnelBroadcaster, a as connectorConnectionEventSchema, b as publishResponseSchema, c as MemoryFunnelEventLog, d as FunnelGatewayServer, f as ConnectorDiagnosticSqlReader, g as funnelEventSchema, h as FunnelEventLog, i as ConnectorDiagnosticLog, l as DEFAULT_GATEWAY_TOKEN_PATH, m as SqliteFunnelEventLog, n as SqliteConnectorDiagnosticLog, o as connectorProcessedEventSchema, p as FunnelListenerSupervisor, r as CONNECTOR_CONNECTION_STATUSES, s as connectorRawEventSchema, t as MemoryConnectorDiagnosticLog, u as FunnelGatewayToken, v as FunnelChannelPublisher, x as funnelTmpDir, y as publishRequestSchema } from "./memory-connector-diagnostic-log-CrW1ltLM.js";
 import { dirname, join, resolve } from "node:path";
 import { hc } from "hono/client";
-import { appendFileSync, chmodSync, existsSync, mkdirSync } from "node:fs";
+import { appendFileSync, existsSync, mkdirSync } from "node:fs";
 import { z } from "zod";
-import { homedir, tmpdir } from "node:os";
-import { stderr, stdin } from "node:process";
 import { fileURLToPath } from "node:url";
-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/id/id-generator.ts
-/**
-* ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
-* MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
-*/
-var FunnelIdGenerator = class {};
-//#endregion
-//#region lib/engine/id/node-id-generator.ts
-var NodeFunnelIdGenerator = class extends FunnelIdGenerator {
-	generate() {
-		return crypto.randomUUID();
-	}
-};
-//#endregion
-//#region lib/engine/settings/settings-reader.ts
-var FunnelSettingsReader = class {};
-//#endregion
-//#region lib/connectors/connector-config-schema.ts
-const connectorConfigSchema = z.discriminatedUnion("type", [
-	slackConnectorSchema,
-	ghConnectorSchema,
-	discordConnectorSchema,
-	scheduleConnectorSchema
-]);
-//#endregion
-//#region lib/engine/settings/settings-schema.ts
-/**
-* Routing mode when multiple WS clients are subscribed to the same channel.
-*
-* - `fanout` (default): every connected client receives every event. Right when each
-*   subscriber has its own job (e.g., TUI mirrors, distinct Claude profiles each running
-*   their own pipeline against the same source).
-* - `exclusive`: each event is delivered to exactly one connected client, picked
-*   round-robin per channel. Right when subscribers are interchangeable workers and you
-*   want each event handled once. Tap=all clients (TUI dashboard) always receive,
-*   regardless of mode, so they can passively observe.
-*/
-const channelDeliveryModeSchema = z.enum(["fanout", "exclusive"]);
-const channelConfigSchema = z.object({
-	id: z.string(),
-	name: z.string(),
-	delivery: channelDeliveryModeSchema.default("fanout"),
-	connectors: z.array(connectorConfigSchema).default([])
-});
-const profileConfigSchema = z.object({
-	/** Stable identity (uuid). The primary key everything internal resolves to;
-	*  survives renames. CLI surfaces still address profiles by `name`. */
-	id: z.string(),
-	/** Human-facing label used only at the CLI/TUI surface (`--profile <name>`).
-	*  Renameable; never used as a storage key. */
-	name: z.string(),
-	path: z.string(),
-	channelId: z.string(),
-	/** Args prepended to the claude argv on every launch through this profile. */
-	options: z.array(z.string()).default([]),
-	/** Env vars layered under the launched claude process. process.env wins on collision. */
-	env: z.record(z.string(), z.string()).default({}),
-	/**
-	* When true (the default), funnel resumes this profile's previous claude
-	* session via `--session-id`/`--resume`. The id lives in `sessionId` below,
-	* scoped to this profile so an unrelated session in the same repo can't bleed
-	* in. Set to false for profiles that should always start fresh.
-	*/
-	resume: z.boolean().default(true),
-	/**
-	* Execution state, not config: the claude session id this profile last
-	* launched. Written by the launcher, read on the next resume. Absent until
-	* the first launch; kept inside the profile (rather than a separate file) so
-	* the session belongs to the profile by identity and the transport layer
-	* (channels) never has to know profiles exist.
-	*/
-	sessionId: z.string().optional()
-});
-const SETTINGS_VERSION = 1;
-const settingsSchema = z.object({
-	/** Schema version. New files always write the current version; older files without one are read as v1. */
-	version: z.literal(1).default(1),
-	channels: z.array(channelConfigSchema).default([]),
-	profiles: z.array(profileConfigSchema).default([])
-});
-//#endregion
-//#region lib/engine/settings/settings-store.ts
-/**
-* Resolves the funnel home dir. Defaults to `~/.funnel`, overridable via
-* `FUNNEL_DIR` so a funnel.json-scoped launch can point everything (settings,
-* gateway pid/token, claude pids) at a repo-local `<repo>/.funnel` and never
-* touch the global home. Read at call time, not module load, so a daemon
-* spawned with the env set resolves the override.
-*/
-function resolveFunnelDir() {
-	const override = process.env.FUNNEL_DIR;
-	if (override && override.length > 0) return override;
-	return join(homedir(), ".funnel");
-}
-const DEFAULT_GATEWAY_PORT = 9742;
-/**
-* Resolves the gateway port. Defaults to 9742 — the port a programmatically
-* hosted gateway (`new Funnel().gatewayServer()`) uses. The `funnel` CLI entry
-* sets `FUNNEL_PORT` to a distinct default so a CLI launch never collides with
-* an embedding app's gateway on 9742. Read at call time so a daemon spawned
-* with the env set resolves the override.
-*/
-function resolveFunnelPort() {
-	return Number(process.env.FUNNEL_PORT) || 9742;
-}
-const FUNNEL_DIR = join(homedir(), ".funnel");
-const SETTINGS_PATH = join(FUNNEL_DIR, "settings.json");
-const defaultFs$6 = new NodeFunnelFileSystem();
-const defaultIdGenerator$2 = new NodeFunnelIdGenerator();
-var FunnelSettingsStore = class extends FunnelSettingsReader {
-	path;
-	fs;
-	idGenerator;
-	constructor(deps = {}) {
-		super();
-		this.path = deps.path ?? SETTINGS_PATH;
-		this.fs = deps.fs ?? defaultFs$6;
-		this.idGenerator = deps.idGenerator ?? defaultIdGenerator$2;
-		Object.freeze(this);
-	}
-	read() {
-		if (!this.fs.existsSync(this.path)) return {
-			version: 1,
-			channels: [],
-			profiles: []
-		};
-		const content = this.fs.readFileSync(this.path);
-		const parsed = JSON.parse(content);
-		if (this.looksLikeLegacy(parsed)) throw new Error(`legacy settings.json detected at ${this.path}. The schema changed (channel.connectors are now nested objects with ids; profile fields renamed). Migration is intentionally not provided. Back up and remove the old file:\n  mv ${this.path} ${this.path}.bak`);
-		if (parsed && typeof parsed === "object" && "version" in parsed && parsed.version !== 1) throw new Error(`unsupported settings.json version (${this.path}): expected 1, got ${String(parsed.version)}`);
-		const minted = this.backfillProfileIds(parsed);
-		const result = settingsSchema.safeParse(parsed);
-		if (!result.success) throw new Error(`invalid settings.json (${this.path}): ${result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join(", ")}`);
-		if (minted) this.write(result.data);
-		return result.data;
-	}
-	looksLikeLegacy(parsed) {
-		if (!parsed || typeof parsed !== "object") return false;
-		const obj = parsed;
-		if (Array.isArray(obj.channels)) for (const channel of obj.channels) {
-			if (!channel || typeof channel !== "object") continue;
-			const ch = channel;
-			if (Array.isArray(ch.connectors) && ch.connectors.some((x) => typeof x === "string")) return true;
-			if (!("id" in ch) && "name" in ch) return true;
-		}
-		if (Array.isArray(obj.connectors)) return true;
-		if (Array.isArray(obj.repositories)) return true;
-		if (Array.isArray(obj.profiles)) for (const profile of obj.profiles) {
-			if (!profile || typeof profile !== "object") continue;
-			const p = profile;
-			if ("repository" in p || "envFiles" in p || "channel" in p && !("channelId" in p)) return true;
-		}
-		return false;
-	}
-	/**
-	* Non-destructive migration for profiles written before `id` existed. Mints a
-	* uuid for each profile lacking one and returns whether anything was minted, so
-	* `read` can persist it immediately — a profile id must be STABLE across reads,
-	* otherwise `setSessionId` (a second read) sees a different id and can't match
-	* the one the launch used. Mutates `parsed` in place (freshly JSON-parsed).
-	*/
-	backfillProfileIds(parsed) {
-		if (!parsed || typeof parsed !== "object") return false;
-		const obj = parsed;
-		if (!Array.isArray(obj.profiles)) return false;
-		let minted = false;
-		for (const profile of obj.profiles) {
-			if (!profile || typeof profile !== "object") continue;
-			const p = profile;
-			if (typeof p.id !== "string") {
-				p.id = this.idGenerator.generate();
-				minted = true;
-			}
-		}
-		return minted;
-	}
-	write(settings) {
-		this.fs.mkdirSync(dirname(this.path), { recursive: true });
-		const versioned = {
-			...settings,
-			version: 1
-		};
-		this.fs.writeSecretFileSync(this.path, `${JSON.stringify(versioned, null, 2)}\n`);
-	}
-};
-//#endregion
 //#region lib/connectors/connector-factory.ts
-const defaultFs$5 = new NodeFunnelFileSystem();
-const defaultProcess$4 = new NodeFunnelProcessRunner();
+const defaultFs$1 = new NodeFunnelFileSystem();
+const defaultProcess$1 = new NodeFunnelProcessRunner();
 /**
 * Pure factory for per-type listeners and adapters. The factory has no CRUD
 * responsibility — connector configs live inside settings.json under their
@@ -225,8 +48,8 @@ var FunnelConnectorFactory = class {
 	slackListenerOptions;
 	scheduleListenerOptions;
 	constructor(deps = {}) {
-		this.fs = deps.fs ?? defaultFs$5;
-		this.process = deps.process ?? defaultProcess$4;
+		this.fs = deps.fs ?? defaultFs$1;
+		this.process = deps.process ?? defaultProcess$1;
 		this.logger = deps.logger;
 		this.diagnosticLog = deps.diagnosticLog;
 		this.dir = deps.dir ?? FUNNEL_DIR;
@@ -361,7 +184,7 @@ const slotFields = (literalKey, envKey, fields, current) => {
 	return result;
 };
 const defaultClock$1 = new NodeFunnelClock();
-const defaultIdGenerator$1 = new NodeFunnelIdGenerator();
+const defaultIdGenerator = new NodeFunnelIdGenerator();
 /**
 * Channels own their connectors. Each channel has a stable id (UUID); the
 * `name` is the human-facing label used by the CLI. Connectors live nested
@@ -381,7 +204,7 @@ var FunnelChannels = class {
 		this.factory = deps.factory;
 		this.profileChecker = deps.profileChecker ?? null;
 		this.clock = deps.clock ?? defaultClock$1;
-		this.idGenerator = deps.idGenerator ?? defaultIdGenerator$1;
+		this.idGenerator = deps.idGenerator ?? defaultIdGenerator;
 		Object.freeze(this);
 	}
 	list() {
@@ -635,898 +458,110 @@ var FunnelChannels = class {
 	}
 };
 //#endregion
-//#region lib/engine/claude/claude.ts
-const defaultProcess$3 = new NodeFunnelProcessRunner();
-const defaultIdGenerator = new NodeFunnelIdGenerator();
-/**
-* Launches Claude Code with funnel pre-wired: ensures the gateway is running,
-* installs the funnel MCP into the target repo's `.mcp.json` if missing,
-* injects `FUNNEL_CHANNEL_ID` into the child env, and delegates singleton
-* enforcement to a ProcessGuard.
-*/
-var FunnelClaude = class {
-	channels;
-	mcp;
-	gateway;
-	sessions;
-	guard;
-	process;
-	idGenerator;
-	logger;
-	constructor(deps) {
-		this.channels = deps.channels;
-		this.mcp = deps.mcp;
-		this.gateway = deps.gateway;
-		this.sessions = deps.sessions;
-		this.guard = deps.guard;
-		this.process = deps.process ?? defaultProcess$3;
-		this.idGenerator = deps.idGenerator ?? defaultIdGenerator;
-		this.logger = deps.logger;
-		Object.freeze(this);
+//#region lib/engine/fs/memory-file-system.ts
+const SECRET_MODE = 384;
+var MemoryFunnelFileSystem = class extends FunnelFileSystem {
+	dirs;
+	files;
+	mtimes;
+	modes;
+	now;
+	constructor(props = {}) {
+		super();
+		this.dirs = new Set(props.dirs ?? []);
+		this.files = new Map(Object.entries(props.files ?? {}));
+		this.mtimes = new Map(Object.entries(props.mtimes ?? {}));
+		this.modes = new Map(Object.entries(props.modes ?? {}));
+		this.now = props.now ?? (() => Date.now());
 	}
-	async launch(options) {
-		const channel = this.channels.get(options.channel) ?? this.channels.getById(options.channel);
-		if (!channel) throw new Error(`channel "${options.channel}" not found`);
-		if (options.profileId && this.guard.isRunning(options.profileId)) throw new Error(`profile "${options.profileId}" is already running`);
-		const cwd = options.cwd ?? globalThis.process.cwd();
-		if ((options.installMcp ?? true) && !this.mcp.findInstalledName(cwd)) {
-			this.mcp.install(cwd);
-			this.logger?.info(`added funnel MCP to .mcp.json`, { cwd });
-		}
-		if (!this.gateway.isRunning()) {
-			this.logger?.info(`starting gateway automatically`);
-			await this.gateway.start();
-		}
-		if (options.profileId) this.guard.acquire(options.profileId);
-		const session = (options.resume ?? false) && options.profileId ? this.resolveSession(options.profileId, cwd, options.userArgs ?? [], options.env ?? {}) : null;
-		const claudeArgs = this.buildArgs(options.options ?? [], options.userArgs ?? [], cwd, session);
-		const env = this.buildEnv(channel.id, options.env ?? {});
-		this.logger?.info(`claude launch`, {
-			channel: options.channel,
-			channelId: channel.id,
-			cwd
-		});
-		try {
-			return await this.process.attach(["claude", ...claudeArgs], {
-				cwd,
-				env,
-				onSpawned: options.onSpawned
-			});
-		} finally {
-			if (options.profileId) this.guard.release(options.profileId);
-		}
+	existsSync(path) {
+		return this.dirs.has(path) || this.files.has(path);
+	}
+	readFileSync(path) {
+		return this.files.get(path) ?? "";
 	}
-	buildArgs(recipeOptions, userArgs, cwd, session) {
-		const result = [...recipeOptions, ...userArgs];
-		if (session !== null) if (session.mode === "resume") result.push("--resume", session.id);
-		else result.push("--session-id", session.id);
-		const mcpName = this.mcp.findInstalledName(cwd);
-		if (mcpName && !result.includes("--dangerously-load-development-channels") && !result.includes("--channels")) result.push("--dangerously-load-development-channels", `server:${mcpName}`);
-		return result;
+	writeFileSync(path, data) {
+		this.files.set(path, data);
+		this.touch(path);
 	}
-	/**
-	* Decides whether funnel should resume an existing claude session or start
-	* a freshly minted one. Backs off when the user already passed a
-	* session-shaping flag, since combining them would either confuse claude
-	* or override the explicit user intent.
-	*
-	* The session is owned by the profile (by id), not by cwd: two profiles
-	* pointing at the same repo each keep their own conversation, and a launch
-	* with no profile never resumes — so an unrelated session in the same repo
-	* can't bleed in. The channel never enters into it; sessions belong to the
-	* launch layer (profiles), keeping the transport layer ignorant of them.
-	*
-	* A persisted id is only resumed when its session jsonl still exists on
-	* disk. claude errors out on `--resume <id>` for a missing conversation, and
-	* a persisted id can outlive its jsonl (claude pruned it, or the very first
-	* launch was aborted after the id was written but before the jsonl
-	* appeared). When the file is gone we mint a fresh session instead, which
-	* overwrites the dangling entry — so the store self-heals.
-	*/
-	resolveSession(profileId, cwd, userArgs, recipeEnv) {
-		for (const arg of userArgs) {
-			if (arg === "-c" || arg === "--continue") return null;
-			if (arg === "--resume" || arg.startsWith("--resume=")) return null;
-			if (arg === "--session-id" || arg.startsWith("--session-id=")) return null;
-		}
-		const existing = this.sessions.getSessionId(profileId);
-		if (existing !== null && this.sessions.sessionFileExists(cwd, existing, recipeEnv)) return {
-			id: existing,
-			mode: "resume"
-		};
-		const fresh = this.idGenerator.generate();
-		this.sessions.setSessionId(profileId, fresh);
-		return {
-			id: fresh,
-			mode: "new"
-		};
+	writeSecretFileSync(path, data) {
+		this.files.set(path, data);
+		this.modes.set(path, SECRET_MODE);
+		this.touch(path);
 	}
-	buildEnv(channelId, recipeEnv) {
-		const env = {};
-		for (const [key, value] of Object.entries(recipeEnv)) env[key] = value;
-		for (const [key, value] of Object.entries(globalThis.process.env)) if (typeof value === "string") env[key] = value;
-		env.FUNNEL_CHANNEL_ID = channelId;
-		env.FUNNEL_PORT = String(resolveFunnelPort());
-		return env;
+	appendFileSync(path, data) {
+		const prev = this.files.get(path) ?? "";
+		this.files.set(path, prev + data);
+		this.touch(path);
 	}
-};
-//#endregion
-//#region lib/engine/claude/file-process-guard.ts
-const defaultFs$4 = new NodeFunnelFileSystem();
-const defaultProcess$2 = new NodeFunnelProcessRunner();
-var FileProcessGuard = class {
-	fs;
-	process;
-	pidDir;
-	constructor(deps = {}) {
-		this.fs = deps.fs ?? defaultFs$4;
-		this.process = deps.process ?? defaultProcess$2;
-		this.pidDir = join(deps.dir ?? FUNNEL_DIR, "claude");
-		Object.freeze(this);
+	unlink(path) {
+		this.files.delete(path);
+		this.mtimes.delete(path);
+		this.modes.delete(path);
 	}
-	isRunning(profileId) {
-		const pid = this.readPid(profileId);
-		if (!pid) return false;
-		return this.process.isAlive(pid);
+	mkdirSync(path, options) {
+		this.dirs.add(path);
+	}
+	readdirSync(path) {
+		const prefix = path.endsWith("/") ? path : `${path}/`;
+		const names = [];
+		for (const file of this.files.keys()) {
+			if (!file.startsWith(prefix)) continue;
+			const rest = file.slice(prefix.length);
+			if (!rest.includes("/")) names.push(rest);
+		}
+		return names;
 	}
-	acquire(profileId) {
-		this.fs.mkdirSync(this.pidDir, { recursive: true });
-		this.fs.writeFileSync(this.pidPath(profileId), String(globalThis.process.pid));
-		globalThis.process.once("exit", () => this.release(profileId));
+	statSync(path) {
+		const mtimeMs = this.mtimes.get(path);
+		if (mtimeMs === void 0) throw new Error(`not found: ${path}`);
+		return {
+			mtimeMs,
+			mode: this.modes.get(path) ?? null
+		};
 	}
-	release(profileId) {
-		const path = this.pidPath(profileId);
-		if (this.fs.existsSync(path)) this.fs.unlink(path);
+	setMtime(path, mtimeMs) {
+		this.mtimes.set(path, mtimeMs);
 	}
-	pidPath(profileId) {
-		return join(this.pidDir, `${profileId}.pid`);
+	setMode(path, mode) {
+		this.modes.set(path, mode);
 	}
-	readPid(profileId) {
-		const path = this.pidPath(profileId);
-		if (!this.fs.existsSync(path)) return null;
-		try {
-			const content = this.fs.readFileSync(path).trim();
-			const pid = Number(content);
-			if (!pid || pid <= 0) return null;
-			return pid;
-		} catch {
-			return null;
-		}
+	touch(path) {
+		if (!this.mtimes.has(path)) this.mtimes.set(path, this.now());
+		else this.mtimes.set(path, this.now());
 	}
 };
 //#endregion
-//#region lib/engine/local-config/local-config-schema.ts
-/**
-* Per-repo launch config (`funnel.json`).
-*
-* `fnl claude` reads this when no global --profile preset is used. It picks one
-* of the declared channels (`--channel <name>` selects by name; otherwise the
-* first entry wins) and materializes its transport (connectors / delivery) into
-* the repo's scoped settings (`~/.funnel/projects/<id>/settings.json`) on launch.
-* Connectors carry no tokens here — a token absent from settings is prompted for
-* at launch (TTY) and saved there, never in the repo.
-*
-* The launch recipe (`options` / `env` / `resume`) lives on `profiles[]`, not on
-* the channel: a channel only describes where events come from. `fnl claude`
-* applies the first profile bound to the chosen channel; the recipe is passed
-* straight to the launcher and is not persisted into the global profile list.
-* These profiles are selected by their `channel` binding, not by name.
-*/
-const slackConnectorSpecSchema = z.object({
-	type: z.literal("slack"),
-	name: z.string(),
-	/** Shrink raw Slack events before fanout. Defaults to true. */
-	minify: z.boolean().optional()
-});
-const discordConnectorSpecSchema = z.object({
-	type: z.literal("discord"),
-	name: z.string()
-});
-const ghConnectorSpecSchema = z.object({
-	type: z.literal("gh"),
-	name: z.string(),
-	pollInterval: z.number().int().positive().optional()
-});
-const scheduleConnectorSpecSchema = z.object({
-	type: z.literal("schedule"),
-	name: z.string()
-});
-const connectorSpecSchema = z.discriminatedUnion("type", [
-	slackConnectorSpecSchema,
-	discordConnectorSpecSchema,
-	ghConnectorSpecSchema,
-	scheduleConnectorSpecSchema
-]);
-const channelSpecSchema = z.object({
-	name: z.string(),
-	connectors: z.array(connectorSpecSchema).optional()
-});
-const profileSpecSchema = z.object({
-	/** Handle for `fnl claude --profile <name>`. A profile is only launchable by this name. */
-	name: z.string(),
-	/** Name of the channel (declared in `channels[]`) this profile binds. The profile depends on the channel, never the reverse. */
-	channel: z.string(),
-	/** Args prepended to the claude argv on every launch through this profile. */
-	options: z.array(z.string()).optional(),
-	/** Env vars layered under the launched claude process. process.env wins on collision. */
-	env: z.record(z.string(), z.string()).optional(),
-	/**
-	* When true (the default), funnel injects `--session-id <uuid>` so that
-	* relaunching from the same cwd resumes the previous claude session
-	* without bleeding into other channels or workspaces. Set to false for
-	* profiles that should always start a fresh session.
-	*/
-	resume: z.boolean().optional()
-});
-const localConfigSchema = z.object({
-	$schema: z.string().optional(),
-	/**
-	* Stable per-repo identifier. funnel writes this on first launch when absent;
-	* all funnel state for this repo lives under `~/.funnel/projects/<id>/`, so the
-	* repo itself never holds settings or tokens. Committed alongside funnel.json.
-	*/
-	id: z.string().optional(),
-	/** Declared channels (transport only). First entry is the default; --channel <name> selects by name. */
-	channels: z.array(channelSpecSchema).min(1),
-	/** Launch presets bound to a channel. First entry bound to the chosen channel is the default. */
-	profiles: z.array(profileSpecSchema).optional()
-});
-const LOCAL_CONFIG_FILENAME = "funnel.json";
-//#endregion
-//#region lib/engine/local-config/local-config.ts
-/**
-* Reads `funnel.json` from a directory. Returns `null` when the file is
-* absent so callers can fall through to other resolution paths (default
-* profile, help). Throws on present-but-invalid files so misconfiguration
-* surfaces loudly instead of silently launching the wrong channel.
-*/
-var FunnelLocalConfig = class {
-	fs;
-	constructor(deps) {
-		this.fs = deps.fs;
-		Object.freeze(this);
+//#region lib/engine/id/memory-id-generator.ts
+var MemoryFunnelIdGenerator = class extends FunnelIdGenerator {
+	counter = 0;
+	prefix;
+	constructor(props = {}) {
+		super();
+		this.prefix = props.prefix ?? "id";
 	}
-	read(cwd) {
-		const path = join(cwd, LOCAL_CONFIG_FILENAME);
-		if (!this.fs.existsSync(path)) return null;
-		const raw = this.fs.readFileSync(path);
-		const parsed = (() => {
-			try {
-				return JSON.parse(raw);
-			} catch (error) {
-				const message = error instanceof Error ? error.message : String(error);
-				throw new Error(`${LOCAL_CONFIG_FILENAME} is not valid JSON: ${message}`);
-			}
-		})();
-		const result = localConfigSchema.safeParse(parsed);
-		if (!result.success) throw new Error(`${LOCAL_CONFIG_FILENAME} is invalid: ${result.error.message}`);
-		this.assertProfilesValid(result.data);
-		return result.data;
-	}
-	assertProfilesValid(config) {
-		const profiles = config.profiles ?? [];
-		if (profiles.length === 0) return;
-		const channelNames = new Set(config.channels.map((channel) => channel.name));
-		const seenNames = /* @__PURE__ */ new Set();
-		for (const profile of profiles) {
-			if (!channelNames.has(profile.channel)) throw new Error(`${LOCAL_CONFIG_FILENAME} is invalid: profile "${profile.name}" binds channel "${profile.channel}", which is not declared in channels[]`);
-			if (seenNames.has(profile.name)) throw new Error(`${LOCAL_CONFIG_FILENAME} is invalid: more than one profile is named "${profile.name}" — names must be unique`);
-			seenNames.add(profile.name);
-		}
+	generate() {
+		this.counter++;
+		return `${this.prefix}-${this.counter}`;
 	}
 };
 //#endregion
-//#region lib/engine/token-prompter/token-prompter.ts
-/**
-* Asks the user for a secret value on stdin. Used as a last resort when a
-* funnel.json token field is absent and not present in `~/.funnel`. The Node
-* implementation refuses to prompt when stdin is not a TTY so non-interactive
-* launches (CI, agent spawning agent, daemons) fail fast instead of hanging.
-*/
-var FunnelTokenPrompter = class {};
-//#endregion
-//#region lib/engine/local-config/local-config-sync.ts
-/**
-* Reconciles a single funnel.json channel spec with `~/.funnel/settings.json`.
-* The spec is the source of truth for the channel it declares:
-*
-*   - missing channel → created
-*   - declared connector matched by name → tokens reconciled
-*   - declared connector matched by token in the same channel under a
-*     different name → renamed in place (then tokens reconciled)
-*   - declared connector with no match → added
-*   - any connector left in the channel that the spec did not touch → removed
-*
-* Removal only fires when the channel spec has a `connectors` field. An
-* absent field means "do not manage connectors from here" and leaves
-* everything in `~/.funnel` alone. Other channels in funnel.json (not
-* passed to this call) are untouched.
-*
-* Returns the per-connector change set so callers (e.g. the claude launcher)
-* can drive listener hot-reload on the gateway after settings are written.
-*/
-var FunnelLocalConfigSync = class {
-	channels;
-	prompter;
-	constructor(deps) {
-		this.channels = deps.channels;
-		this.prompter = deps.prompter;
-		Object.freeze(this);
-	}
-	async ensure(channel) {
-		if (!this.channels.get(channel.name)) this.channels.add({ name: channel.name });
-		if (channel.connectors === void 0) return {
-			touched: [],
-			removed: []
-		};
-		const touched = [];
-		const touchedIds = /* @__PURE__ */ new Set();
-		for (const spec of channel.connectors) {
-			const outcome = await this.ensureConnector(channel.name, spec);
-			touched.push({
-				name: outcome.name,
-				changed: outcome.changed
-			});
-			touchedIds.add(outcome.id);
-		}
-		return {
-			touched,
-			removed: this.removeExtras(channel.name, touchedIds)
-		};
-	}
-	async ensureConnector(channelName, spec) {
-		if (spec.type === "slack") return await this.ensureSlack(channelName, spec);
-		if (spec.type === "discord") return await this.ensureDiscord(channelName, spec);
-		if (spec.type === "gh") return this.ensureGh(channelName, spec);
-		return this.ensureSchedule(channelName, spec);
-	}
-	async ensureSlack(channelName, spec) {
-		const byName = this.findExistingSlack(channelName, spec.name);
-		const bot = await this.resolveSlot({
-			label: `${spec.name}.botToken`,
-			existingLiteral: byName?.botToken,
-			existingEnv: byName?.botTokenEnv
-		});
-		const app = await this.resolveSlot({
-			label: `${spec.name}.appToken`,
-			existingLiteral: byName?.appToken,
-			existingEnv: byName?.appTokenEnv
+//#region lib/engine/logger/memory-logger.ts
+var MemoryFunnelLogger = class extends FunnelLogger {
+	file = null;
+	entries = [];
+	info(message, meta) {
+		this.entries.push({
+			level: "info",
+			message,
+			meta
 		});
-		const update = {
-			botToken: bot.token,
-			botTokenEnv: bot.tokenEnv,
-			appToken: app.token,
-			appTokenEnv: app.tokenEnv
-		};
-		if (byName) {
-			if (!(byName.botToken === bot.token && byName.botTokenEnv === bot.tokenEnv && byName.appToken === app.token && byName.appTokenEnv === app.tokenEnv)) {
-				this.channels.updateSlackConnector(channelName, spec.name, update);
-				return {
-					id: byName.id,
-					name: spec.name,
-					changed: true
-				};
-			}
-			return {
-				id: byName.id,
-				name: spec.name,
-				changed: false
-			};
-		}
-		return {
-			id: this.channels.addConnector(channelName, {
-				type: "slack",
-				name: spec.name,
-				...update,
-				...spec.minify !== void 0 ? { minify: spec.minify } : {}
-			}).id,
-			name: spec.name,
-			changed: true
-		};
 	}
-	async ensureDiscord(channelName, spec) {
-		const byName = this.findExistingDiscord(channelName, spec.name);
-		const bot = await this.resolveSlot({
-			label: `${spec.name}.botToken`,
-			existingLiteral: byName?.botToken,
-			existingEnv: byName?.botTokenEnv
-		});
-		const update = {
-			botToken: bot.token,
-			botTokenEnv: bot.tokenEnv
-		};
-		if (byName) {
-			if (byName.botToken !== bot.token || byName.botTokenEnv !== bot.tokenEnv) {
-				this.channels.updateDiscordConnector(channelName, spec.name, update);
-				return {
-					id: byName.id,
-					name: spec.name,
-					changed: true
-				};
-			}
-			return {
-				id: byName.id,
-				name: spec.name,
-				changed: false
-			};
-		}
-		return {
-			id: this.channels.addConnector(channelName, {
-				type: "discord",
-				name: spec.name,
-				...update
-			}).id,
-			name: spec.name,
-			changed: true
-		};
-	}
-	ensureGh(channelName, spec) {
-		const existing = this.channels.getConnector(channelName, spec.name);
-		if (existing && existing.type !== "gh") throw new Error(`connector "${spec.name}" exists in channel "${channelName}" with type "${existing.type}", funnel.json declares "gh"`);
-		if (existing && existing.type === "gh") {
-			if (spec.pollInterval !== void 0 && existing.pollInterval !== spec.pollInterval) {
-				this.channels.updateGhConnector(channelName, spec.name, { pollInterval: spec.pollInterval });
-				return {
-					id: existing.id,
-					name: spec.name,
-					changed: true
-				};
-			}
-			return {
-				id: existing.id,
-				name: spec.name,
-				changed: false
-			};
-		}
-		return {
-			id: this.channels.addConnector(channelName, {
-				type: "gh",
-				name: spec.name,
-				...spec.pollInterval !== void 0 ? { pollInterval: spec.pollInterval } : {}
-			}).id,
-			name: spec.name,
-			changed: true
-		};
-	}
-	ensureSchedule(channelName, spec) {
-		const existing = this.channels.getConnector(channelName, spec.name);
-		if (existing && existing.type !== "schedule") throw new Error(`connector "${spec.name}" exists in channel "${channelName}" with type "${existing.type}", funnel.json declares "schedule"`);
-		if (existing && existing.type === "schedule") return {
-			id: existing.id,
-			name: spec.name,
-			changed: false
-		};
-		return {
-			id: this.channels.addConnector(channelName, {
-				type: "schedule",
-				name: spec.name
-			}).id,
-			name: spec.name,
-			changed: true
-		};
-	}
-	findExistingSlack(channelName, connectorName) {
-		const existing = this.channels.getConnector(channelName, connectorName);
-		if (!existing) return null;
-		if (existing.type !== "slack") throw new Error(`connector "${connectorName}" exists in channel "${channelName}" with type "${existing.type}", funnel.json declares "slack"`);
-		return existing;
-	}
-	findExistingDiscord(channelName, connectorName) {
-		const existing = this.channels.getConnector(channelName, connectorName);
-		if (!existing) return null;
-		if (existing.type !== "discord") throw new Error(`connector "${connectorName}" exists in channel "${channelName}" with type "${existing.type}", funnel.json declares "discord"`);
-		return existing;
-	}
-	removeExtras(channelName, touched) {
-		const channel = this.channels.get(channelName);
-		if (!channel) return [];
-		const stale = channel.connectors.filter((c) => !touched.has(c.id));
-		for (const connector of stale) this.channels.removeConnector(channelName, connector.name);
-		return stale.map((c) => c.name);
-	}
-	/**
-	* Decides how a single token slot is stored in settings.json. funnel.json
-	* never carries tokens, so the only sources are a value already in
-	* settings.json (carried over verbatim, whichever form it was — literal or an
-	* `env`-var reference set via the CLI) or, on first sync, a TTY prompt for a
-	* literal (throws when stdin is not a TTY). Either way the secret lands in the
-	* repo-scoped settings, never in the repo itself.
-	*/
-	async resolveSlot(input) {
-		if (input.existingEnv !== void 0) return {
-			token: void 0,
-			tokenEnv: input.existingEnv
-		};
-		if (input.existingLiteral !== void 0) return {
-			token: input.existingLiteral,
-			tokenEnv: void 0
-		};
-		return {
-			token: await this.prompter.promptSecret(input.label),
-			tokenEnv: void 0
-		};
-	}
-};
-const FUNNEL_MCP_ARGS = ["funnel", "mcp"];
-const mcpEntrySchema = z.object({
-	command: z.string().optional(),
-	args: z.array(z.string()).optional()
-});
-const mcpConfigSchema = z.object({ mcpServers: z.record(z.string(), mcpEntrySchema).optional() });
-const defaultFs$3 = new NodeFunnelFileSystem();
-/**
-* Installs/uninstalls the funnel MCP entry into a target repository's
-* `.mcp.json`. Detects an existing entry by command match so renaming is
-* preserved across re-installs.
-*/
-var FunnelMcp = class {
-	fs;
-	constructor(deps = {}) {
-		this.fs = deps.fs ?? defaultFs$3;
-		Object.freeze(this);
-	}
-	install(repoPath) {
-		if (!this.fs.existsSync(repoPath)) throw new Error(`repository does not exist: ${repoPath}`);
-		const config = this.readConfig(repoPath);
-		const servers = config.mcpServers ?? {};
-		const targetName = this.findServerName(servers) ?? "funnel";
-		servers[targetName] = {
-			command: "bun",
-			args: FUNNEL_MCP_ARGS
-		};
-		this.writeConfig(repoPath, {
-			...config,
-			mcpServers: servers
-		});
-	}
-	uninstall(repoPath) {
-		if (!this.fs.existsSync(repoPath)) return;
-		const config = this.readConfig(repoPath);
-		const servers = config.mcpServers ?? {};
-		const name = this.findServerName(servers);
-		if (!name) return;
-		const next = { ...servers };
-		delete next[name];
-		this.writeConfig(repoPath, {
-			...config,
-			mcpServers: next
-		});
-	}
-	findInstalledName(cwd) {
-		const config = this.readConfig(cwd);
-		return this.findServerName(config.mcpServers ?? {});
-	}
-	findServerName(servers) {
-		for (const entry of Object.entries(servers)) {
-			const name = entry[0];
-			const value = entry[1];
-			if (this.isFunnelEntry(value)) return name;
-		}
-		return null;
-	}
-	isFunnelEntry(value) {
-		if (!value) return false;
-		if (value.command === "bun" && value.args?.[0] === "funnel") return true;
-		if (value.command === "funnel") return true;
-		return false;
-	}
-	readConfig(repoPath) {
-		const mcpPath = join(repoPath, ".mcp.json");
-		if (!this.fs.existsSync(mcpPath)) return {};
-		const content = this.fs.readFileSync(mcpPath).trim();
-		if (!content) return {};
-		let parsed;
-		try {
-			parsed = JSON.parse(content);
-		} catch (error) {
-			throw new Error(`invalid .mcp.json (${mcpPath}): ${error instanceof Error ? error.message : String(error)}`);
-		}
-		const result = mcpConfigSchema.safeParse(parsed);
-		if (!result.success) throw new Error(`invalid .mcp.json (${mcpPath}): ${result.error.message}`);
-		return result.data;
-	}
-	writeConfig(repoPath, config) {
-		const mcpPath = join(repoPath, ".mcp.json");
-		this.fs.writeFileSync(mcpPath, `${JSON.stringify(config, null, 2)}\n`);
-	}
-};
-//#endregion
-//#region lib/engine/profiles/profiles.ts
-const defaultFs$2 = new NodeFunnelFileSystem();
-/**
-* Named launch presets for `fnl claude`. Each profile bundles a working
-* directory, the channel id its Claude instance subscribes to, and the launch
-* recipe (`options` prepended to the claude argv, `env` layered under the
-* process, `resume` toggling session reuse). Implements ProfileChannelChecker
-* so FunnelChannels can refuse to remove a channel that is still referenced.
-*
-* Each profile has a stable `id` (uuid) minted at `add`. That id is the unit
-* everything internal keys on — the PID file, the resumable session id — so a
-* rename never strands either. `name` is purely the CLI/TUI handle; the CRUD
-* methods here take it because that is what the user types, but resolve to the
-* id before touching id-keyed state. The first array entry is the default
-* profile; `asDefault` reorders to put one first.
-*
-* `channelId` always stores the channel's stable id (uuid). CLI surfaces
-* resolve channel name → id before calling `add`/`update` here.
-*/
-var FunnelProfiles = class {
-	store;
-	idGenerator;
-	fs;
-	constructor(deps) {
-		this.store = deps.store;
-		this.idGenerator = deps.idGenerator;
-		this.fs = deps.fs ?? defaultFs$2;
-		Object.freeze(this);
-	}
-	list() {
-		return this.store.read().profiles;
-	}
-	get(name) {
-		return this.list().find((p) => p.name === name) ?? null;
-	}
-	getById(id) {
-		return this.list().find((p) => p.id === id) ?? null;
-	}
-	getDefault() {
-		return this.list()[0] ?? null;
-	}
-	add(input) {
-		const settings = this.store.read();
-		if (settings.profiles.some((p) => p.name === input.name)) throw new Error(`profile "${input.name}" already exists`);
-		if (!settings.channels.some((c) => c.id === input.channelId)) throw new Error(`channel id "${input.channelId}" not found`);
-		settings.profiles.push({
-			id: this.idGenerator.generate(),
-			name: input.name,
-			path: input.path,
-			channelId: input.channelId,
-			options: input.options ?? [],
-			env: input.env ?? {},
-			resume: input.resume ?? true
-		});
-		this.store.write(settings);
-	}
-	remove(name) {
-		const settings = this.store.read();
-		const index = settings.profiles.findIndex((p) => p.name === name);
-		if (index < 0) throw new Error(`profile "${name}" not found`);
-		settings.profiles.splice(index, 1);
-		this.store.write(settings);
-	}
-	rename(oldName, newName) {
-		const settings = this.store.read();
-		const profile = settings.profiles.find((p) => p.name === oldName);
-		if (!profile) throw new Error(`profile "${oldName}" not found`);
-		if (settings.profiles.some((p) => p.name === newName)) throw new Error(`profile "${newName}" already exists`);
-		profile.name = newName;
-		this.store.write(settings);
-	}
-	asDefault(name) {
-		const settings = this.store.read();
-		const index = settings.profiles.findIndex((p) => p.name === name);
-		if (index < 0) throw new Error(`profile "${name}" not found`);
-		if (index === 0) return;
-		const [profile] = settings.profiles.splice(index, 1);
-		if (!profile) return;
-		settings.profiles.unshift(profile);
-		this.store.write(settings);
-	}
-	hasChannelRef(channelId) {
-		return this.store.read().profiles.some((p) => p.channelId === channelId);
-	}
-	/** Resumable claude session id last launched by this profile (by id), or null. */
-	getSessionId(id) {
-		return this.getById(id)?.sessionId ?? null;
-	}
-	/** Records the claude session id this profile launched, overwriting any prior one. */
-	setSessionId(id, sessionId) {
-		const settings = this.store.read();
-		const profile = settings.profiles.find((p) => p.id === id);
-		if (!profile) throw new Error(`profile id "${id}" not found`);
-		profile.sessionId = sessionId;
-		this.store.write(settings);
-	}
-	/**
-	* Mirrors claude's session storage path
-	* (`<config-dir>/projects/<cwd-with-slashes-as-dashes>/<id>.jsonl`) to check
-	* whether a recorded session still exists AND is non-empty. Reads the same
-	* `CLAUDE_CONFIG_DIR` the child will run under so the check matches reality; a
-	* wrong guess can only ever produce a false negative (start fresh), never a
-	* bad resume.
-	*/
-	sessionFileExists(cwd, sessionId, env) {
-		const path = join(env.CLAUDE_CONFIG_DIR ?? globalThis.process.env.CLAUDE_CONFIG_DIR ?? join(homedir(), ".claude"), "projects", cwd.replace(/\//g, "-"), `${sessionId}.jsonl`);
-		if (!this.fs.existsSync(path)) return false;
-		return this.fs.readFileSync(path).trim().length > 0;
-	}
-	update(name, fields) {
-		const settings = this.store.read();
-		const profile = settings.profiles.find((p) => p.name === name);
-		if (!profile) throw new Error(`profile "${name}" not found`);
-		if (fields.channelId !== void 0) {
-			if (!settings.channels.some((c) => c.id === fields.channelId)) throw new Error(`channel id "${fields.channelId}" not found`);
-			profile.channelId = fields.channelId;
-		}
-		if (fields.path !== void 0) profile.path = fields.path;
-		if (fields.options !== void 0) profile.options = fields.options;
-		if (fields.env !== void 0) profile.env = fields.env;
-		if (fields.resume !== void 0) profile.resume = fields.resume;
-		this.store.write(settings);
-	}
-};
-//#endregion
-//#region lib/engine/token-prompter/node-token-prompter.ts
-const STAR = "*";
-const CR = "\r";
-const LF = "\n";
-const BACKSPACE = String.fromCharCode(8);
-const DEL = String.fromCharCode(127);
-const CTRL_C = String.fromCharCode(3);
-const CTRL_D = String.fromCharCode(4);
-/**
-* Reads a secret from stdin in raw mode. Echoes a `*` per byte so the user
-* can see progress without exposing the token. Refuses to prompt when stdin
-* is not a TTY — callers should surface the resulting error with a hint
-* pointing at the corresponding env var or CLI command.
-*/
-var NodeFunnelTokenPrompter = class extends FunnelTokenPrompter {
-	async promptSecret(label) {
-		if (!stdin.isTTY) throw new Error(`cannot prompt for "${label}": stdin is not a TTY. Set the matching env var or run \`fnl channels <ch> connectors add ...\` first.`);
-		stderr.write(`${label}: `);
-		const wasRaw = stdin.isRaw;
-		stdin.setRawMode(true);
-		stdin.resume();
-		try {
-			return await this.readSecret();
-		} finally {
-			stdin.setRawMode(wasRaw);
-			stdin.pause();
-			stderr.write(LF);
-		}
-	}
-	readSecret() {
-		return new Promise((resolve, reject) => {
-			let buffer = "";
-			const onData = (chunk) => {
-				for (const byte of chunk) {
-					const char = String.fromCharCode(byte);
-					if (char === LF || char === CR) {
-						stdin.off("data", onData);
-						resolve(buffer);
-						return;
-					}
-					if (char === CTRL_C) {
-						stdin.off("data", onData);
-						reject(/* @__PURE__ */ new Error("prompt cancelled"));
-						return;
-					}
-					if (char === CTRL_D) {
-						stdin.off("data", onData);
-						if (buffer.length === 0) reject(/* @__PURE__ */ new Error("prompt cancelled"));
-						else resolve(buffer);
-						return;
-					}
-					if (char === BACKSPACE || char === DEL) {
-						if (buffer.length > 0) {
-							buffer = buffer.slice(0, -1);
-							stderr.write("\b \b");
-						}
-						continue;
-					}
-					buffer += char;
-					stderr.write(STAR);
-				}
-			};
-			stdin.on("data", onData);
-		});
-	}
-};
-//#endregion
-//#region lib/engine/fs/memory-file-system.ts
-const SECRET_MODE = 384;
-var MemoryFunnelFileSystem = class extends FunnelFileSystem {
-	dirs;
-	files;
-	mtimes;
-	modes;
-	now;
-	constructor(props = {}) {
-		super();
-		this.dirs = new Set(props.dirs ?? []);
-		this.files = new Map(Object.entries(props.files ?? {}));
-		this.mtimes = new Map(Object.entries(props.mtimes ?? {}));
-		this.modes = new Map(Object.entries(props.modes ?? {}));
-		this.now = props.now ?? (() => Date.now());
-	}
-	existsSync(path) {
-		return this.dirs.has(path) || this.files.has(path);
-	}
-	readFileSync(path) {
-		return this.files.get(path) ?? "";
-	}
-	writeFileSync(path, data) {
-		this.files.set(path, data);
-		this.touch(path);
-	}
-	writeSecretFileSync(path, data) {
-		this.files.set(path, data);
-		this.modes.set(path, SECRET_MODE);
-		this.touch(path);
-	}
-	appendFileSync(path, data) {
-		const prev = this.files.get(path) ?? "";
-		this.files.set(path, prev + data);
-		this.touch(path);
-	}
-	unlink(path) {
-		this.files.delete(path);
-		this.mtimes.delete(path);
-		this.modes.delete(path);
-	}
-	mkdirSync(path, options) {
-		this.dirs.add(path);
-	}
-	readdirSync(path) {
-		const prefix = path.endsWith("/") ? path : `${path}/`;
-		const names = [];
-		for (const file of this.files.keys()) {
-			if (!file.startsWith(prefix)) continue;
-			const rest = file.slice(prefix.length);
-			if (!rest.includes("/")) names.push(rest);
-		}
-		return names;
-	}
-	statSync(path) {
-		const mtimeMs = this.mtimes.get(path);
-		if (mtimeMs === void 0) throw new Error(`not found: ${path}`);
-		return {
-			mtimeMs,
-			mode: this.modes.get(path) ?? null
-		};
-	}
-	setMtime(path, mtimeMs) {
-		this.mtimes.set(path, mtimeMs);
-	}
-	setMode(path, mode) {
-		this.modes.set(path, mode);
-	}
-	touch(path) {
-		if (!this.mtimes.has(path)) this.mtimes.set(path, this.now());
-		else this.mtimes.set(path, this.now());
-	}
-};
-//#endregion
-//#region lib/engine/id/memory-id-generator.ts
-var MemoryFunnelIdGenerator = class extends FunnelIdGenerator {
-	counter = 0;
-	prefix;
-	constructor(props = {}) {
-		super();
-		this.prefix = props.prefix ?? "id";
-	}
-	generate() {
-		this.counter++;
-		return `${this.prefix}-${this.counter}`;
-	}
-};
-//#endregion
-//#region lib/engine/logger/memory-logger.ts
-var MemoryFunnelLogger = class extends FunnelLogger {
-	file = null;
-	entries = [];
-	info(message, meta) {
-		this.entries.push({
-			level: "info",
-			message,
-			meta
-		});
-	}
-	warn(message, meta) {
-		this.entries.push({
-			level: "warn",
-			message,
-			meta
+	warn(message, meta) {
+		this.entries.push({
+			level: "warn",
+			message,
+			meta
 		});
 	}
 	error(message, meta) {
@@ -1662,18 +697,6 @@ var MockFunnelSettingsReader = class extends FunnelSettingsReader {
 	}
 };
 //#endregion
-//#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/engine/time/memory-clock.ts
 var MemoryFunnelClock = class extends FunnelClock {
 	current;
@@ -1692,121 +715,43 @@ var MemoryFunnelClock = class extends FunnelClock {
 	}
 };
 //#endregion
-//#region lib/gateway/publish-schema.ts
+//#region lib/gateway/resolve-daemon-script.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.
+* Locate the daemon entry script. Works in both dev (running from source)
+* and built mode (bundled into dist/bin.js with daemon at dist/gateway/daemon.js).
+*
+* The candidates cover:
+*  1. dev: this helper lives at lib/gateway/, so daemon.ts is its sibling
+*  2. built sibling: dist/gateway/daemon.js if the helper itself ends up at dist/gateway/
+*  3. bundled: when this helper is inlined into dist/bin.js, the helper's dir is dist/,
+*     and daemon.js lives at dist/gateway/daemon.js
+*
+* Uses `fileURLToPath(import.meta.url)` rather than `import.meta.dir` so the
+* same helper resolves correctly whether run from source, the built sibling,
+* or inlined into the bundle.
 */
-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()
-});
+const resolveDaemonScript = () => {
+	const here = dirname(fileURLToPath(import.meta.url));
+	const candidates = [
+		resolve(here, "./daemon.ts"),
+		resolve(here, "./daemon.js"),
+		resolve(here, "./gateway/daemon.js")
+	];
+	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
+	throw new Error(`daemon script not found (looked in ${candidates.join(", ")})`);
+};
 //#endregion
-//#region lib/gateway/channel-publisher.ts
-const OFFLINE$1 = { 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$1;
-		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/resolve-daemon-script.ts
-/**
-* Locate the daemon entry script. Works in both dev (running from source)
-* and built mode (bundled into dist/bin.js with daemon at dist/gateway/daemon.js).
-*
-* The candidates cover:
-*  1. dev: this helper lives at lib/gateway/, so daemon.ts is its sibling
-*  2. built sibling: dist/gateway/daemon.js if the helper itself ends up at dist/gateway/
-*  3. bundled: when this helper is inlined into dist/bin.js, the helper's dir is dist/,
-*     and daemon.js lives at dist/gateway/daemon.js
-*
-* Uses `fileURLToPath(import.meta.url)` rather than `import.meta.dir` so the
-* same helper resolves correctly whether run from source, the built sibling,
-* or inlined into the bundle.
-*/
-const resolveDaemonScript = () => {
-	const here = dirname(fileURLToPath(import.meta.url));
-	const candidates = [
-		resolve(here, "./daemon.ts"),
-		resolve(here, "./daemon.js"),
-		resolve(here, "./gateway/daemon.js")
-	];
-	for (const candidate of candidates) if (existsSync(candidate)) return candidate;
-	throw new Error(`daemon script not found (looked in ${candidates.join(", ")})`);
-};
-//#endregion
-//#region lib/gateway/gateway.ts
-const STARTUP_TIMEOUT_MS = 5e3;
-const SIGTERM_TIMEOUT_MS = 2e3;
-const POLL_INTERVAL_MS = 100;
-const SIGKILL_GRACE_MS = 200;
-const defaultProcess$1 = new NodeFunnelProcessRunner();
-const defaultFs$1 = new NodeFunnelFileSystem();
-const defaultClock = new NodeFunnelClock();
-const defaultSleep$1 = (ms) => new Promise((r) => {
-	setTimeout(r, ms);
-});
+//#region lib/gateway/gateway.ts
+const STARTUP_TIMEOUT_MS = 5e3;
+const SIGTERM_TIMEOUT_MS = 2e3;
+const POLL_INTERVAL_MS = 100;
+const SIGKILL_GRACE_MS = 200;
+const defaultProcess = new NodeFunnelProcessRunner();
+const defaultFs = new NodeFunnelFileSystem();
+const defaultClock = new NodeFunnelClock();
+const defaultSleep = (ms) => new Promise((r) => {
+	setTimeout(r, ms);
+});
 /**
 * Manages the gateway daemon as a separate process via PID file.
 * Use `start()` to spawn `bun daemon.ts` in the background and `stop()` to
@@ -1823,1812 +768,137 @@ var FunnelGateway = class {
 	port;
 	sleep;
 	constructor(deps = {}) {
-		this.process = deps.process ?? defaultProcess$1;
-		this.fs = deps.fs ?? defaultFs$1;
+		this.process = deps.process ?? defaultProcess;
+		this.fs = deps.fs ?? defaultFs;
 		this.clock = deps.clock ?? defaultClock;
 		this.dir = deps.dir ?? FUNNEL_DIR;
 		this.tmpDir = deps.tmpDir ?? funnelTmpDir();
 		this.pidFile = join(this.dir, "gateway.pid");
 		this.gatewayLog = join(this.tmpDir, "gateway.log");
 		this.port = deps.port ?? resolveFunnelPort();
-		this.sleep = deps.sleep ?? defaultSleep$1;
+		this.sleep = deps.sleep ?? defaultSleep;
 		Object.freeze(this);
 	}
-	isRunning() {
-		const pid = this.readPid();
-		if (!pid) return false;
-		return this.isProcessAlive(pid);
-	}
-	getStatus() {
-		const pid = this.readPid();
-		const running = pid !== null && this.isProcessAlive(pid);
-		return {
-			running,
-			pid: running ? pid : null,
-			port: this.port
-		};
-	}
-	async start(options = {}) {
-		if (this.isRunning()) return true;
-		this.fs.mkdirSync(this.tmpDir, { recursive: true });
-		const gatewayScript = resolveDaemonScript();
-		const command = this.buildStartCommand(gatewayScript, options);
-		this.process.detach(command, {
-			env: { FUNNEL_DIR: this.dir },
-			stdoutFile: this.gatewayLog,
-			stderrFile: this.gatewayLog
-		});
-		const deadline = this.clock.millis() + STARTUP_TIMEOUT_MS;
-		while (this.clock.millis() < deadline) {
-			if (this.isRunning()) return true;
-			await this.sleep(POLL_INTERVAL_MS);
-		}
-		return this.isRunning();
-	}
-	buildStartCommand(gatewayScript, options = {}) {
-		const tag = `funnel-gateway[${this.dir}]`;
-		if (options.caffeinate !== false && globalThis.process.platform === "darwin") return [
-			"caffeinate",
-			"-is",
-			"bun",
-			gatewayScript,
-			tag
-		];
-		return [
-			"bun",
-			gatewayScript,
-			tag
-		];
-	}
-	async stop() {
-		const pid = this.readPid();
-		if (!pid) return true;
-		if (!this.isProcessAlive(pid)) {
-			this.removePid();
-			return true;
-		}
-		try {
-			this.process.kill(pid, "SIGTERM");
-		} catch {
-			return false;
-		}
-		const deadline = this.clock.millis() + SIGTERM_TIMEOUT_MS;
-		while (this.clock.millis() < deadline) {
-			if (!this.isProcessAlive(pid)) {
-				this.removePid();
-				return true;
-			}
-			await this.sleep(POLL_INTERVAL_MS);
-		}
-		try {
-			this.process.kill(pid, "SIGKILL");
-		} catch {}
-		await this.sleep(SIGKILL_GRACE_MS);
-		this.removePid();
-		return !this.isProcessAlive(pid);
-	}
-	async restart(options = {}) {
-		const wasRunning = this.isRunning();
-		if (options.onlyIfRunning && !wasRunning) return {
-			ok: true,
-			wasRunning: false,
-			stopped: false,
-			started: false
-		};
-		const stopped = wasRunning ? await this.stop() : true;
-		if (!stopped) return {
-			ok: false,
-			wasRunning,
-			stopped: false,
-			started: false
-		};
-		const started = await this.start({ caffeinate: options.caffeinate });
-		return {
-			ok: started,
-			wasRunning,
-			stopped,
-			started
-		};
-	}
-	getGatewayLog() {
-		return this.gatewayLog;
-	}
-	getPort() {
-		return this.port;
-	}
-	readPid() {
-		if (!this.fs.existsSync(this.pidFile)) return null;
-		try {
-			const content = this.fs.readFileSync(this.pidFile).trim();
-			const pid = Number(content);
-			if (!pid || pid <= 0) return null;
-			return pid;
-		} catch {
-			return null;
-		}
-	}
-	removePid() {
-		this.fs.unlink(this.pidFile);
-	}
-	isProcessAlive(pid) {
-		return this.process.isAlive(pid);
-	}
-};
-//#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$1 = 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$1(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$1(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$1.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$1 = factory$1.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$1 = factory$1.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$1.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$1.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$1.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$1.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$1.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$1 = factory$1.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$1.createApp().get("/health", ...healthHandler).get("/status", ...statusHandler$1).get("/debug", ...debugHandler$1).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$1);
-}
-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;
-		}
+	isRunning() {
+		const pid = this.readPid();
+		if (!pid) return false;
+		return this.isProcessAlive(pid);
 	}
 	getStatus() {
+		const pid = this.readPid();
+		const running = pid !== null && this.isProcessAlive(pid);
 		return {
-			clients: this.broadcaster.getClientCount(),
-			channels: this.broadcaster.listChannels()
+			running,
+			pid: running ? pid : null,
+			port: this.port
 		};
 	}
-	getBroadcaster() {
-		return this.broadcaster;
-	}
-	getSupervisor() {
-		return this.supervisor;
+	async start(options = {}) {
+		if (this.isRunning()) return true;
+		this.fs.mkdirSync(this.tmpDir, { recursive: true });
+		const gatewayScript = resolveDaemonScript();
+		const command = this.buildStartCommand(gatewayScript, options);
+		this.process.detach(command, {
+			env: { FUNNEL_DIR: this.dir },
+			stdoutFile: this.gatewayLog,
+			stderrFile: this.gatewayLog
+		});
+		const deadline = this.clock.millis() + STARTUP_TIMEOUT_MS;
+		while (this.clock.millis() < deadline) {
+			if (this.isRunning()) return true;
+			await this.sleep(POLL_INTERVAL_MS);
+		}
+		return this.isRunning();
 	}
-	getEventLog() {
-		return this.eventLog;
+	buildStartCommand(gatewayScript, options = {}) {
+		const tag = `funnel-gateway[${this.dir}]`;
+		if (options.caffeinate !== false && globalThis.process.platform === "darwin") return [
+			"caffeinate",
+			"-is",
+			"bun",
+			gatewayScript,
+			tag
+		];
+		return [
+			"bun",
+			gatewayScript,
+			tag
+		];
 	}
-	/**
-	* 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 });
+	async stop() {
+		const pid = this.readPid();
+		if (!pid) return true;
+		if (!this.isProcessAlive(pid)) {
+			this.removePid();
+			return true;
 		}
-		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));
+		try {
+			this.process.kill(pid, "SIGTERM");
+		} catch {
+			return false;
 		}
-		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$1.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 }));
+		const deadline = this.clock.millis() + SIGTERM_TIMEOUT_MS;
+		while (this.clock.millis() < deadline) {
+			if (!this.isProcessAlive(pid)) {
+				this.removePid();
+				return true;
+			}
+			await this.sleep(POLL_INTERVAL_MS);
 		}
-		return (this.extraRoutes ? base.route("/", this.extraRoutes) : base).route("/", gatewayRoutes);
+		try {
+			this.process.kill(pid, "SIGKILL");
+		} catch {}
+		await this.sleep(SIGKILL_GRACE_MS);
+		this.removePid();
+		return !this.isProcessAlive(pid);
 	}
-	/**
-	* 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 restart(options = {}) {
+		const wasRunning = this.isRunning();
+		if (options.onlyIfRunning && !wasRunning) return {
+			ok: true,
+			wasRunning: false,
+			stopped: false,
+			started: false
 		};
-	}
-	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
+		const stopped = wasRunning ? await this.stop() : true;
+		if (!stopped) return {
+			ok: false,
+			wasRunning,
+			stopped: false,
+			started: false
+		};
+		const started = await this.start({ caffeinate: options.caffeinate });
+		return {
+			ok: started,
+			wasRunning,
+			stopped,
+			started
 		};
-		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;
+	getGatewayLog() {
+		return this.gatewayLog;
 	}
-};
-//#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);
+	getPort() {
+		return this.port;
 	}
-	read() {
-		if (!this.fs.existsSync(this.path)) return null;
-		const value = this.fs.readFileSync(this.path).trim();
-		return value.length > 0 ? value : null;
+	readPid() {
+		if (!this.fs.existsSync(this.pidFile)) return null;
+		try {
+			const content = this.fs.readFileSync(this.pidFile).trim();
+			const pid = Number(content);
+			if (!pid || pid <= 0) return null;
+			return pid;
+		} catch {
+			return 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;
+	removePid() {
+		this.fs.unlink(this.pidFile);
 	}
-	getPath() {
-		return this.path;
+	isProcessAlive(pid) {
+		return this.process.isAlive(pid);
 	}
 };
-const DEFAULT_GATEWAY_TOKEN_PATH = join(homedir(), ".funnel", TOKEN_FILE_NAME);
 //#endregion
 //#region lib/gateway/listeners-client.ts
 const listenerEntrySchema = z.object({
@@ -4032,473 +1302,6 @@ var NoopFunnelLogger = class extends FunnelLogger {
 	error() {}
 };
 //#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
 //#region lib/cli/factory.ts
 const factory = createFactory();
 //#endregion
@@ -6541,21 +3344,6 @@ examples:
 	});
 	return c.text(lines.join("\n"));
 });
-//#endregion
-//#region lib/engine/local-config/local-config-json-schema.ts
-/**
-* Generates the JSON Schema (draft 2020-12) for `funnel.json`. Useful for
-* `$schema` references in committed `funnel.json` files so editors can give
-* autocomplete and validation for channels[] (transport) and profiles[]
-* (launch recipe) without anyone hand-maintaining a separate schema.
-*/
-const funnelJsonSchema = () => {
-	return {
-		...z.toJSONSchema(localConfigSchema, { target: "draft-2020-12" }),
-		title: "Funnel per-repo launch config",
-		description: "Used by `fnl claude` to declare channels (transport: connectors to materialize into ~/.funnel/settings.json on launch) and profiles (launch recipe: options / env / resume) bound to those channels."
-	};
-};
 const schemaHandler = factory.createHandlers(zValidator$1("query", z.object({}), `funnel schema — print the JSON Schema for funnel.json
 
 usage: funnel schema