@interactive-inc/claude-funnel 0.57.0 → 0.58.1

package/dist/{memory-diagnostic-log-BbFVqDzz.js → memory-diagnostic-log-5LzwJ_F7.js}

@@ -2,11 +2,11 @@ import { n as NodeFunnelProcessRunner } from "./gh-connector-schema-DUcZgN2Q.js"
 import { t as NodeFunnelFileSystem } from "./node-file-system-BcrmWN9I.js";
 import { r as FUNNEL_DIR, s as resolveFunnelPort, t as gatewayLoopbackUrl } from "./gateway-base-url-6foMXfFf.js";
 import { t as ConnectorDiagnosticSqlReader } from "./diagnostic-sql-reader-CzYgZpq2.js";
+import { t as FunnelLogSqliteSink } from "./funnel-log-sqlite-sink-B_5_4ybn.js";
 import { dirname, join } from "node:path";
 import { chmodSync, existsSync, mkdirSync } from "node:fs";
 import { z } from "zod";
 import { homedir, tmpdir } from "node:os";
-import { Database } from "bun:sqlite";
 import { timingSafeEqual } from "node:crypto";
 import { createFactory } from "hono/factory";
 import { HTTPException } from "hono/http-exception";
@@ -360,298 +360,6 @@ const funnelEventSchema = z.object({
 */
 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) {
-		if (props.path !== ":memory:") {
-			const dir = dirname(props.path);
-			if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
-		}
-		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/event-log/sqlite-event-log.ts
 const MAX_CONTENT_CHARS = 2e3;
 /**
@@ -679,7 +387,7 @@ var SqliteFunnelEventLog = class extends FunnelEventLog {
 		super();
 		this.now = props.now ?? (() => Date.now());
 		this.logger = props.logger;
-		this.sink = new LeucoLoggerSqliteSink({
+		this.sink = new FunnelLogSqliteSink({
 			path: props.path,
 			indexes: ["channel_id", "connector_id"],
 			extractIndexes: (event) => ({
@@ -722,7 +430,7 @@ var SqliteFunnelEventLog = class extends FunnelEventLog {
 	* so this returns the full slice and lets the caller filter.
 	*/
 	loadSince(since) {
-		const records = this.sink.getRecords({ sinceSeq: since });
+		const records = this.sink.query({ sinceSeq: since });
 		const out = [];
 		for (const record of records) out.push({
 			content: record.event.content,
@@ -739,7 +447,7 @@ var SqliteFunnelEventLog = class extends FunnelEventLog {
 	loadForChannel(props) {
 		const where = { channel_id: props.channelId };
 		if (props.connectorId !== void 0) where.connector_id = props.connectorId;
-		const records = this.sink.getRecords({
+		const records = this.sink.query({
 			where,
 			...props.sinceSeq !== void 0 ? { sinceSeq: props.sinceSeq } : {},
 			...props.limit !== void 0 ? { limit: props.limit } : {}
@@ -771,7 +479,8 @@ function truncate(content) {
 const defaultOnError$1 = () => {};
 const DEFAULT_HEALTH_INTERVAL_MS = 3e4;
 const DEFAULT_MAX_BACKOFF_MS = 6e4;
-const defaultSleep = (ms) => new Promise((r) => {
+const DEFAULT_START_TIMEOUT_MS = 3e4;
+const defaultSleep$1 = (ms) => new Promise((r) => {
 	setTimeout(r, ms);
 });
 /**
@@ -796,10 +505,13 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 	stats = /* @__PURE__ */ new Map();
 	healthCheckIntervalMs;
 	maxBackoffMs;
+	startTimeoutMs;
 	sleep;
 	now;
 	healthCheckTimer = null;
 	healthCheckInFlight = false;
+	/** Connectors that failed initial start — retried by the health check. */
+	pendingRetry = /* @__PURE__ */ new Map();
 	constructor(deps) {
 		this.channels = deps.channels;
 		this.notify = deps.notify;
@@ -807,7 +519,8 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 		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.startTimeoutMs = deps.startTimeoutMs ?? DEFAULT_START_TIMEOUT_MS;
+		this.sleep = deps.sleep ?? defaultSleep$1;
 		this.now = deps.now ?? (() => Date.now());
 	}
 	static keyOf(channelName, connectorName) {
@@ -853,13 +566,16 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 			}
 		};
 		try {
-			await created.listener.start(bind);
+			await Promise.race([created.listener.start(bind), this.sleep(this.startTimeoutMs).then(() => {
+				throw new Error(`listener start timed out after ${this.startTimeoutMs}ms`);
+			})]);
 			this.running.set(key, {
 				config: created.config,
 				channelName,
 				channelId: created.channelId,
 				listener: created.listener
 			});
+			this.pendingRetry.delete(key);
 			this.ensureStats(key);
 			this.logger?.info(`${created.config.type} listener started`, {
 				channel: channelName,
@@ -894,8 +610,6 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 		};
 		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
@@ -918,6 +632,9 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 				ok: false,
 				reason: err.message
 			};
+		} finally {
+			this.running.delete(key);
+			this.failureCounts.delete(key);
 		}
 	}
 	async restart(channelName, connectorName) {
@@ -927,11 +644,23 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 	}
 	async startAll() {
 		const all = this.channels.listAllConnectors();
-		for (const view of all) await this.start(view.channelName, view.name);
+		const results = await Promise.allSettled(all.map((view) => this.start(view.channelName, view.name)));
+		for (let i = 0; i < results.length; i++) {
+			const result = results[i];
+			const view = all[i];
+			if (result.status === "rejected" || result.status === "fulfilled" && !result.value.ok) {
+				const key = FunnelListenerSupervisor.keyOf(view.channelName, view.name);
+				this.pendingRetry.set(key, {
+					channelName: view.channelName,
+					connectorName: view.name
+				});
+			}
+		}
 		this.startHealthCheck();
 	}
 	async stopAll() {
 		this.stopHealthCheck();
+		this.pendingRetry.clear();
 		for (const [, entry] of [...this.running.entries()]) await this.stop(entry.channelName, entry.config.name);
 	}
 	ensureStats(key) {
@@ -966,6 +695,10 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 		clearInterval(this.healthCheckTimer);
 		this.healthCheckTimer = null;
 	}
+	/** Run one health-check pass synchronously. Test-only seam. */
+	async runHealthCheckForTest() {
+		await this.runHealthCheck();
+	}
 	async runHealthCheck() {
 		if (this.healthCheckInFlight) return;
 		this.healthCheckInFlight = true;
@@ -977,6 +710,23 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 				}
 				await this.recoverDead(entry.channelName, entry.config.name, entry.config.type);
 			}
+			for (const [key, pending] of [...this.pendingRetry.entries()]) {
+				if (this.running.has(key)) {
+					this.pendingRetry.delete(key);
+					continue;
+				}
+				this.logger?.info("retrying failed listener", {
+					channel: pending.channelName,
+					connector: pending.connectorName
+				});
+				const failureCount = this.failureCounts.get(key) ?? 0;
+				const backoffMs = Math.min(1e3 * 2 ** failureCount, this.maxBackoffMs);
+				await this.sleep(backoffMs);
+				if ((await this.start(pending.channelName, pending.connectorName)).ok) {
+					this.pendingRetry.delete(key);
+					this.failureCounts.delete(key);
+				} else this.failureCounts.set(key, failureCount + 1);
+			}
 		} finally {
 			this.healthCheckInFlight = false;
 		}
@@ -1005,7 +755,27 @@ var FunnelListenerSupervisor = class FunnelListenerSupervisor {
 //#endregion
 //#region lib/gateway/kill-competing-slack-gateways.ts
 const defaultProcess = new NodeFunnelProcessRunner();
+const SIGTERM_GRACE_MS = 3e3;
+const POLL_INTERVAL_MS = 100;
+const SIGKILL_GRACE_MS = 200;
+const defaultSleep = (ms) => new Promise((resolve) => {
+	setTimeout(resolve, ms);
+});
 const titleFor = (dir) => `funnel-gateway[${dir}]`;
+const waitForExit = async (props) => {
+	const deadline = props.now() + SIGTERM_GRACE_MS;
+	while (props.now() < deadline) {
+		if (props.pids.every((pid) => !props.runner.isAlive(pid))) return;
+		await props.sleep(POLL_INTERVAL_MS);
+	}
+	for (const pid of props.pids) {
+		if (!props.runner.isAlive(pid)) continue;
+		try {
+			props.runner.kill(pid, "SIGKILL");
+		} catch {}
+	}
+	await props.sleep(SIGKILL_GRACE_MS);
+};
 /**
 * Kills other funnel daemon processes that share the SAME funnel home dir,
 * which is the only situation that causes a real conflict (duplicate Slack
@@ -1015,6 +785,10 @@ const titleFor = (dir) => `funnel-gateway[${dir}]`;
 * `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.
+*
+* Waits for the killed daemons to actually exit before returning, so the caller
+* can bind the port and open a fresh Socket Mode connection without overlapping
+* the old one (the overlap is what makes Slack split inbound events).
 */
 const killCompetingSlackGateways = async (props) => {
 	const runner = props.process ?? defaultProcess;
@@ -1031,6 +805,13 @@ const killCompetingSlackGateways = async (props) => {
 			args: snapshot.command.slice(0, 160)
 		});
 	}
+	if (killed.length === 0) return killed;
+	await waitForExit({
+		runner,
+		pids: killed,
+		sleep: props.sleep ?? defaultSleep,
+		now: props.now ?? (() => Date.now())
+	});
 	return killed;
 };
 //#endregion
@@ -1290,6 +1071,7 @@ const healthHandler = factory.createHandlers((c) => {
 	return c.json({
 		ok: true,
 		pid: deps.selfPid,
+		funnelDir: deps.dir,
 		clients: deps.broadcaster.getClientCount(),
 		listeners: deps.supervisor.list()
 	});
@@ -1341,6 +1123,7 @@ const statusHandler = factory.createHandlers((c) => {
 	return c.json({
 		ok: true,
 		pid: deps.selfPid,
+		funnelDir: deps.dir,
 		uptimeMs: deps.uptimeMs(),
 		clients: deps.broadcaster.listChannels(),
 		listeners: deps.supervisor.list(),
@@ -1450,6 +1233,7 @@ var FunnelGatewayServer = class {
 		if (this.server) return this.server;
 		if (!this.token && !LOOPBACK_HOSTS.has(this.hostname) && !this.allowInsecureHost) throw new Error(`refusing to start gateway: hostname "${this.hostname}" is reachable off-box but no token is set. Set a token, bind to loopback (127.0.0.1), or pass allowInsecureHost: true.`);
 		const app = this.buildApp();
+		await this.killCompetingSlackIfNeeded();
 		this.startedAt = this.nowMs();
 		this.server = Bun.serve({
 			port: this.port,
@@ -1504,6 +1288,7 @@ var FunnelGatewayServer = class {
 			if (this.token && !this.tokenMatchesUpgrade(request)) return new Response("unauthorized", { status: 401 });
 			const requestedChannel = url.searchParams.get("channel") ?? "";
 			const channel = requestedChannel ? this.resolveChannel(requestedChannel) : null;
+			if (requestedChannel && !channel) return new Response(`unknown channel "${requestedChannel}"`, { status: 404 });
 			const channelId = channel?.id ?? requestedChannel;
 			const channelName = channel?.name ?? null;
 			const connectors = channel?.connectors ?? [];
@@ -1567,6 +1352,7 @@ var FunnelGatewayServer = class {
 		base.use((c, next) => {
 			c.set("deps", {
 				selfPid: this.selfPid,
+				dir: this.dir,
 				broadcaster: this.broadcaster,
 				supervisor: this.supervisor,
 				channels: this.channels,
@@ -1606,21 +1392,22 @@ var FunnelGatewayServer = class {
 			delivery: channel.delivery
 		};
 	}
+	async killCompetingSlackIfNeeded() {
+		if (!this.killCompetingSlack) return;
+		if (!this.channels.listAllConnectors().some((c) => c.type === "slack")) return;
+		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(",")
+		});
+	}
 	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",
@@ -1885,7 +1672,7 @@ var ConnectorDiagnosticLog = class {};
 */
 const RAW_PAYLOAD_CAP = 256 * 1024;
 /**
-* Default `ConnectorDiagnosticLog`: three independent `LeucoLoggerSqliteSink`s, one
+* Default `ConnectorDiagnosticLog`: three independent `FunnelLogSqliteSink`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
@@ -1920,7 +1707,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 			...ageCap,
 			...rawMax !== void 0 ? { maxRows: rawMax } : {}
 		};
-		this.raw = new LeucoLoggerSqliteSink({
+		this.raw = new FunnelLogSqliteSink({
 			path: props.rawPath,
 			indexes: [
 				"event_id",
@@ -1934,7 +1721,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 			}),
 			...rawCap
 		});
-		this.processed = new LeucoLoggerSqliteSink({
+		this.processed = new FunnelLogSqliteSink({
 			path: props.processedPath,
 			indexes: [
 				"event_id",
@@ -1950,7 +1737,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 			}),
 			...verdictCap
 		});
-		this.connection = new LeucoLoggerSqliteSink({
+		this.connection = new FunnelLogSqliteSink({
 			path: props.connectionPath,
 			indexes: [
 				"connector_id",
@@ -2016,7 +1803,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 		});
 	}
 	queryRaw(query) {
-		return this.raw.getRecords({
+		return this.raw.query({
 			...query.type !== void 0 ? { type: query.type } : {},
 			...query.limit !== void 0 ? { limit: query.limit } : {},
 			where: buildWhere(query),
@@ -2034,7 +1821,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 	queryProcessed(query) {
 		const where = buildWhere(query);
 		if (query.outcome !== void 0) where.outcome = query.outcome;
-		return this.processed.getRecords({
+		return this.processed.query({
 			...query.type !== void 0 ? { type: query.type } : {},
 			...query.limit !== void 0 ? { limit: query.limit } : {},
 			where,
@@ -2053,7 +1840,7 @@ var SqliteConnectorDiagnosticLog = class extends ConnectorDiagnosticLog {
 	queryConnection(query) {
 		const where = buildWhere(query);
 		if (query.status !== void 0) where.status = query.status;
-		return this.connection.getRecords({
+		return this.connection.query({
 			...query.type !== void 0 ? { type: query.type } : {},
 			...query.limit !== void 0 ? { limit: query.limit } : {},
 			where,

package/dist/{memory-token-prompter-DpCC1_Dn.d.ts → memory-token-prompter-BlFwK9k7.d.ts}

@@ -1,5 +1,5 @@
-import { n as FunnelFileSystem } from "./file-system-Wub9Nto4.js";
-import { i as FunnelTokenPrompter } from "./local-config-sync-E_t5_fjw.js";
+import { n as FunnelFileSystem } from "./file-system-DxpnnUVb.js";
+import { i as FunnelTokenPrompter } from "./local-config-sync--f739oCJ.js";
 
 //#region lib/services/local-config/local-config-json-schema.d.ts
 /**

package/dist/{profiles-EHTeCOqB.d.ts → profiles-g2qGVOWv.d.ts}

@@ -1,6 +1,6 @@
-import { r as ProfileConfig } from "./settings-schema-zhnMIa8I.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-CBrgz01o.js";
-import { n as FunnelFileSystem } from "./file-system-Wub9Nto4.js";
+import { r as ProfileConfig } from "./settings-schema-1hh11jnN.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-DPwqOVUm.js";
+import { n as FunnelFileSystem } from "./file-system-DxpnnUVb.js";
 
 //#region lib/engine/profiles/profiles.d.ts
 type Deps = {

package/dist/profiles.d.ts

@@ -1,2 +1,2 @@
-import { t as FunnelProfiles } from "./profiles-EHTeCOqB.js";
+import { t as FunnelProfiles } from "./profiles-g2qGVOWv.js";
 export { FunnelProfiles };

package/dist/recovery.d.ts

@@ -1,2 +1,2 @@
-import { a as RecoveryListenerControl, i as RecoveryGatewayControl, n as RecoveryAction, o as RecoveryResult, r as RecoveryChannelSource, t as FunnelRecovery } from "./funnel-recovery-BUBsu7WX.js";
+import { a as RecoveryListenerControl, i as RecoveryGatewayControl, n as RecoveryAction, o as RecoveryResult, r as RecoveryChannelSource, t as FunnelRecovery } from "./funnel-recovery-COExL9MD.js";
 export { FunnelRecovery, RecoveryAction, RecoveryChannelSource, RecoveryGatewayControl, RecoveryListenerControl, RecoveryResult };

package/dist/{schedule-listener-DKh0hnkK.d.ts → schedule-listener-DoMPjHZj.d.ts}

@@ -1,5 +1,5 @@
-import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "./diagnostic-log-Bxe7Bbvw.js";
-import { n as FunnelFileSystem } from "./file-system-Wub9Nto4.js";
+import { S as FunnelLogger, b as FunnelConnectorListener, o as ConnectorDiagnosticLog, x as NotifyFn } from "./diagnostic-log-Cb3v8P7p.js";
+import { n as FunnelFileSystem } from "./file-system-DxpnnUVb.js";
 import { z } from "zod";
 
 //#region lib/engine/connectors/schedule-state-store.d.ts