@interactive-inc/claude-funnel 0.41.0 → 0.50.0

package/dist/index.js

@@ -1,212 +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, readFileSync } 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";
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
-//#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$5 = 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$5;
-		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$4 = new NodeFunnelFileSystem();
-const defaultProcess$3 = 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
@@ -228,8 +48,8 @@ var FunnelConnectorFactory = class {
 	slackListenerOptions;
 	scheduleListenerOptions;
 	constructor(deps = {}) {
-		this.fs = deps.fs ?? defaultFs$4;
-		this.process = deps.process ?? defaultProcess$3;
+		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;
@@ -364,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
@@ -382,9 +202,9 @@ var FunnelChannels = class {
 	constructor(deps) {
 		this.store = deps.store;
 		this.factory = deps.factory;
-		this.profileChecker = deps.profileChecker;
+		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() {
@@ -420,7 +240,7 @@ var FunnelChannels = class {
 		const index = settings.channels.findIndex((c) => c.name === name);
 		if (index < 0) throw new Error(`channel "${name}" not found`);
 		const channel = settings.channels[index];
-		if (channel && this.profileChecker.hasChannelRef(channel.id)) throw new Error(`channel "${name}" is referenced by a profile`);
+		if (channel && this.profileChecker?.hasChannelRef(channel.id)) throw new Error(`channel "${name}" is referenced by a profile`);
 		settings.channels.splice(index, 1);
 		this.store.write(settings);
 	}
@@ -638,175 +458,6 @@ var FunnelChannels = class {
 	}
 };
 //#endregion
-//#region lib/engine/claude/claude.ts
-const defaultProcess$2 = new NodeFunnelProcessRunner();
-const defaultFs$3 = new NodeFunnelFileSystem();
-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 writes a per-profile
-* PID file to enforce singleton launches.
-*/
-var FunnelClaude = class {
-	channels;
-	mcp;
-	gateway;
-	profiles;
-	process;
-	fs;
-	idGenerator;
-	logger;
-	pidDir;
-	constructor(deps) {
-		this.channels = deps.channels;
-		this.mcp = deps.mcp;
-		this.gateway = deps.gateway;
-		this.profiles = deps.profiles;
-		this.process = deps.process ?? defaultProcess$2;
-		this.fs = deps.fs ?? defaultFs$3;
-		this.idGenerator = deps.idGenerator ?? defaultIdGenerator;
-		this.logger = deps.logger;
-		this.pidDir = join(deps.dir ?? FUNNEL_DIR, "claude");
-		Object.freeze(this);
-	}
-	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.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.writePidFile(options.profileId);
-			this.installCleanup(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.removePidFile(options.profileId);
-		}
-	}
-	isRunning(profileId) {
-		const pid = this.readPid(profileId);
-		if (!pid) return false;
-		return this.isProcessAlive(pid);
-	}
-	pidPath(profileId) {
-		return join(this.pidDir, `${profileId}.pid`);
-	}
-	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;
-		}
-	}
-	writePidFile(profileId) {
-		this.fs.mkdirSync(this.pidDir, { recursive: true });
-		this.fs.writeFileSync(this.pidPath(profileId), String(globalThis.process.pid));
-	}
-	removePidFile(profileId) {
-		const path = this.pidPath(profileId);
-		if (this.fs.existsSync(path)) this.fs.unlink(path);
-	}
-	installCleanup(profileId) {
-		globalThis.process.once("exit", () => this.removePidFile(profileId));
-	}
-	isProcessAlive(pid) {
-		return this.process.isAlive(pid);
-	}
-	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;
-	}
-	/**
-	* 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.profiles.getSessionId(profileId);
-		if (existing !== null && this.sessionFileExists(cwd, existing, recipeEnv)) return {
-			id: existing,
-			mode: "resume"
-		};
-		const fresh = this.idGenerator.generate();
-		this.profiles.setSessionId(profileId, fresh);
-		return {
-			id: fresh,
-			mode: "new"
-		};
-	}
-	/**
-	* 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, recipeEnv) {
-		const path = join(recipeEnv.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;
-	}
-	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;
-	}
-};
-//#endregion
 //#region lib/engine/fs/memory-file-system.ts
 const SECRET_MODE = 384;
 var MemoryFunnelFileSystem = class extends FunnelFileSystem {
@@ -895,397 +546,6 @@ var MemoryFunnelIdGenerator = class extends FunnelIdGenerator {
 	}
 };
 //#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);
-	}
-	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);
-		}
-	}
-};
-//#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
-		});
-		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
-		};
-	}
-};
-//#endregion
-//#region lib/engine/local-config/local-config-writer.ts
-const isRecord = (value) => {
-	return typeof value === "object" && value !== null && !Array.isArray(value);
-};
-const withIdFirst = (config, id) => {
-	const ordered = {};
-	if (config.$schema !== void 0) ordered.$schema = config.$schema;
-	ordered.id = id;
-	for (const key of Object.keys(config)) {
-		if (key === "$schema" || key === "id") continue;
-		ordered[key] = config[key];
-	}
-	return ordered;
-};
-/**
-* The one path that mutates the repo-committed funnel.json, and it only ever
-* inserts `id`. On first launch a repo has no `id`; funnel generates one and
-* writes it back here so future launches resolve the same `~/.funnel/projects/<id>/`.
-* Idempotent — a no-op once `id` is present. Kept separate from the read-only
-* FunnelLocalConfig so reads stay side-effect free.
-*/
-var FunnelLocalConfigWriter = class {
-	fs;
-	constructor(deps) {
-		this.fs = deps.fs;
-		Object.freeze(this);
-	}
-	ensureId(cwd, id) {
-		const path = join(cwd, LOCAL_CONFIG_FILENAME);
-		if (!this.fs.existsSync(path)) return;
-		const parsed = JSON.parse(this.fs.readFileSync(path));
-		if (!isRecord(parsed)) return;
-		if (typeof parsed.id === "string" && parsed.id !== "") return;
-		const ordered = withIdFirst(parsed, id);
-		this.fs.writeFileSync(path, `${JSON.stringify(ordered, null, 2)}\n`);
-	}
-};
-//#endregion
 //#region lib/engine/logger/memory-logger.ts
 var MemoryFunnelLogger = class extends FunnelLogger {
 	file = null;
@@ -1316,93 +576,6 @@ var MemoryFunnelLogger = class extends FunnelLogger {
 	}
 };
 //#endregion
-//#region lib/engine/mcp/mcp.ts
-const FUNNEL_MCP_COMMAND = "bun";
-const FUNNEL_MCP_ARGS = ["funnel", "mcp"];
-const FUNNEL_MCP_NAME = "funnel";
-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$2 = 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$2;
-		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/process/memory-process-runner.ts
 const empty = {
 	exitCode: 0,
@@ -1503,182 +676,6 @@ var MemoryFunnelProcessRunner = class extends FunnelProcessRunner {
 	}
 };
 //#endregion
-//#region lib/engine/profiles/profiles.ts
-/**
-* 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;
-	constructor(deps) {
-		this.store = deps.store;
-		this.idGenerator = deps.idGenerator;
-		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);
-	}
-	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/settings/mock-settings-reader.ts
 const createSettings = (partial = {}) => ({
 	version: 1,
@@ -1700,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;
@@ -1730,85 +715,6 @@ var MemoryFunnelClock = class extends FunnelClock {
 	}
 };
 //#endregion
-//#region lib/gateway/publish-schema.ts
-/**
-* Shared schema for `POST /channels/:channel/publish` — used by both the
-* gateway route handler (input validation) and the CLI / programmable client
-* (request shape). The route resolves `channel` from the path; this body
-* covers everything else.
-*/
-const publishRequestSchema = z.object({
-	content: z.string().min(1),
-	meta: z.record(z.string(), z.string()).optional(),
-	connector: z.string().min(1).optional(),
-	/**
-	* Address the event to a single subscriber. When set, only the WS client that
-	* declared this id at upgrade time (`?id=<subscriberId>`) receives it among the
-	* channel's regular subscribers; tap=all observers still see it. Omit for the
-	* default fanout. The route surfaces it to subscribers as `meta.target`.
-	*/
-	target: z.string().min(1).optional()
-});
-const publishResponseSchema = z.object({
-	ok: z.literal(true),
-	offset: z.number().int().nonnegative()
-});
-//#endregion
-//#region lib/gateway/channel-publisher.ts
-const OFFLINE$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)
@@ -1840,10 +746,10 @@ 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 defaultProcess = new NodeFunnelProcessRunner();
+const defaultFs = new NodeFunnelFileSystem();
 const defaultClock = new NodeFunnelClock();
-const defaultSleep$1 = (ms) => new Promise((r) => {
+const defaultSleep = (ms) => new Promise((r) => {
 	setTimeout(r, ms);
 });
 /**
@@ -1862,15 +768,15 @@ 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() {
@@ -1986,1712 +892,13 @@ var FunnelGateway = class {
 			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) {
-		if (data.tapAll) return true;
-		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`. Tap=all clients always
-	* receive (passive observation). For each per-channel group:
-	*   - fanout → every matching client receives
-	*   - exclusive → exactly one client receives, picked round-robin per channel
-	*
-	* `meta.target` narrows the regular (non-tap) recipient set first via
-	* `matchesClient`: only the subscriber whose `subscriberId` equals `target`
-	* stays in the running, so a targeted event reaches one named instance while
-	* still being observable by tap=all clients.
-	*/
-	pickRecipients(event) {
-		const exclusiveByChannel = /* @__PURE__ */ new Map();
-		const recipients = [];
-		for (const [ws, data] of this.clients) {
-			if (!this.matchesClient(event, data)) continue;
-			if (data.tapAll) {
-				recipients.push(ws);
-				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;
-	settings;
-	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.settings = deps.settings;
-		this.port = deps.port ?? resolveFunnelPort();
-		this.hostname = deps.hostname ?? DEFAULT_HOST;
-		this.dbPath = deps.dbPath ?? defaultDbPath();
-		this.process = deps.process;
-		this.logger = deps.logger;
-		this.onError = deps.onError ?? defaultOnError;
-		this.selfPid = deps.selfPid ?? globalThis.process.pid;
-		this.dir = deps.dir ?? FUNNEL_DIR;
-		this.killCompetingSlack = deps.killCompetingSlack ?? true;
-		this.token = deps.token ?? "";
-		this.extraRoutes = deps.extraRoutes ?? null;
-		const clock = deps.clock;
-		this.nowMs = clock ? () => clock.millis() : () => Date.now();
-		if (deps.eventLog) this.eventLog = deps.eventLog;
-		else {
-			const dbDir = dirname(this.dbPath);
-			if (!existsSync(dbDir)) mkdirSync(dbDir, { recursive: true });
-			this.eventLog = new SqliteFunnelEventLog({
-				path: this.dbPath,
-				now: this.nowMs
-			});
-		}
-		this.broadcaster = new FunnelBroadcaster({
-			logger: this.logger,
-			onError: this.onError,
-			now: this.nowMs,
-			persistentReplay: this.eventLog
-		});
-		this.broadcaster.seedLatestOffset(this.eventLog.findMaxOffset());
-		this.supervisor = new FunnelListenerSupervisor({
-			channels: this.channels,
-			logger: this.logger,
-			onError: this.onError,
-			notify: async (channelName, connectorName, content, meta) => {
-				this.emit({
-					channel: channelName,
-					connector: connectorName,
-					content,
-					meta
-				});
-			},
-			now: this.nowMs
-		});
-	}
-	async start() {
-		if (this.server) return this.server;
-		if (!this.token && !LOOPBACK_HOSTS.has(this.hostname)) this.logger?.warn("gateway auth is disabled on a non-loopback bind — every endpoint is reachable without a token", { hostname: this.hostname });
-		const app = this.buildApp();
-		this.startedAt = this.nowMs();
-		this.server = Bun.serve({
-			port: this.port,
-			hostname: this.hostname,
-			development: false,
-			fetch: (request, server) => this.handleFetch(request, server, app),
-			websocket: {
-				open: (ws) => this.handleWsOpen(ws),
-				close: (ws) => this.handleWsClose(ws),
-				message() {}
-			}
-		});
-		this.logServerStarted();
-		await this.bootListeners();
-		return this.server;
-	}
-	async stop() {
-		await this.supervisor.stopAll();
-		if (this.server) {
-			this.server.stop();
-			this.server = null;
-		}
-	}
-	getStatus() {
-		return {
-			clients: this.broadcaster.getClientCount(),
-			channels: this.broadcaster.listChannels()
-		};
-	}
-	getBroadcaster() {
-		return this.broadcaster;
-	}
-	getSupervisor() {
-		return this.supervisor;
-	}
-	getEventLog() {
-		return this.eventLog;
-	}
-	/**
-	* Register an in-process observer for every broadcast event. Fires after
-	* the event is fanned out to WS clients and recorded in the event log.
-	* Returns an unsubscribe function. Only meaningful in-process (embedded
-	* hosts / `new Funnel(...)` running their own gateway-server); a separate
-	* daemon process cannot be observed this way — use a WS client for that.
-	*/
-	onEvent(handler) {
-		return this.broadcaster.subscribe(handler);
-	}
-	handleFetch(request, server, app) {
-		const url = new URL(request.url);
-		if (url.pathname === "/ws" && request.headers.get("upgrade") === "websocket") {
-			if (this.token && !this.tokenMatchesUpgrade(request)) return new Response("unauthorized", { status: 401 });
-			const tapAll = url.searchParams.get("tap") === "all";
-			const requestedChannel = tapAll ? "" : url.searchParams.get("channel") ?? "";
-			const channel = !tapAll && requestedChannel ? this.resolveChannel(requestedChannel) : null;
-			const channelId = tapAll ? "" : channel?.id ?? requestedChannel;
-			const channelName = tapAll ? null : 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,
-				tapAll,
-				delivery,
-				subscriberId,
-				since
-			} })) return void 0;
-			return new Response("WebSocket upgrade failed", { status: 400 });
-		}
-		return app.fetch(request);
-	}
-	handleWsOpen(ws) {
-		if (typeof ws.data.since === "number") {
-			const replay = this.broadcaster.replaySince(ws.data.since, ws.data);
-			for (const event of replay) ws.send(JSON.stringify(event));
-		}
-		this.broadcaster.addClient(ws, ws.data);
-		if (ws.data.channelName) {
-			const meta = {
-				event_type: "system",
-				action: "channel_connect",
-				channel: ws.data.channelName,
-				channelId: ws.data.channel,
-				connectors: ws.data.connectors.join(","),
-				total: String(this.broadcaster.getClientCount())
-			};
-			this.logger?.info("channel connected", meta);
-		} else this.logger?.info("tap-all client connected", {
-			event_type: "system",
-			action: "tap_connect",
-			total: String(this.broadcaster.getClientCount())
-		});
-	}
-	handleWsClose(ws) {
-		this.broadcaster.removeClient(ws);
-		if (ws.data.channelName) this.logger?.info("channel disconnected", {
-			event_type: "system",
-			action: "channel_disconnect",
-			channel: ws.data.channelName,
-			channelId: ws.data.channel,
-			total: String(this.broadcaster.getClientCount())
-		});
-		else this.logger?.info("tap-all client disconnected", {
-			event_type: "system",
-			action: "tap_disconnect",
-			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 }));
-		}
-		return (this.extraRoutes ? base.route("/", this.extraRoutes) : base).route("/", gatewayRoutes);
-	}
-	/**
-	* Reads the bearer token from the WebSocket upgrade request. Accepts:
-	*   - `Sec-WebSocket-Protocol: funnel.token.<value>` (preferred — header, never logged in URLs)
-	*   - `Authorization: Bearer <value>` (also header-based)
-	* Returns true on a constant-time match against the daemon token.
-	*/
-	tokenMatchesUpgrade(request) {
-		const protocols = (request.headers.get("sec-websocket-protocol") ?? "").split(",").map((p) => p.trim()).filter((p) => p.length > 0);
-		for (const proto of protocols) if (proto.startsWith("funnel.token.") && constantTimeEqual(proto.slice(13), this.token)) return true;
-		const match = (request.headers.get("authorization") ?? "").match(/^Bearer\s+(.+)$/i);
-		if (match && constantTimeEqual(match[1] ?? "", this.token)) return true;
-		return false;
-	}
-	resolveChannel(requested) {
-		const channel = this.settings.read()?.channels.find((c) => c.id === requested || c.name === requested);
-		if (!channel) return null;
-		return {
-			id: channel.id,
-			name: channel.name,
-			connectors: channel.connectors.map((c) => c.name),
-			delivery: channel.delivery
-		};
-	}
-	async bootListeners() {
-		const allConnectors = this.channels.listAllConnectors();
-		if (this.killCompetingSlack && allConnectors.some((c) => c.type === "slack")) {
-			const killed = await killCompetingSlackGateways({
-				selfPid: this.selfPid,
-				dir: this.dir,
-				process: this.process,
-				logger: this.logger
-			});
-			if (killed.length > 0) this.logger?.info("killed competing Slack gateway processes", {
-				event_type: "system",
-				action: "kill_competing",
-				pids: killed.join(",")
-			});
-		}
-		await this.supervisor.startAll();
-		for (const entry of this.supervisor.list()) this.logger?.info(`${entry.type} listener started: ${entry.name}`, {
-			event_type: "system",
-			action: `${entry.type}_connect`,
-			channel: entry.channelName,
-			connector: entry.name
-		});
-		this.logger?.info(`event store: ${this.dbPath}`);
-		this.logger?.info("funnel gateway running");
-	}
-	/**
-	* Broadcast `content` to subscribers of `channel`, persisting the event in
-	* the SQLite store and stamping `meta.channel{,Id}` / `meta.connector{,Id}`
-	* when they resolve. Used by both the connector-listener path (via the
-	* supervisor's `notify` callback) and the public `/channels/:channel/publish`
-	* route. Returns the assigned event offset.
-	*/
-	emit(input) {
-		const channelId = this.lookupChannelId(input.channel);
-		const connectorId = channelId && input.connector ? this.lookupConnectorId(channelId, input.connector) : null;
-		const enriched = {
-			...input.meta,
-			channel: input.channel
-		};
-		if (input.connector) enriched.connector = input.connector;
-		if (channelId) enriched.channelId = channelId;
-		if (connectorId) enriched.connectorId = connectorId;
-		const event = this.broadcaster.broadcast(input.content, enriched);
-		this.eventLog.record({
-			content: input.content,
-			channelId: channelId ?? null,
-			connectorId: connectorId ?? null,
-			meta: enriched,
-			offset: event.offset
-		});
-		return { offset: event.offset };
-	}
-	lookupChannelId(channelName) {
-		return this.settings.read().channels.find((c) => c.name === channelName)?.id ?? null;
-	}
-	lookupConnectorId(channelId, connectorName) {
-		return (this.settings.read().channels.find((c) => c.id === channelId)?.connectors.find((c) => c.name === connectorName))?.id ?? null;
-	}
-};
-//#endregion
-//#region lib/gateway/gateway-token.ts
-const TOKEN_FILE_NAME = "gateway.token";
-const TOKEN_BYTES = 32;
-const defaultFs = new NodeFunnelFileSystem();
-const defaultGenerate = () => {
-	const buf = new Uint8Array(TOKEN_BYTES);
-	crypto.getRandomValues(buf);
-	return [...buf].map((b) => b.toString(16).padStart(2, "0")).join("");
-};
-/**
-* Reads / generates the gateway daemon token used to authenticate
-* `/listeners*`, `/status`, and `/ws` connections.
-*
-* Token file: `<dir>/gateway.token` (default `~/.funnel/gateway.token`),
-* written with mode 0600. Clients on the same machine as the daemon read
-* the file directly; the token never leaves the user's home directory.
-*/
-var FunnelGatewayToken = class {
-	fs;
-	path;
-	generate;
-	constructor(deps = {}) {
-		this.fs = deps.fs ?? defaultFs;
-		this.path = join(deps.dir ?? FUNNEL_DIR, TOKEN_FILE_NAME);
-		this.generate = deps.generate ?? defaultGenerate;
-		Object.freeze(this);
-	}
-	read() {
-		if (!this.fs.existsSync(this.path)) return null;
-		const value = this.fs.readFileSync(this.path).trim();
-		return value.length > 0 ? value : null;
-	}
-	/**
-	* Returns the existing token or, if missing, generates one and writes it with mode 0600.
-	*
-	* NOTE: not atomic — two concurrent `ensure()` calls (e.g., `fnl gateway start` racing
-	* itself before the PID lock is acquired) could each generate independent tokens. The
-	* gateway PID file makes this practically a non-issue; if you need stronger guarantees,
-	* take a file lock around this call externally.
-	*/
-	ensure() {
-		const existing = this.read();
-		if (existing) return existing;
-		const token = this.generate();
-		this.fs.mkdirSync(dirname(this.path), { recursive: true });
-		this.fs.writeSecretFileSync(this.path, `${token}\n`);
-		return token;
+	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({
@@ -3827,7 +1034,7 @@ const buildFunnelDebugReport = async (deps, channelFilter) => {
 			errors: listenerEntry.errors,
 			lastEventAt: listenerEntry.lastEventAt
 		} : null;
-		const claudeClients = (gatewayData?.clients ?? []).filter((cl) => !cl.tapAll && (cl.channelName === ch.name || cl.channel === ch.name));
+		const claudeClients = (gatewayData?.clients ?? []).filter((cl) => cl.channelName === ch.name || cl.channel === ch.name);
 		report.channels.push({
 			name: ch.name,
 			connectors: ch.connectors.map((conn) => conn.name),
@@ -3870,15 +1077,14 @@ const SANDBOX_DIR = "/sandbox/.funnel";
 const SANDBOX_TMP_DIR = "/sandbox/tmp";
 const noopOnError = () => {};
 /**
-* Facade exposing every funnel facet as a getter.
+* Facade that wires every funnel facet together and exposes the public surface.
 *
-* The same `Funnel` is used by the CLI and as a programmable library.
-* All side-effecting boundaries (filesystem, process, logger, clock, id, paths) are
-* injectable via `Props` — passing memory implementations gives a fully sandboxed
+* All side-effecting boundaries (filesystem, process, logger, clock, id, paths)
+* are injected via Props — passing memory implementations gives a fully sandboxed
 * Funnel that touches no real disk, processes, or wall-clock time.
 *
-* Connectors live nested inside their owning channel (channels[].connectors[]),
-* so connector CRUD is reached via `funnel.channels.addConnector(...)` etc.
+* Fully immutable: all fields are resolved in the constructor and frozen.
+* No lazy initialisation — every dependency is wired at construction time.
 *
 * @example
 * ```ts
@@ -3889,9 +1095,104 @@ const noopOnError = () => {};
 * ```
 */
 var Funnel = class Funnel {
-	memos = {};
+	paths;
+	channels;
+	gateway;
+	gatewayToken;
+	publisher;
+	listeners;
+	claude;
+	profiles;
+	localConfig;
+	localConfigSync;
+	fs;
+	process;
+	logger;
+	clock;
+	onError;
 	constructor(props = {}) {
-		this.props = props;
+		const dir = props.dir ?? resolveFunnelDir();
+		const tmpDir = props.tmpDir ?? funnelTmpDir();
+		const fs = props.fs ?? new NodeFunnelFileSystem();
+		const process = props.process ?? new NodeFunnelProcessRunner();
+		const clock = props.clock ?? new NodeFunnelClock();
+		const idGenerator = props.idGenerator ?? new NodeFunnelIdGenerator();
+		this.paths = {
+			dir,
+			tmpDir,
+			settings: join(dir, "settings.json")
+		};
+		this.fs = fs;
+		this.process = process;
+		this.logger = props.logger;
+		this.clock = clock;
+		this.onError = props.onError ?? noopOnError;
+		const store = props.store ?? new FunnelSettingsStore({
+			path: this.paths.settings,
+			fs,
+			idGenerator
+		});
+		const factory = new FunnelConnectorFactory({
+			fs,
+			process,
+			logger: this.logger,
+			diagnosticLog: props.diagnosticLog,
+			dir,
+			slackListenerOptions: props.slackListenerOptions,
+			scheduleListenerOptions: props.scheduleListenerOptions
+		});
+		this.channels = new FunnelChannels({
+			store,
+			factory,
+			clock,
+			idGenerator
+		});
+		this.gateway = new FunnelGateway({
+			fs,
+			process,
+			clock,
+			dir,
+			tmpDir,
+			port: props.port
+		});
+		this.gatewayToken = new FunnelGatewayToken({
+			fs,
+			dir
+		});
+		this.publisher = new FunnelChannelPublisher({
+			port: this.gateway.getPort(),
+			isDaemonRunning: () => this.gateway.isRunning(),
+			getToken: () => this.gatewayToken.read()
+		});
+		this.listeners = new FunnelListenersClient({
+			port: this.gateway.getPort(),
+			isDaemonRunning: () => this.gateway.isRunning(),
+			getToken: () => this.gatewayToken.read()
+		});
+		const mcp = new FunnelMcp({ fs });
+		this.profiles = new FunnelProfiles({
+			store,
+			idGenerator,
+			fs
+		});
+		this.localConfig = new FunnelLocalConfig({ fs });
+		this.localConfigSync = new FunnelLocalConfigSync({
+			channels: this.channels,
+			prompter: props.tokenPrompter ?? new NodeFunnelTokenPrompter()
+		});
+		this.claude = new FunnelClaude({
+			channels: this.channels,
+			mcp,
+			gateway: this.gateway,
+			sessions: this.profiles,
+			guard: new FileProcessGuard({
+				fs,
+				process,
+				dir
+			}),
+			process,
+			logger: this.logger
+		});
 		Object.freeze(this);
 	}
 	/**
@@ -3901,6 +1202,7 @@ var Funnel = class Funnel {
 	*/
 	static inMemory(props = {}) {
 		return new Funnel({
+			...props,
 			store: props.store ?? new MockFunnelSettingsReader(),
 			fs: props.fs ?? new MemoryFunnelFileSystem(),
 			process: props.process ?? new MemoryFunnelProcessRunner(),
@@ -3911,184 +1213,6 @@ var Funnel = class Funnel {
 			tmpDir: props.tmpDir ?? SANDBOX_TMP_DIR
 		});
 	}
-	/** Resolved on-disk paths the facade will read/write when methods are called. Pure compute, not memoized. */
-	get paths() {
-		const dir = this.props.dir ?? resolveFunnelDir();
-		return {
-			dir,
-			tmpDir: this.props.tmpDir ?? funnelTmpDir(),
-			settings: join(dir, "settings.json")
-		};
-	}
-	/** Filesystem boundary. Defaults to NodeFunnelFileSystem. */
-	get fs() {
-		if (!this.memos.fs) this.memos.fs = this.props.fs ?? new NodeFunnelFileSystem();
-		return this.memos.fs;
-	}
-	/** Process runner boundary. Defaults to NodeFunnelProcessRunner. */
-	get process() {
-		if (!this.memos.process) this.memos.process = this.props.process ?? new NodeFunnelProcessRunner();
-		return this.memos.process;
-	}
-	/** Logger boundary. Optional — when no logger is injected, every facet's `this.logger?.x` call is a silent no-op. Production entry points (cli, daemon) inject a NodeFunnelLogger. */
-	get logger() {
-		return this.props.logger;
-	}
-	/** Clock boundary. Defaults to NodeFunnelClock. */
-	get clock() {
-		if (!this.memos.clock) this.memos.clock = this.props.clock ?? new NodeFunnelClock();
-		return this.memos.clock;
-	}
-	/**
-	* Error hook. Forwards Funnel-internal exceptions that would otherwise be
-	* swallowed. Defaults to a no-op when no host hook was passed.
-	*/
-	get onError() {
-		return this.props.onError ?? noopOnError;
-	}
-	/** ID generator boundary. Defaults to NodeFunnelIdGenerator. */
-	get idGenerator() {
-		if (!this.memos.idGenerator) this.memos.idGenerator = this.props.idGenerator ?? new NodeFunnelIdGenerator();
-		return this.memos.idGenerator;
-	}
-	/** Settings reader. If not injected, a FunnelSettingsStore rooted at `dir` is created. */
-	get store() {
-		if (!this.memos.store) this.memos.store = this.props.store ?? new FunnelSettingsStore({
-			path: this.paths.settings,
-			fs: this.fs,
-			idGenerator: this.idGenerator
-		});
-		return this.memos.store;
-	}
-	/** Pure factory that constructs per-type listeners and adapters from connector configs. */
-	get factory() {
-		if (!this.memos.factory) this.memos.factory = new FunnelConnectorFactory({
-			fs: this.fs,
-			process: this.process,
-			logger: this.logger,
-			diagnosticLog: this.props.diagnosticLog,
-			dir: this.paths.dir,
-			slackListenerOptions: this.props.slackListenerOptions,
-			scheduleListenerOptions: this.props.scheduleListenerOptions
-		});
-		return this.memos.factory;
-	}
-	/** Channel CRUD + nested connector CRUD + schedule entries + listener/adapter dispatch. */
-	get channels() {
-		if (!this.memos.channels) this.memos.channels = new FunnelChannels({
-			store: this.store,
-			factory: this.factory,
-			profileChecker: this.profiles,
-			clock: this.clock,
-			idGenerator: this.idGenerator
-		});
-		return this.memos.channels;
-	}
-	/** Launch profiles (named presets for `fnl claude`: path + sub-agent + channel id). */
-	get profiles() {
-		if (!this.memos.profiles) this.memos.profiles = new FunnelProfiles({
-			store: this.store,
-			idGenerator: this.idGenerator
-		});
-		return this.memos.profiles;
-	}
-	/** Reads `funnel.json` from a cwd. `fnl claude` consults it before falling back to the default profile. */
-	get localConfig() {
-		if (!this.memos.localConfig) this.memos.localConfig = new FunnelLocalConfig({ fs: this.fs });
-		return this.memos.localConfig;
-	}
-	/** Writes the stable `id` into funnel.json on first launch so state can be scoped to `~/.funnel/projects/<id>/`. */
-	get localConfigWriter() {
-		if (!this.memos.localConfigWriter) this.memos.localConfigWriter = new FunnelLocalConfigWriter({ fs: this.fs });
-		return this.memos.localConfigWriter;
-	}
-	/** Secret prompter. Defaults to a TTY-only stdin reader; tests inject MemoryFunnelTokenPrompter. */
-	get tokenPrompter() {
-		if (!this.memos.tokenPrompter) this.memos.tokenPrompter = this.props.tokenPrompter ?? new NodeFunnelTokenPrompter();
-		return this.memos.tokenPrompter;
-	}
-	/** Reconciles funnel.json's channel + connectors with `~/.funnel/settings.json` on launch. */
-	get localConfigSync() {
-		if (!this.memos.localConfigSync) this.memos.localConfigSync = new FunnelLocalConfigSync({
-			channels: this.channels,
-			prompter: this.tokenPrompter
-		});
-		return this.memos.localConfigSync;
-	}
-	/** funnel MCP installer (writes/removes `.mcp.json` entries in target repos). */
-	get mcp() {
-		if (!this.memos.mcp) this.memos.mcp = new FunnelMcp({ fs: this.fs });
-		return this.memos.mcp;
-	}
-	/** Launch Claude Code with a channel injected via env, MCP installed, gateway ensured. */
-	get claude() {
-		if (!this.memos.claude) this.memos.claude = new FunnelClaude({
-			channels: this.channels,
-			mcp: this.mcp,
-			gateway: this.gateway,
-			profiles: this.profiles,
-			fs: this.fs,
-			process: this.process,
-			idGenerator: this.idGenerator,
-			logger: this.logger,
-			dir: this.paths.dir
-		});
-		return this.memos.claude;
-	}
-	/** Gateway daemon controller (PID-file, start/stop the separate `bun daemon.ts` process). */
-	get gateway() {
-		if (!this.memos.gateway) this.memos.gateway = new FunnelGateway({
-			fs: this.fs,
-			process: this.process,
-			clock: this.clock,
-			dir: this.paths.dir,
-			tmpDir: this.paths.tmpDir,
-			port: this.props.port
-		});
-		return this.memos.gateway;
-	}
-	/** Read / generate the daemon's gateway token (mode 0600 file under `dir`). */
-	get gatewayToken() {
-		if (!this.memos.gatewayToken) this.memos.gatewayToken = new FunnelGatewayToken({
-			fs: this.fs,
-			dir: this.paths.dir
-		});
-		return this.memos.gatewayToken;
-	}
-	/**
-	* HTTP client for `POST /channels/:channel/publish` on the running gateway
-	* daemon. Use it to push arbitrary content into a channel from outside any
-	* connector. Returns `{ state: "offline" }` if the daemon isn't up.
-	*/
-	get publisher() {
-		if (!this.memos.publisher) {
-			const gateway = this.gateway;
-			const token = this.gatewayToken;
-			this.memos.publisher = new FunnelChannelPublisher({
-				port: gateway.getPort(),
-				isDaemonRunning: () => gateway.isRunning(),
-				getToken: () => token.read()
-			});
-		}
-		return this.memos.publisher;
-	}
-	/**
-	* HTTP client for listener operations on the running gateway daemon.
-	* Returns `{ state: "offline" }` when the daemon is offline so hot-reload
-	* paths stay write-only without parsing strings.
-	*/
-	get listeners() {
-		if (!this.memos.listeners) {
-			const gateway = this.gateway;
-			const token = this.gatewayToken;
-			this.memos.listeners = new FunnelListenersClient({
-				port: gateway.getPort(),
-				isDaemonRunning: () => gateway.isRunning(),
-				getToken: () => token.read()
-			});
-		}
-		return this.memos.listeners;
-	}
 	/**
 	* In-process gateway server. Unlike `gateway.start()` (which spawns a daemon),
 	* this returns a class that runs `Bun.serve` + listeners inside the current process —
@@ -4097,7 +1221,6 @@ var Funnel = class Funnel {
 	gatewayServer(options = {}) {
 		return new FunnelGatewayServer({
 			channels: this.channels,
-			settings: this.store,
 			port: options.port,
 			hostname: options.hostname,
 			dbPath: options.dbPath,
@@ -4112,6 +1235,20 @@ var Funnel = class Funnel {
 			extraRoutes: options.extraRoutes
 		});
 	}
+	/**
+	* Run the gateway daemon in the foreground (tied to this terminal).
+	* For background daemon management, use `funnel.gateway.start()` instead.
+	*/
+	async runGatewayForeground(options = {}) {
+		const gatewayScript = resolveDaemonScript();
+		const command = options.caffeinate !== false && globalThis.process.platform === "darwin" ? [
+			"caffeinate",
+			"-is",
+			"bun",
+			gatewayScript
+		] : ["bun", gatewayScript];
+		return this.process.attach(command);
+	}
 	async debug(channelName) {
 		return buildFunnelDebugReport({
 			gateway: this.gateway,
@@ -4125,331 +1262,6 @@ var Funnel = class Funnel {
 	}
 };
 //#endregion
-//#region lib/engine/mcp/channel-subscriber.ts
-const RECONNECT_DELAY = 1e3;
-const MAX_RECONNECT_DELAY = 1e4;
-/**
-* Subscribes to the gateway WebSocket for a single channel and forwards
-* incoming events to the MCP server as `notifications/claude/channel`.
-* Reconnects with exponential backoff and replays missed events via `?since=<offset>`.
-*/
-var FunnelChannelSubscriber = class {
-	state = {
-		reconnectDelay: RECONNECT_DELAY,
-		lastOffset: 0
-	};
-	constructor(props) {
-		this.props = props;
-		Object.freeze(this);
-	}
-	start() {
-		this.connect();
-	}
-	connect() {
-		const sinceQuery = this.state.lastOffset > 0 ? `&since=${this.state.lastOffset}` : "";
-		const wsUrl = `${this.props.baseUrl}${sinceQuery}`;
-		const ws = new WebSocket(wsUrl, this.props.protocols);
-		ws.addEventListener("open", () => {
-			this.state.reconnectDelay = RECONNECT_DELAY;
-			process.stderr.write(`funnel: connected (${wsUrl})\n`);
-		});
-		ws.addEventListener("message", (event) => this.handleMessage(event));
-		ws.addEventListener("close", () => {
-			process.stderr.write(`funnel: disconnected, reconnecting in ${this.state.reconnectDelay}ms\n`);
-			setTimeout(() => this.connect(), this.state.reconnectDelay);
-			this.state.reconnectDelay = Math.min(this.state.reconnectDelay * 2, MAX_RECONNECT_DELAY);
-		});
-		ws.addEventListener("error", () => {});
-	}
-	async handleMessage(event) {
-		try {
-			const payload = JSON.parse(String(event.data));
-			const eventType = payload.meta?.event_type ?? "unknown";
-			if (typeof payload.offset === "number" && payload.offset > this.state.lastOffset) this.state.lastOffset = payload.offset;
-			process.stderr.write(`funnel: received event (${eventType})\n`);
-			await this.props.server.notification({
-				method: "notifications/claude/channel",
-				params: {
-					content: payload.content,
-					meta: payload.meta
-				}
-			});
-		} catch (error) {
-			process.stderr.write(`funnel: error: ${error instanceof Error ? error.message : String(error)}\n`);
-		}
-	}
-};
-//#endregion
-//#region lib/engine/mcp/read-channel-connectors.ts
-const TOOL_CONNECTOR_TYPES = new Set([
-	"slack",
-	"gh",
-	"discord"
-]);
-const readChannelConnectors = (dir, channelId) => {
-	const settingsPath = join(dir, "settings.json");
-	if (!existsSync(settingsPath)) return null;
-	const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
-	const parsed = settingsSchema.safeParse(raw);
-	if (!parsed.success) return null;
-	const channel = parsed.data.channels.find((c) => c.id === channelId);
-	if (!channel) return null;
-	const connectors = channel.connectors.filter((c) => TOOL_CONNECTOR_TYPES.has(c.type)).map((c) => ({
-		name: c.name,
-		type: c.type
-	}));
-	return {
-		channelName: channel.name,
-		connectors
-	};
-};
-//#endregion
-//#region lib/engine/mcp/read-gateway-token.ts
-const readGatewayToken = (dir) => {
-	const fromEnv = process.env.FUNNEL_GATEWAY_TOKEN;
-	if (fromEnv && fromEnv.length > 0) return fromEnv;
-	const path = join(dir, "gateway.token");
-	if (!existsSync(path)) return null;
-	const value = readFileSync(path, "utf-8").trim();
-	return value.length > 0 ? value : null;
-};
-//#endregion
-//#region lib/engine/mcp/usage-hint-for-type.ts
-const usageHintForType = (type) => {
-	if (type === "slack") return [
-		"Slack Web API.",
-		"To reply in the same thread: method=POST path=chat.postMessage body={ channel: meta.channel_id, text: \"...\", thread_ts: meta.thread_ts }",
-		"To react: method=POST path=reactions.add body={ channel: meta.channel_id, timestamp: meta.thread_ts, name: \"thumbsup\" }",
-		"Use meta fields from the incoming event: channel_id (Slack channel), thread_ts (thread anchor), user_id (sender)."
-	].join(" ");
-	if (type === "discord") return [
-		"Discord REST API.",
-		"To reply: method=POST path=/channels/<meta.channel_id>/messages body={ content: \"...\" }",
-		"Use meta fields: channel_id (Discord channel), user_id (sender), guild_id."
-	].join(" ");
-	if (type === "gh") return [
-		"GitHub REST via gh CLI.",
-		"To comment: method=POST path=repos/<meta.repository>/issues/<number>/comments body={ body: \"...\" }",
-		"Parse <number> from meta.subject_url. meta fields: repository (owner/repo), subject_type, subject_url, reason."
-	].join(" ");
-	return "Generic adapter call.";
-};
-//#endregion
-//#region lib/engine/mcp/channel-server.ts
-const DEFAULT_FUNNEL_DIR = join(homedir(), ".funnel");
-const BUILTIN_TOOL_NAMES = ["fnl_status", "fnl_debug"];
-const isBuiltinTool = (name) => BUILTIN_TOOL_NAMES.includes(name);
-const readAllChannels = (dir) => {
-	const settingsPath = join(dir, "settings.json");
-	if (!existsSync(settingsPath)) return [];
-	try {
-		const raw = JSON.parse(readFileSync(settingsPath, "utf-8"));
-		const parsed = settingsSchema.safeParse(raw);
-		if (!parsed.success) return [];
-		return parsed.data.channels.map((c) => ({
-			id: c.id,
-			name: c.name
-		}));
-	} catch {
-		return [];
-	}
-};
-const startChannelServer = async (options = {}) => {
-	const dir = options.dir ?? DEFAULT_FUNNEL_DIR;
-	const gatewayBaseUrl = options.gatewayUrl ?? process.env.FUNNEL_GATEWAY_URL ?? `http://127.0.0.1:${resolveFunnelPort()}`;
-	const gatewayWsUrl = `${gatewayBaseUrl.replace(/^http/, "ws")}/ws`;
-	const channelId = options.channelId ?? process.env.FUNNEL_CHANNEL_ID;
-	const channel = channelId ? readChannelConnectors(dir, channelId) : null;
-	const token = options.token ?? readGatewayToken(dir);
-	const allChannels = readAllChannels(dir);
-	const currentChannelName = channel?.channelName ?? null;
-	const channelContext = allChannels.length > 0 ? [
-		"",
-		"Configured channels (use as the `channel` argument to fnl_debug):",
-		...allChannels.map((ch) => `  ${ch.name}${ch.name === currentChannelName ? " ← this session" : ""}`)
-	].join("\n") : "";
-	const server = new Server({
-		name: FUNNEL_MCP_NAME,
-		version: "1.0.0"
-	}, {
-		capabilities: {
-			experimental: { "claude/channel": {} },
-			tools: {}
-		},
-		instructions: [
-			`Events arrive as notifications (method: notifications/claude/channel) with two fields:`,
-			`  content — the event payload as a JSON string (parse it to read the message)`,
-			`  meta    — key/value strings describing the event`,
-			"",
-			"meta fields by event_type:",
-			"  slack:    event_type=slack  channel_id=C…  thread_ts=1234.5678  user_id=U…  mentioned=true|false",
-			"  gh:       event_type=gh     repository=owner/repo  subject_type=Issue|PullRequest  subject_url=…  reason=…",
-			"  discord:  event_type=discord  channel_id=…  user_id=…  guild_id=…  mentioned=true|false",
-			"  schedule: event_type=schedule  entry_id=…",
-			"",
-			"To reply to a Slack message in the same thread, call the connector tool with:",
-			`  method: POST`,
-			`  path:   chat.postMessage`,
-			`  body:   { channel: meta.channel_id, text: "your reply", thread_ts: meta.thread_ts }`,
-			"",
-			"To comment on a GitHub issue/PR (extract from subject_url in meta):",
-			`  method: POST`,
-			`  path:   repos/<meta.repository>/issues/<number>/comments   (parse number from meta.subject_url)`,
-			`  body:   { body: "your reply" }`,
-			"",
-			"Built-in diagnostic tools — call proactively when events seem missing or delayed:",
-			"  fnl_status — gateway running state, all listeners alive/dead, Claude WS clients",
-			"  fnl_debug  — per-channel diagnosis with last 10 events, rootCause, suggestedActions",
-			"               omit channel arg to diagnose all channels; check summary.suggestedActions first",
-			channelContext
-		].join("\n")
-	});
-	server.setRequestHandler(ListToolsRequestSchema, async () => {
-		const connectorTools = (channel?.connectors ?? []).map((c) => ({
-			name: c.name,
-			description: `Call the "${c.name}" (${c.type}) connector. ${usageHintForType(c.type)}`,
-			inputSchema: {
-				type: "object",
-				properties: {
-					method: {
-						type: "string",
-						description: "HTTP verb or API method (e.g. POST, chat.postMessage)"
-					},
-					path: {
-						type: "string",
-						description: "API path or method name (adapter-specific)"
-					},
-					body: {
-						type: "object",
-						description: "Request body / params (adapter-specific)"
-					}
-				},
-				required: ["method", "path"]
-			}
-		}));
-		const channelEnum = allChannels.length > 0 ? allChannels.map((ch) => ch.name) : void 0;
-		const builtinTools = [{
-			name: "fnl_status",
-			description: "Return the current funnel gateway status as JSON — gateway running state, listener alive/dead per channel, and connected Claude WS clients. Call this when you need to check whether the gateway is up or why events stopped arriving.",
-			inputSchema: {
-				type: "object",
-				properties: {}
-			}
-		}, {
-			name: "fnl_debug",
-			description: "Return a full channel diagnosis as JSON — gateway health, listener state, Claude WS connection, last 10 inbound events with outcome, connectionErrors (when listener is dead), and diagnosis.rootCause. Call this first when debugging missing events. Omit `channel` to diagnose all channels at once.",
-			inputSchema: {
-				type: "object",
-				properties: { channel: channelEnum ? {
-					type: "string",
-					description: `Channel name to inspect. One of: ${channelEnum.join(", ")}. Omit to get all channels.`,
-					enum: channelEnum
-				} : {
-					type: "string",
-					description: "Channel name to inspect. Omit to get all channels."
-				} }
-			}
-		}];
-		return { tools: [...connectorTools, ...builtinTools] };
-	});
-	server.setRequestHandler(CallToolRequestSchema, async (request) => {
-		const toolName = request.params.name;
-		if (isBuiltinTool(toolName)) return handleBuiltinTool(toolName, request.params.arguments, gatewayBaseUrl, token, allChannels);
-		if (!channel) throw new Error("FUNNEL_CHANNEL_ID is not set or channel not found in settings.json");
-		const args = request.params.arguments ?? {};
-		const method = typeof args.method === "string" ? args.method : "";
-		const path = typeof args.path === "string" ? args.path : "";
-		const body = args.body ?? {};
-		if (!method || !path) throw new Error("`method` and `path` are required");
-		const url = `${gatewayBaseUrl}/channels/${encodeURIComponent(channel.channelName)}/connectors/${encodeURIComponent(toolName)}/call`;
-		const headers = { "content-type": "application/json" };
-		if (token) headers.authorization = `Bearer ${token}`;
-		const res = await fetch(url, {
-			method: "POST",
-			headers,
-			body: JSON.stringify({
-				method,
-				path,
-				body
-			})
-		});
-		const text = await res.text();
-		if (!res.ok) throw new Error(`gateway call failed (${res.status}): ${text}`);
-		return { content: [{
-			type: "text",
-			text
-		}] };
-	});
-	const transport = new StdioServerTransport();
-	await server.connect(transport);
-	if (!channelId) return;
-	new FunnelChannelSubscriber({
-		server,
-		baseUrl: `${gatewayWsUrl}?channel=${encodeURIComponent(channelId)}`,
-		protocols: token ? [`funnel.token.${token}`] : void 0
-	}).start();
-};
-const handleBuiltinTool = async (name, args, gatewayBaseUrl, token, allChannels) => {
-	const headers = {};
-	if (token) headers.authorization = `Bearer ${token}`;
-	if (name === "fnl_status") {
-		const res = await fetch(`${gatewayBaseUrl}/status`, { headers }).catch(() => null);
-		if (!res) return { content: [{
-			type: "text",
-			text: JSON.stringify({
-				running: false,
-				error: "gateway unreachable",
-				hint: "run: fnl gateway start",
-				knownChannels: allChannels.map((ch) => ch.name)
-			})
-		}] };
-		const body = await res.json();
-		return { content: [{
-			type: "text",
-			text: JSON.stringify(body)
-		}] };
-	}
-	const channelArg = typeof args?.channel === "string" ? args.channel : null;
-	const url = channelArg ? `${gatewayBaseUrl}/debug?channel=${encodeURIComponent(channelArg)}` : `${gatewayBaseUrl}/debug`;
-	const res = await fetch(url, { headers }).catch(() => null);
-	if (!res) return { content: [{
-		type: "text",
-		text: JSON.stringify({
-			gateway: { running: false },
-			channels: allChannels.map((ch) => ({
-				id: ch.id,
-				name: ch.name,
-				diagnosis: {
-					status: "error",
-					message: "gateway is not running",
-					nextAction: "fnl gateway start",
-					rootCause: null
-				}
-			}))
-		})
-	}] };
-	const body = await res.json();
-	return { content: [{
-		type: "text",
-		text: JSON.stringify(body)
-	}] };
-};
-//#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."
-	};
-};
-//#endregion
 //#region lib/engine/logger/node-logger.ts
 const defaultLogFile = () => join(funnelTmpDir(), "funnel.log");
 var NodeFunnelLogger = class extends FunnelLogger {
@@ -4490,493 +1302,6 @@ var NoopFunnelLogger = class extends FunnelLogger {
 	error() {}
 };
 //#endregion
-//#region lib/engine/token-prompter/memory-token-prompter.ts
-/**
-* Pre-seeded answers keyed by prompt label. Tests configure the map up front;
-* unmapped labels throw so the test surfaces unexpected prompts loudly.
-*/
-var MemoryFunnelTokenPrompter = class extends FunnelTokenPrompter {
-	answers;
-	asked = [];
-	constructor(props = {}) {
-		super();
-		this.answers = new Map(Object.entries(props.answers ?? {}));
-	}
-	async promptSecret(label) {
-		this.asked.push(label);
-		const answer = this.answers.get(label);
-		if (answer === void 0) throw new Error(`no answer seeded for prompt "${label}"`);
-		return answer;
-	}
-};
-//#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
@@ -5465,7 +1790,6 @@ modes:
   fanout      every connected WS client receives every event (default)
   exclusive   each event is delivered to exactly one connected client (round-robin)
 
-tap=all clients (TUI dashboard, debugging) always receive regardless of mode.
 `), (c) => {
 	const param = c.req.valid("param");
 	c.env.funnel.channels.setDelivery(param.channel, param.mode);
@@ -5662,19 +1986,19 @@ const claudeHandler = factory.createHandlers(zValidator$1("query", z.object({
 	channel: z.string().optional()
 }).passthrough(), claudeHelp), async (c) => {
 	const query = c.req.valid("query");
-	const funnel = c.env.funnel;
+	const { funnel, claude, profiles, localConfig, localConfigSync } = c.env;
 	const userArgs = queryToCliArgs(c.req.url, RESERVED_KEYS$1);
 	if (query.channel && !query.profile) {
-		const exitCode = await funnel.claude.launch({
+		const exitCode = await claude.launch({
 			channel: query.channel,
 			userArgs
 		});
 		process.exit(exitCode);
 	}
 	if (query.profile) {
-		const profile = funnel.profiles.get(query.profile);
+		const profile = profiles.get(query.profile);
 		if (!profile) throw new HTTPException(404, { message: `profile "${query.profile}" not found` });
-		const exitCode = await funnel.claude.launch({
+		const exitCode = await claude.launch({
 			channel: profile.channelId,
 			cwd: profile.path,
 			userArgs,
@@ -5686,24 +2010,24 @@ const claudeHandler = factory.createHandlers(zValidator$1("query", z.object({
 		process.exit(exitCode);
 	}
 	const cwd = process.cwd();
-	const local = funnel.localConfig.read(cwd);
+	const local = localConfig.read(cwd);
 	if (local) {
 		const picked = query.channel !== void 0 ? local.channels.find((c) => c.name === query.channel) : local.channels[0];
 		if (!picked) throw new HTTPException(404, { message: query.channel ? `channel "${query.channel}" is not declared in funnel.json` : `funnel.json declares no channels` });
-		const synced = await funnel.localConfigSync.ensure(picked);
+		const synced = await localConfigSync.ensure(picked);
 		for (const outcome of synced.touched) if (outcome.changed) await funnel.listeners.restart(picked.name, outcome.name);
 		else await funnel.listeners.start(picked.name, outcome.name);
 		for (const name of synced.removed) await funnel.listeners.stop(picked.name, name);
-		const exitCode = await funnel.claude.launch({
+		const exitCode = await claude.launch({
 			channel: picked.name,
 			cwd,
 			userArgs
 		});
 		process.exit(exitCode);
 	}
-	const defaultProfile = funnel.profiles.getDefault();
+	const defaultProfile = profiles.getDefault();
 	if (!defaultProfile) return c.text(claudeHelp);
-	const exitCode = await funnel.claude.launch({
+	const exitCode = await claude.launch({
 		channel: defaultProfile.channelId,
 		cwd: defaultProfile.path,
 		userArgs,
@@ -6196,7 +2520,7 @@ const buildChannelReport = async (targetChannel, gatewayStatus, gatewayBodyOrNul
 			errors: l.errors,
 			lastEventAt: l.lastEventAt
 		}));
-		baseReport.claudeClients = gatewayBodyOrNull.clients.filter((cl) => !cl.tapAll && cl.channelName === targetChannelName).length;
+		baseReport.claudeClients = gatewayBodyOrNull.clients.filter((cl) => cl.channelName === targetChannelName).length;
 	}
 	if (store) {
 		const evRows = queryRows(new ConnectorDiagnosticSqlReader(store), "SELECT seq, ts, type, outcome, payload FROM processed WHERE channel_id = ? ORDER BY seq DESC LIMIT ?", [targetChannel.id, limit]);
@@ -6706,15 +3030,7 @@ examples:
   funnel gateway run
   funnel gateway run --no-caffeine`), async (c) => {
 	const query = c.req.valid("query");
-	const funnel = c.env.funnel;
-	const gatewayScript = resolveDaemonScript();
-	const command = query["no-caffeine"] !== "true" && process.platform === "darwin" ? [
-		"caffeinate",
-		"-is",
-		"bun",
-		gatewayScript
-	] : ["bun", gatewayScript];
-	const exitCode = await funnel.process.attach(command);
+	const exitCode = await c.env.funnel.runGatewayForeground({ caffeinate: query["no-caffeine"] !== "true" });
 	process.exit(exitCode);
 });
 //#endregion
@@ -6858,10 +3174,11 @@ const profilesAddHandler = factory.createHandlers(zValidator$1("param", z.object
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
 	const funnel = c.env.funnel;
+	const { profiles, claude } = c.env;
 	const channel = funnel.channels.get(query.channel);
 	if (!channel) throw new HTTPException(400, { message: `channel "${query.channel}" not found` });
 	const recipe = parseProfileRecipe(query);
-	funnel.profiles.add({
+	profiles.add({
 		name: param.profile,
 		path: query.path,
 		channelId: channel.id,
@@ -6877,7 +3194,9 @@ usage: funnel profiles <name> as-default
 
 the first profile in the list is treated as the default for fnl claude.`), (c) => {
 	const param = c.req.valid("param");
-	c.env.funnel.profiles.asDefault(param.profile);
+	c.env.funnel;
+	const { profiles, claude } = c.env;
+	profiles.asDefault(param.profile);
 	return c.text(`profile "${param.profile}" is now the default`);
 });
 //#endregion
@@ -6903,7 +3222,9 @@ const profilesRenameHandler = factory.createHandlers(zValidator$1("param", z.obj
 	newName: z.string()
 })), zValidator$1("query", z.object({})), (c) => {
 	const param = c.req.valid("param");
-	c.env.funnel.profiles.rename(param.profile, param.newName);
+	c.env.funnel;
+	const { profiles, claude } = c.env;
+	profiles.rename(param.profile, param.newName);
 	return c.text(`renamed profile "${param.profile}" to "${param.newName}"`);
 });
 //#endregion
@@ -6915,10 +3236,11 @@ usage: funnel profiles <name> run [additional claude args...]
 const RESERVED_KEYS = [];
 const profilesLaunchHandler = factory.createHandlers(zValidator$1("param", z.object({ profile: z.string() })), zValidator$1("query", z.object({}).passthrough(), launchHelp), async (c) => {
 	const param = c.req.valid("param");
-	const funnel = c.env.funnel;
-	const profile = funnel.profiles.get(param.profile);
+	c.env.funnel;
+	const { profiles, claude } = c.env;
+	const profile = profiles.get(param.profile);
 	if (!profile) throw new HTTPException(404, { message: `profile "${param.profile}" not found` });
-	const exitCode = await funnel.claude.launch({
+	const exitCode = await claude.launch({
 		channel: profile.channelId,
 		cwd: profile.path,
 		userArgs: queryToCliArgs(c.req.url, RESERVED_KEYS),
@@ -6939,7 +3261,9 @@ const profilesRemoveHelpHandler = factory.createHandlers((c) => c.text(help$1));
 //#region lib/cli/routes/profiles.remove.$profile.ts
 const profilesRemoveHandler = factory.createHandlers(zValidator$1("param", z.object({ profile: z.string() })), zValidator$1("query", z.object({})), (c) => {
 	const param = c.req.valid("param");
-	c.env.funnel.profiles.remove(param.profile);
+	c.env.funnel;
+	const { profiles, claude } = c.env;
+	profiles.remove(param.profile);
 	return c.text(`removed profile "${param.profile}"`);
 });
 //#endregion
@@ -6973,10 +3297,11 @@ const profilesSetHandler = factory.createHandlers(zValidator$1("param", z.object
 	const param = c.req.valid("param");
 	const query = c.req.valid("query");
 	const funnel = c.env.funnel;
+	const { profiles, claude } = c.env;
 	const channel = query.channel !== void 0 ? funnel.channels.get(query.channel) : null;
 	if (query.channel !== void 0 && !channel) throw new HTTPException(400, { message: `channel "${query.channel}" not found` });
 	const recipe = parseProfileRecipe(query);
-	funnel.profiles.update(param.profile, {
+	profiles.update(param.profile, {
 		path: query.path,
 		channelId: channel?.id,
 		options: recipe.options,
@@ -7007,9 +3332,11 @@ examples:
   funnel profiles add cto --path /repo/myapp --channel prod-inbox --agent pm --options "--brief"
   funnel profiles cto as-default
   funnel profiles cto run`), (c) => {
-	const profiles = c.env.funnel.profiles.list();
-	if (profiles.length === 0) return c.text("no profiles");
-	const lines = profiles.map((profile, index) => {
+	c.env.funnel;
+	const { profiles } = c.env;
+	const profileList = profiles.list();
+	if (profileList.length === 0) return c.text("no profiles");
+	const lines = profileList.map((profile, index) => {
 		const tag = index === 0 ? " (default)" : "";
 		const recipe = profile.options.length > 0 ? `, options=${profile.options.join(" ")}` : "";
 		const session = profile.resume ? "" : ", resume=false";
@@ -7061,9 +3388,9 @@ const isGatewayStatus = (value) => {
 	if (!("listeners" in value) || !Array.isArray(value.listeners)) return false;
 	return true;
 };
-const buildStatusLines = async (funnel) => {
+const buildStatusLines = async (funnel, profiles) => {
 	const channels = funnel.channels.list();
-	const profiles = funnel.profiles.list();
+	const profileList = profiles.list();
 	const gatewayStatus = funnel.gateway.getStatus();
 	const lines = [];
 	lines.push("= funnel status =");
@@ -7089,7 +3416,6 @@ const buildStatusLines = async (funnel) => {
 	const listenerAliveByChannel = /* @__PURE__ */ new Map();
 	if (gatewayData) {
 		for (const client of gatewayData.clients) {
-			if (client.tapAll) continue;
 			const key = client.channelName ?? client.channel;
 			clientsByChannel.set(key, (clientsByChannel.get(key) ?? 0) + 1);
 		}
@@ -7110,8 +3436,8 @@ const buildStatusLines = async (funnel) => {
 		lines.push(`  ${indicator} ${paddedName}  [${connectorLabel}]${claudeLabel}`);
 	}
 	lines.push("");
-	lines.push(`profiles: ${profiles.length}`);
-	for (const [index, profile] of profiles.entries()) {
+	lines.push(`profiles: ${profileList.length}`);
+	for (const [index, profile] of profileList.entries()) {
 		const tag = index === 0 ? " (default)" : "";
 		const channel = funnel.channels.getById(profile.channelId);
 		const channelLabel = channel ? channel.name : `id:${profile.channelId}`;
@@ -7132,11 +3458,11 @@ const statusHandler = factory.createHandlers(zValidator$1("query", z.object({
 	const isWatch = query.watch === "true" || query.watch === "";
 	const intervalSec = Math.min(60, Math.max(1, query.interval ? Number(query.interval) : 3));
 	if (!isWatch) {
-		const lines = await buildStatusLines(funnel);
+		const lines = await buildStatusLines(funnel, c.env.profiles);
 		return c.text(lines.join("\n"));
 	}
 	const render = async () => {
-		const lines = await buildStatusLines(funnel);
+		const lines = await buildStatusLines(funnel, c.env.profiles);
 		const ts = (/* @__PURE__ */ new Date()).toISOString().slice(11, 19);
 		process.stdout.write("\x1B[2J\x1B[H");
 		process.stdout.write(lines.join("\n"));
@@ -7178,4 +3504,4 @@ const routes = factory.createApp().onError((error, c) => {
 	return c.text(`error: ${error instanceof Error ? error.message : String(error)}`, 400);
 }).get("/claude", ...claudeHandler).get("/channels", ...channelsGroupHandler).post("/channels/add", ...channelsAddHelpHandler).post("/channels/add/:channel", ...channelsAddHandler).post("/channels/remove", ...channelsRemoveHelpHandler).post("/channels/remove/:channel", ...channelsRemoveHandler).post("/channels/rename/:channel/:newName", ...channelsRenameHandler).post("/channels/:channel/rename/:newName", ...channelsRenameHandler).post("/channels/rename", ...channelsRenameHelpHandler).post("/channels/:channel/rename", ...channelsChannelRenameHelpHandler).post("/channels/:channel/set/delivery/:mode", ...channelsSetDeliveryHandler).post("/channels/publish", ...channelsPublishHelpHandler).post("/channels/:channel/publish", ...channelsPublishHandler).get("/channels/:channel/validate", ...channelsValidateHandler).get("/channels/validate", ...channelsValidateHelpHandler).get("/channels/:channel", ...channelsShowHandler).get("/channels/:channel/connectors", ...channelsConnectorsGroupHandler).post("/channels/:channel/connectors/add", ...channelsConnectorsAddHelpHandler).post("/channels/:channel/connectors/add/:connector", ...channelsConnectorsAddHandler).post("/channels/:channel/connectors/remove", ...channelsConnectorsRemoveHelpHandler).post("/channels/:channel/connectors/remove/:connector", ...channelsConnectorsRemoveHandler).post("/channels/:channel/connectors/set", ...channelsConnectorsSetHelpHandler).post("/channels/:channel/connectors/set/:connector", ...channelsConnectorsSetHandler).post("/channels/:channel/connectors/rename/:connector/:newName", ...channelsConnectorsRenameHandler).post("/channels/:channel/connectors/:connector/rename/:newName", ...channelsConnectorsRenameHandler).post("/channels/:channel/connectors/rename", ...channelsConnectorsRenameHelpHandler).post("/channels/:channel/connectors/:connector/rename", ...channelsConnectorRenameHelpHandler).post("/channels/:channel/connectors/:connector/request", ...channelsConnectorsRequestHandler).get("/channels/:channel/connectors/:connector", ...channelsConnectorsShowHandler).get("/channels/:channel/connectors/:connector/schedules", ...channelsConnectorsSchedulesGroupHandler).post("/channels/:channel/connectors/:connector/schedules/add", ...channelsConnectorSchedulesAddHelpHandler).post("/channels/:channel/connectors/:connector/schedules/add/:id", ...channelsConnectorsSchedulesAddHandler).post("/channels/:channel/connectors/:connector/schedules/remove", ...channelsConnectorSchedulesRemoveHelpHandler).post("/channels/:channel/connectors/:connector/schedules/remove/:id", ...channelsConnectorsSchedulesRemoveHandler).get("/profiles", ...profilesGroupHandler).post("/profiles/add", ...profilesAddHelpHandler).post("/profiles/add/:profile", ...profilesAddHandler).post("/profiles/set", ...profilesSetHelpHandler).post("/profiles/set/:profile", ...profilesSetHandler).post("/profiles/remove", ...profilesRemoveHelpHandler).post("/profiles/remove/:profile", ...profilesRemoveHandler).post("/profiles/rename/:profile/:newName", ...profilesRenameHandler).post("/profiles/:profile/rename/:newName", ...profilesRenameHandler).post("/profiles/rename", ...profilesRenameHelpHandler).post("/profiles/:profile/rename", ...profilesProfileRenameHelpHandler).post("/profiles/:profile/as-default", ...profilesAsDefaultHandler).get("/profiles/:profile/run", ...profilesLaunchHandler).get("/profiles/:profile", ...profilesLaunchHandler).get("/gateway", ...gatewayGroupHandler).get("/gateway/status", ...gatewayStatusHandler).get("/gateway/start", ...gatewayStartHandler).get("/gateway/stop", ...gatewayStopHandler).get("/gateway/restart", ...gatewayRestartHandler).get("/gateway/run", ...gatewayRunHandler).get("/gateway/logs", ...gatewayLogsHandler).get("/gateway/sql", ...gatewaySqlHandler).get("/gateway/listeners", ...gatewayListenersHandler).get("/debug", ...debugHandler).get("/debug/events", ...debugEventsHandler).get("/debug/dropped", ...debugDroppedHandler).get("/debug/errors", ...debugErrorsHandler).get("/debug/replay", ...debugReplayHandler).get("/schema", ...schemaHandler).get("/status", ...statusHandler).get("/update", ...updateHandler);
 //#endregion
-export { CONNECTOR_CONNECTION_STATUSES, ConnectorDiagnosticLog, ConnectorDiagnosticSqlReader, DEFAULT_GATEWAY_PORT, DEFAULT_GATEWAY_TOKEN_PATH, FUNNEL_DIR, FUNNEL_MCP_ARGS, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelEventLog, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLocalConfigWriter, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, MemoryConnectorDiagnosticLog, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, SETTINGS_PATH, SETTINGS_VERSION, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, routes as cliRoutes, connectorConfigSchema, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, connectorSpecSchema, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, localConfigSchema, profileConfigSchema, profileSpecSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, resolveFunnelDir, resolveFunnelPort, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };
+export { CONNECTOR_CONNECTION_STATUSES, ConnectorDiagnosticLog, ConnectorDiagnosticSqlReader, DEFAULT_GATEWAY_PORT, DEFAULT_GATEWAY_TOKEN_PATH, FUNNEL_DIR, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelEventLog, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLogger, FunnelProcessRunner, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, MemoryConnectorDiagnosticLog, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NoopFunnelLogger, SETTINGS_PATH, SETTINGS_VERSION, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, channelConfigSchema, channelDeliveryModeSchema, routes as cliRoutes, connectorConfigSchema, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, createSettings, discordConnectorSchema, factory, funnelEventSchema, ghConnectorSchema, profileConfigSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, resolveFunnelDir, resolveFunnelPort, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, toRequest };