@interactive-inc/claude-funnel 0.7.1 → 0.8.1

package/dist/index.js

@@ -0,0 +1,3575 @@
+// @bun
+// lib/funnel.ts
+import { join as join9 } from "path";
+
+// lib/connectors/connector-adapter.ts
+class FunnelConnectorAdapter {
+}
+
+// lib/engine/http/http-client.ts
+class FunnelHttpClient {
+}
+
+// lib/engine/http/node-http-client.ts
+class NodeFunnelHttpClient extends FunnelHttpClient {
+  constructor() {
+    super();
+    Object.freeze(this);
+  }
+  async fetch(request) {
+    const res = await globalThis.fetch(request.url, {
+      method: request.method,
+      headers: request.headers,
+      body: request.body
+    });
+    return {
+      status: res.status,
+      ok: res.ok,
+      text: () => res.text(),
+      json: () => res.json()
+    };
+  }
+}
+
+// lib/connectors/discord-adapter.ts
+var DISCORD_API_BASE = "https://discord.com/api/v10";
+var defaultHttp = new NodeFunnelHttpClient;
+
+class FunnelDiscordAdapter extends FunnelConnectorAdapter {
+  token;
+  http;
+  constructor(deps) {
+    super();
+    this.token = deps.config.botToken;
+    this.http = deps.http ?? defaultHttp;
+    Object.freeze(this);
+  }
+  async call(input) {
+    const method = (input.method || "GET").toUpperCase();
+    const path = input.path.startsWith("/") ? input.path : `/${input.path}`;
+    const body = input.body;
+    const hasBody = body !== null && typeof body === "object" && method !== "GET" && Object.keys(body).length > 0;
+    const res = await this.http.fetch({
+      method,
+      url: `${DISCORD_API_BASE}${path}`,
+      headers: {
+        Authorization: `Bot ${this.token}`,
+        "Content-Type": "application/json"
+      },
+      body: hasBody ? JSON.stringify(input.body) : undefined
+    });
+    if (!res.ok) {
+      throw new Error(`Discord API failed (${res.status}): ${await res.text()}`);
+    }
+    if (res.status === 204)
+      return null;
+    return await res.json();
+  }
+}
+
+// lib/connectors/discord-listener.ts
+import { Client, GatewayIntentBits, Partials } from "discord.js";
+
+// lib/connectors/connector-listener.ts
+class FunnelConnectorListener {
+  isAlive() {
+    return true;
+  }
+}
+
+// lib/connectors/discord-event-processor.ts
+class FunnelDiscordEventProcessor {
+  ownUserId;
+  constructor(props) {
+    this.ownUserId = props.ownUserId;
+  }
+  process(message) {
+    if (message.authorIsBot)
+      return { skip: true };
+    const mentioned = this.ownUserId ? message.mentionedUserIds.includes(this.ownUserId) : false;
+    return {
+      skip: false,
+      content: JSON.stringify(message.raw),
+      meta: {
+        event_type: "discord",
+        channel_id: message.channelId,
+        user_id: message.authorId,
+        mentioned: String(mentioned),
+        guild_id: message.guildId ?? ""
+      }
+    };
+  }
+}
+
+// lib/engine/logger/node-logger.ts
+import { appendFileSync, mkdirSync } from "fs";
+import { dirname, join } from "path";
+
+// lib/engine/logger/logger.ts
+class FunnelLogger {
+}
+
+// lib/engine/logger/node-logger.ts
+var DEFAULT_LOG_FILE = join("/tmp/funnel", "funnel.log");
+
+class NodeFunnelLogger extends FunnelLogger {
+  file;
+  now;
+  constructor(props = {}) {
+    super();
+    this.file = props.file ?? DEFAULT_LOG_FILE;
+    this.now = props.now ?? (() => new Date);
+    Object.freeze(this);
+  }
+  info(message, meta) {
+    this.write("info", message, meta);
+  }
+  warn(message, meta) {
+    this.write("warn", message, meta);
+  }
+  error(message, meta) {
+    this.write("error", message, meta);
+  }
+  write(level, message, meta) {
+    mkdirSync(dirname(this.file), { recursive: true });
+    const entry = {
+      time: this.now().toISOString(),
+      level,
+      message,
+      ...meta ? { meta } : {}
+    };
+    appendFileSync(this.file, `${JSON.stringify(entry)}
+`);
+  }
+}
+
+// lib/connectors/discord-listener.ts
+var defaultLogger = new NodeFunnelLogger;
+
+class FunnelDiscordListener extends FunnelConnectorListener {
+  config;
+  logger;
+  client = null;
+  constructor(deps) {
+    super();
+    this.config = deps.config;
+    this.logger = deps.logger ?? defaultLogger;
+  }
+  async start(notify) {
+    const client = new Client({
+      intents: [
+        GatewayIntentBits.Guilds,
+        GatewayIntentBits.GuildMessages,
+        GatewayIntentBits.MessageContent,
+        GatewayIntentBits.DirectMessages
+      ],
+      partials: [Partials.Channel]
+    });
+    client.on("messageCreate", async (message) => {
+      const ownUserId = client.user?.id ?? "";
+      const mentionedUserIds = [...message.mentions.users.keys()];
+      this.logger.info("discord messageCreate", {
+        author: message.author.id,
+        authorIsBot: String(message.author.bot),
+        channelId: message.channelId,
+        guildId: message.guildId ?? "",
+        mentions: mentionedUserIds.join(","),
+        ownUserId,
+        mentioned: String(mentionedUserIds.includes(ownUserId))
+      });
+      const processor = new FunnelDiscordEventProcessor({ ownUserId });
+      const result = processor.process({
+        authorId: message.author.id,
+        authorIsBot: message.author.bot,
+        channelId: message.channelId,
+        guildId: message.guildId,
+        mentionedUserIds,
+        raw: message.toJSON()
+      });
+      if (result.skip) {
+        this.logger.info("discord skip", { reason: "bot author" });
+        return;
+      }
+      try {
+        await notify(result.content, result.meta);
+      } catch (error) {
+        this.logger.error("discord notify error", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    });
+    client.on("ready", (readyClient) => {
+      this.logger.info("discord ready", {
+        userId: readyClient.user.id,
+        tag: readyClient.user.tag,
+        guilds: String(readyClient.guilds.cache.size)
+      });
+    });
+    client.on("error", (error) => {
+      this.logger.error("discord client error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+    await client.login(this.config.botToken);
+    this.client = client;
+  }
+  async stop() {
+    if (!this.client)
+      return;
+    try {
+      await this.client.destroy();
+    } catch (error) {
+      this.logger.error("discord stop error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.client = null;
+    }
+  }
+  isAlive() {
+    return this.client !== null;
+  }
+}
+
+// lib/engine/process/process-runner.ts
+class FunnelProcessRunner {
+}
+
+// lib/engine/process/node-process-runner.ts
+var toEnv = (env) => {
+  if (!env)
+    return;
+  const merged = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (typeof value === "string")
+      merged[key] = value;
+  }
+  for (const [key, value] of Object.entries(env)) {
+    merged[key] = value;
+  }
+  return merged;
+};
+
+class NodeFunnelProcessRunner extends FunnelProcessRunner {
+  constructor() {
+    super();
+    Object.freeze(this);
+  }
+  runSync(command) {
+    const result = Bun.spawnSync(command, {
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    return {
+      exitCode: result.exitCode ?? 0,
+      stdout: result.stdout.toString(),
+      stderr: result.stderr.toString()
+    };
+  }
+  async run(command, options = {}) {
+    const proc = Bun.spawn(command, {
+      cwd: options.cwd,
+      env: toEnv(options.env),
+      stdin: options.input !== undefined ? "pipe" : "ignore",
+      stdout: "pipe",
+      stderr: "pipe"
+    });
+    if (options.input !== undefined && proc.stdin) {
+      proc.stdin.write(options.input);
+      proc.stdin.end();
+    }
+    const exitCode = await proc.exited;
+    const stdout = await new Response(proc.stdout).text();
+    const stderr = await new Response(proc.stderr).text();
+    return { exitCode, stdout, stderr };
+  }
+  async attach(command, options = {}) {
+    const proc = Bun.spawn(command, {
+      cwd: options.cwd,
+      env: toEnv(options.env),
+      stdio: ["inherit", "inherit", "inherit"]
+    });
+    return await proc.exited;
+  }
+  detach(command, options = {}) {
+    const proc = Bun.spawn(command, {
+      env: toEnv(options.env),
+      stdio: ["ignore", "ignore", "ignore"]
+    });
+    proc.unref();
+  }
+  kill(pid, signal = "SIGTERM") {
+    try {
+      process.kill(pid, signal);
+    } catch {}
+  }
+}
+
+// lib/connectors/gh-adapter.ts
+var defaultProcess = new NodeFunnelProcessRunner;
+
+class FunnelGhAdapter extends FunnelConnectorAdapter {
+  process;
+  constructor(deps = {}) {
+    super();
+    this.process = deps.process ?? defaultProcess;
+    Object.freeze(this);
+  }
+  async call(input) {
+    const args = ["api", input.path];
+    if (input.method && input.method.toLowerCase() !== "get") {
+      args.push("-X", input.method.toUpperCase());
+    }
+    const hasBody = input.body && typeof input.body === "object" && Object.keys(input.body).length > 0;
+    if (hasBody) {
+      args.push("--input", "-");
+    }
+    const result = await this.process.run(["gh", ...args], {
+      input: hasBody ? JSON.stringify(input.body) : undefined
+    });
+    if (result.exitCode !== 0) {
+      throw new Error(`gh api failed: ${result.stderr.trim() || result.stdout.trim()}`);
+    }
+    try {
+      return JSON.parse(result.stdout);
+    } catch {
+      return result.stdout;
+    }
+  }
+}
+
+// lib/connectors/gh-listener.ts
+import { z } from "zod";
+var ghNotificationSchema = z.object({
+  id: z.string(),
+  reason: z.string(),
+  subject: z.object({
+    type: z.string(),
+    url: z.string(),
+    title: z.string()
+  }),
+  repository: z.object({ full_name: z.string() }),
+  updated_at: z.string()
+});
+var ghNotificationsSchema = z.array(ghNotificationSchema);
+var defaultProcess2 = new NodeFunnelProcessRunner;
+var defaultLogger2 = new NodeFunnelLogger;
+var MAX_SEEN = 1e4;
+var KEEP_SEEN = 5000;
+
+class FunnelGhListener extends FunnelConnectorListener {
+  config;
+  process;
+  logger;
+  now;
+  seen = new Map;
+  bootstrapped = false;
+  since;
+  timer = null;
+  constructor(deps) {
+    super();
+    this.config = deps.config;
+    this.process = deps.process ?? defaultProcess2;
+    this.logger = deps.logger ?? defaultLogger2;
+    this.now = deps.now ?? (() => new Date);
+    this.since = this.now().toISOString();
+  }
+  async start(notify) {
+    await this.pollOnce(notify);
+    const interval = this.config.pollInterval ?? 60;
+    this.timer = setInterval(() => void this.pollOnce(notify), interval * 1000);
+    this.timer.unref();
+  }
+  async stop() {
+    if (!this.timer)
+      return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+  isAlive() {
+    return this.timer !== null;
+  }
+  async pollOnce(notify) {
+    const nextSince = this.now().toISOString();
+    const params = new URLSearchParams({ since: this.since, all: "false" });
+    try {
+      const result = await this.process.run(["gh", "api", `/notifications?${params}`]);
+      if (result.exitCode !== 0) {
+        this.logger.error("gh poll failed", { stderr: result.stderr });
+        return;
+      }
+      const parsed = ghNotificationsSchema.safeParse(JSON.parse(result.stdout));
+      if (!parsed.success) {
+        this.logger.warn("gh response did not match schema", { error: parsed.error.message });
+        return;
+      }
+      const items = parsed.data;
+      for (const item of items) {
+        if (this.seen.get(item.id) === item.updated_at)
+          continue;
+        this.seen.set(item.id, item.updated_at);
+        if (!this.bootstrapped)
+          continue;
+        const meta = {
+          event_type: "gh",
+          reason: item.reason,
+          subject_type: item.subject.type,
+          subject_url: item.subject.url,
+          repository: item.repository.full_name,
+          thread_id: item.id,
+          updated_at: item.updated_at
+        };
+        await notify(JSON.stringify(item), meta);
+      }
+      if (this.seen.size > MAX_SEEN) {
+        const toDrop = this.seen.size - KEEP_SEEN;
+        let dropped = 0;
+        for (const key of this.seen.keys()) {
+          if (dropped >= toDrop)
+            break;
+          this.seen.delete(key);
+          dropped++;
+        }
+      }
+      this.since = nextSince;
+      this.bootstrapped = true;
+    } catch (error) {
+      this.logger.error("gh poll error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+}
+
+// lib/connectors/match-cron.ts
+var parseField = (expr, min, max) => {
+  const values = new Set;
+  for (const part of expr.split(",")) {
+    const [rangePart, stepPart] = part.split("/");
+    const step = stepPart ? Number(stepPart) : 1;
+    if (!Number.isFinite(step) || step <= 0) {
+      throw new Error(`invalid cron step: "${stepPart}"`);
+    }
+    let lo = min;
+    let hi = max;
+    if (rangePart === "*" || rangePart === undefined || rangePart === "") {
+      lo = min;
+      hi = max;
+    } else if (rangePart.includes("-")) {
+      const [aStr, bStr] = rangePart.split("-");
+      const a = Number(aStr);
+      const b = Number(bStr);
+      if (!Number.isFinite(a) || !Number.isFinite(b)) {
+        throw new Error(`invalid cron range: "${rangePart}"`);
+      }
+      lo = a;
+      hi = b;
+    } else {
+      const n = Number(rangePart);
+      if (!Number.isFinite(n))
+        throw new Error(`invalid cron value: "${rangePart}"`);
+      lo = n;
+      hi = stepPart ? max : n;
+    }
+    if (lo < min || hi > max || lo > hi) {
+      throw new Error(`cron value out of range: ${rangePart} (must be ${min}-${max})`);
+    }
+    for (let i = lo;i <= hi; i += step) {
+      values.add(i);
+    }
+  }
+  return { min, max, values };
+};
+var matchCron = (expr, date) => {
+  const parts = expr.trim().split(/\s+/);
+  if (parts.length !== 5) {
+    throw new Error(`cron must have 5 fields (got ${parts.length}): "${expr}"`);
+  }
+  const [minute, hour, dom, month, dow] = parts;
+  if (!minute || !hour || !dom || !month || !dow) {
+    throw new Error(`cron has empty fields: "${expr}"`);
+  }
+  const fields = [
+    { field: parseField(minute, 0, 59), value: date.getMinutes() },
+    { field: parseField(hour, 0, 23), value: date.getHours() },
+    { field: parseField(dom, 1, 31), value: date.getDate() },
+    { field: parseField(month, 1, 12), value: date.getMonth() + 1 },
+    { field: parseField(dow, 0, 6), value: date.getDay() }
+  ];
+  for (const { field, value } of fields) {
+    if (!field.values.has(value))
+      return false;
+  }
+  return true;
+};
+
+// lib/connectors/schedule-listener.ts
+var defaultLogger3 = new NodeFunnelLogger;
+var MAX_CATCHUP_MINUTES = 60 * 24;
+
+class FunnelScheduleListener extends FunnelConnectorListener {
+  config;
+  lastFiredStore;
+  logger;
+  now;
+  timer = null;
+  stopped = false;
+  constructor(deps) {
+    super();
+    this.config = deps.config;
+    this.lastFiredStore = deps.lastFiredStore;
+    this.logger = deps.logger ?? defaultLogger3;
+    this.now = deps.now ?? (() => new Date);
+  }
+  async start(notify) {
+    this.stopped = false;
+    const scheduleNext = () => {
+      if (this.stopped)
+        return;
+      const date = this.now();
+      const msUntilNextMinute = 60000 - (date.getSeconds() * 1000 + date.getMilliseconds());
+      this.timer = setTimeout(async () => {
+        if (this.stopped)
+          return;
+        await this.tick(notify);
+        scheduleNext();
+      }, msUntilNextMinute);
+      this.timer.unref();
+    };
+    await this.tick(notify);
+    scheduleNext();
+  }
+  async stop() {
+    this.stopped = true;
+    if (this.timer) {
+      clearTimeout(this.timer);
+      this.timer = null;
+    }
+  }
+  isAlive() {
+    return !this.stopped && this.timer !== null;
+  }
+  async tick(notify) {
+    const now = this.truncateToMinute(this.now());
+    const state = this.lastFiredStore.load();
+    let changed = false;
+    for (const entry of this.config.entries) {
+      if (!entry.enabled)
+        continue;
+      const fired = await this.fireEntry(entry, now, state, notify);
+      if (fired)
+        changed = true;
+    }
+    if (changed)
+      this.lastFiredStore.save(state);
+  }
+  async fireEntry(entry, now, state, notify) {
+    const lastFired = state.get(entry.id);
+    const searchFrom = lastFired ? new Date(lastFired.getTime() + 60000) : now;
+    if (searchFrom.getTime() > now.getTime())
+      return false;
+    if (entry.catchupPolicy === "skip") {
+      try {
+        if (!matchCron(entry.cron, now))
+          return false;
+      } catch (error) {
+        this.logInvalidCron(entry, error);
+        return false;
+      }
+      await this.notifyOne(entry, now, notify, false);
+      state.set(entry.id, now);
+      return true;
+    }
+    if (entry.catchupPolicy === "all") {
+      const matches = this.findAllMatches(entry.cron, searchFrom, now, entry.id);
+      if (matches.length === 0)
+        return false;
+      for (const match2 of matches) {
+        await this.notifyOne(entry, match2, notify, match2.getTime() !== now.getTime());
+      }
+      state.set(entry.id, matches[matches.length - 1] ?? now);
+      return true;
+    }
+    const match = this.findMostRecentMatch(entry.cron, searchFrom, now, entry.id);
+    if (!match)
+      return false;
+    await this.notifyOne(entry, match, notify, match.getTime() !== now.getTime());
+    state.set(entry.id, match);
+    return true;
+  }
+  async notifyOne(entry, firedAt, notify, catchup) {
+    const meta = {
+      event_type: "schedule",
+      schedule_id: entry.id,
+      cron: entry.cron,
+      fired_at: firedAt.toISOString(),
+      catchup_policy: entry.catchupPolicy
+    };
+    if (catchup)
+      meta.catchup = "true";
+    await notify(entry.prompt, meta);
+  }
+  findMostRecentMatch(cron, from, until, entryId) {
+    const maxIterations = Math.min(MAX_CATCHUP_MINUTES, Math.floor((until.getTime() - from.getTime()) / 60000) + 1);
+    for (let i = 0;i < maxIterations; i++) {
+      const candidate = new Date(until.getTime() - i * 60000);
+      try {
+        if (matchCron(cron, candidate))
+          return candidate;
+      } catch (error) {
+        this.logInvalidCron({ id: entryId, cron }, error);
+        return null;
+      }
+    }
+    return null;
+  }
+  findAllMatches(cron, from, until, entryId) {
+    const maxIterations = Math.min(MAX_CATCHUP_MINUTES, Math.floor((until.getTime() - from.getTime()) / 60000) + 1);
+    const matches = [];
+    for (let i = 0;i < maxIterations; i++) {
+      const candidate = new Date(from.getTime() + i * 60000);
+      if (candidate.getTime() > until.getTime())
+        break;
+      try {
+        if (matchCron(cron, candidate))
+          matches.push(candidate);
+      } catch (error) {
+        this.logInvalidCron({ id: entryId, cron }, error);
+        return [];
+      }
+    }
+    return matches;
+  }
+  logInvalidCron(entry, error) {
+    this.logger.error("invalid cron expression in schedule", {
+      connector: this.config.name,
+      id: entry.id,
+      cron: entry.cron,
+      error: error instanceof Error ? error.message : String(error)
+    });
+  }
+  truncateToMinute(date) {
+    const copy = new Date(date.getTime());
+    copy.setSeconds(0, 0);
+    return copy;
+  }
+}
+
+// lib/connectors/schedule-state-store.ts
+import { dirname as dirname2 } from "path";
+
+// lib/engine/fs/node-file-system.ts
+import {
+  appendFileSync as appendFileSync2,
+  chmodSync,
+  existsSync,
+  mkdirSync as mkdirSync2,
+  readdirSync,
+  readFileSync,
+  statSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+
+// lib/engine/fs/file-system.ts
+class FunnelFileSystem {
+}
+
+// lib/engine/fs/node-file-system.ts
+var SECRET_MODE = 384;
+
+class NodeFunnelFileSystem extends FunnelFileSystem {
+  constructor() {
+    super();
+    Object.freeze(this);
+  }
+  existsSync(path) {
+    return existsSync(path);
+  }
+  readFileSync(path) {
+    return readFileSync(path, "utf-8");
+  }
+  writeFileSync(path, data) {
+    writeFileSync(path, data);
+  }
+  writeSecretFileSync(path, data) {
+    writeFileSync(path, data, { mode: SECRET_MODE });
+    try {
+      chmodSync(path, SECRET_MODE);
+    } catch {}
+  }
+  appendFileSync(path, data) {
+    appendFileSync2(path, data);
+  }
+  unlink(path) {
+    try {
+      unlinkSync(path);
+    } catch {}
+  }
+  mkdirSync(path, options) {
+    mkdirSync2(path, { recursive: options?.recursive ?? false });
+  }
+  readdirSync(path) {
+    return readdirSync(path);
+  }
+  statSync(path) {
+    const stat = statSync(path);
+    return { mtimeMs: stat.mtimeMs, mode: stat.mode & 511 };
+  }
+}
+
+// lib/connectors/schedule-state-store.ts
+var defaultFs = new NodeFunnelFileSystem;
+
+class ScheduleStateStore {
+  path;
+  fs;
+  constructor(deps) {
+    this.path = deps.path;
+    this.fs = deps.fs ?? defaultFs;
+    Object.freeze(this);
+  }
+  load() {
+    const map = new Map;
+    if (!this.fs.existsSync(this.path))
+      return map;
+    const raw = JSON.parse(this.fs.readFileSync(this.path));
+    if (raw === null || typeof raw !== "object")
+      return map;
+    for (const [id, iso] of Object.entries(raw)) {
+      if (typeof iso === "string")
+        map.set(id, new Date(iso));
+    }
+    return map;
+  }
+  save(state) {
+    const obj = {};
+    for (const [id, date] of state) {
+      obj[id] = date.toISOString();
+    }
+    this.fs.mkdirSync(dirname2(this.path), { recursive: true });
+    this.fs.writeFileSync(this.path, `${JSON.stringify(obj, null, 2)}
+`);
+  }
+}
+
+// lib/connectors/slack-adapter.ts
+import { WebClient } from "@slack/web-api";
+var toRecord = (value) => {
+  const result = {};
+  for (const [key, val] of Object.entries(value))
+    result[key] = val;
+  return result;
+};
+
+class FunnelSlackAdapter extends FunnelConnectorAdapter {
+  client;
+  constructor(deps) {
+    super();
+    this.client = deps.client ?? new WebClient(deps.config.botToken);
+    Object.freeze(this);
+  }
+  async call(input) {
+    const body = input.body !== null && typeof input.body === "object" ? toRecord(input.body) : {};
+    return await this.client.apiCall(input.path, body);
+  }
+}
+
+// lib/connectors/slack-listener.ts
+import { App, LogLevel } from "@slack/bolt";
+import { z as z2 } from "zod";
+
+// lib/connectors/slack-event-processor.ts
+var ALLOWED_EVENTS = new Set(["message", "app_mention"]);
+var ALLOWED_SUBTYPES = new Set([
+  undefined,
+  "thread_broadcast",
+  "bot_message",
+  "file_share"
+]);
+var DEDUP_WINDOW = 1e4;
+var getString = (event, key) => {
+  const value = event[key];
+  return typeof value === "string" ? value : undefined;
+};
+
+class FunnelSlackEventProcessor {
+  ownBotUserId;
+  ownBotId;
+  now;
+  dedup = new Map;
+  constructor(props) {
+    this.ownBotUserId = props.ownBotUserId;
+    this.ownBotId = props.ownBotId;
+    this.now = props.now ?? (() => Date.now());
+  }
+  process(event) {
+    const eventType = getString(event, "type");
+    if (!eventType || !ALLOWED_EVENTS.has(eventType))
+      return { skip: true };
+    const subtype = getString(event, "subtype");
+    if (!ALLOWED_SUBTYPES.has(subtype))
+      return { skip: true };
+    const channelId = getString(event, "channel") ?? "";
+    const eventTs = getString(event, "event_ts") ?? getString(event, "ts") ?? "";
+    const dedupKey = `${channelId}:${eventTs}`;
+    const now = this.now();
+    if (this.dedup.has(dedupKey))
+      return { skip: true };
+    this.dedup.set(dedupKey, now);
+    for (const key of this.dedup.keys()) {
+      if ((this.dedup.get(key) ?? 0) < now - DEDUP_WINDOW)
+        this.dedup.delete(key);
+    }
+    const userId = getString(event, "user");
+    const botId = getString(event, "bot_id");
+    if (userId === this.ownBotUserId)
+      return { skip: true };
+    if (botId === this.ownBotId)
+      return { skip: true };
+    const text = getString(event, "text") ?? "";
+    const mentioned = text.includes(`<@${this.ownBotUserId}>`);
+    const threadTs = getString(event, "thread_ts") ?? getString(event, "ts") ?? "";
+    return {
+      skip: false,
+      content: JSON.stringify(event),
+      meta: {
+        event_type: "slack",
+        channel_id: channelId,
+        user_id: userId ?? "",
+        mentioned: String(mentioned),
+        thread_ts: threadTs
+      },
+      shouldReact: mentioned,
+      channel: channelId,
+      timestamp: getString(event, "ts") ?? ""
+    };
+  }
+}
+
+// lib/connectors/slack-listener.ts
+var middlewareArgsSchema = z2.object({
+  event: z2.record(z2.string(), z2.unknown()).optional()
+});
+var defaultLogger4 = new NodeFunnelLogger;
+
+class FunnelSlackListener extends FunnelConnectorListener {
+  config;
+  logger;
+  app = null;
+  constructor(deps) {
+    super();
+    this.config = deps.config;
+    this.logger = deps.logger ?? defaultLogger4;
+  }
+  async start(notify) {
+    const app = new App({
+      token: this.config.botToken,
+      appToken: this.config.appToken,
+      socketMode: true,
+      logLevel: LogLevel.ERROR
+    });
+    const authResult = await app.client.auth.test({ token: this.config.botToken });
+    const processor = new FunnelSlackEventProcessor({
+      ownBotUserId: authResult.user_id ?? "",
+      ownBotId: authResult.bot_id ?? ""
+    });
+    app.use(async (args) => {
+      const parsed = middlewareArgsSchema.safeParse(args);
+      if (!parsed.success || !parsed.data.event)
+        return;
+      const result = processor.process(parsed.data.event);
+      if (result.skip)
+        return;
+      if (result.shouldReact) {
+        try {
+          await app.client.reactions.add({
+            token: this.config.botToken,
+            channel: result.channel,
+            timestamp: result.timestamp,
+            name: "eyes"
+          });
+        } catch {}
+      }
+      await notify(result.content, result.meta);
+    });
+    app.error(async (error) => {
+      this.logger.error("Slack error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    });
+    await app.start();
+    this.app = app;
+  }
+  async stop() {
+    if (!this.app)
+      return;
+    try {
+      await this.app.stop();
+    } catch (error) {
+      this.logger.error("Slack stop error", {
+        error: error instanceof Error ? error.message : String(error)
+      });
+    } finally {
+      this.app = null;
+    }
+  }
+  isAlive() {
+    return this.app !== null;
+  }
+}
+
+// lib/engine/settings/settings-store.ts
+import { homedir } from "os";
+import { dirname as dirname3, join as join2 } from "path";
+
+// lib/engine/settings/settings-reader.ts
+class FunnelSettingsReader {
+}
+
+// lib/engine/settings/settings-schema.ts
+import { z as z8 } from "zod";
+
+// lib/connectors/connector-config-schema.ts
+import { z as z7 } from "zod";
+
+// lib/connectors/discord-connector-schema.ts
+import { z as z3 } from "zod";
+var discordConnectorSchema = z3.object({
+  id: z3.string(),
+  name: z3.string(),
+  type: z3.literal("discord"),
+  botToken: z3.string().min(10),
+  createdAt: z3.string().datetime().optional(),
+  updatedAt: z3.string().datetime().optional()
+});
+
+// lib/connectors/gh-connector-schema.ts
+import { z as z4 } from "zod";
+var ghConnectorSchema = z4.object({
+  id: z4.string(),
+  name: z4.string(),
+  type: z4.literal("gh"),
+  pollInterval: z4.number().int().positive().optional(),
+  createdAt: z4.string().datetime().optional(),
+  updatedAt: z4.string().datetime().optional()
+});
+
+// lib/connectors/schedule-connector-schema.ts
+import { z as z5 } from "zod";
+var scheduleCatchupPolicySchema = z5.enum(["latest", "all", "skip"]);
+var scheduleEntrySchema = z5.object({
+  id: z5.string(),
+  cron: z5.string(),
+  prompt: z5.string(),
+  enabled: z5.boolean().default(true),
+  catchupPolicy: scheduleCatchupPolicySchema.default("latest")
+});
+var scheduleConnectorSchema = z5.object({
+  id: z5.string(),
+  name: z5.string(),
+  type: z5.literal("schedule"),
+  entries: z5.array(scheduleEntrySchema).default([]),
+  createdAt: z5.string().datetime().optional(),
+  updatedAt: z5.string().datetime().optional()
+});
+
+// lib/connectors/slack-connector-schema.ts
+import { z as z6 } from "zod";
+var slackConnectorSchema = z6.object({
+  id: z6.string(),
+  name: z6.string(),
+  type: z6.literal("slack"),
+  botToken: z6.string().startsWith("xoxb-"),
+  appToken: z6.string().startsWith("xapp-"),
+  createdAt: z6.string().datetime().optional(),
+  updatedAt: z6.string().datetime().optional()
+});
+
+// lib/connectors/connector-config-schema.ts
+var connectorConfigSchema = z7.discriminatedUnion("type", [
+  slackConnectorSchema,
+  ghConnectorSchema,
+  discordConnectorSchema,
+  scheduleConnectorSchema
+]);
+
+// lib/engine/settings/settings-schema.ts
+var channelDeliveryModeSchema = z8.enum(["fanout", "exclusive"]);
+var channelConfigSchema = z8.object({
+  id: z8.string(),
+  name: z8.string(),
+  delivery: channelDeliveryModeSchema.default("fanout"),
+  connectors: z8.array(connectorConfigSchema).default([])
+});
+var profileConfigSchema = z8.object({
+  name: z8.string(),
+  path: z8.string(),
+  subAgent: z8.string(),
+  channelId: z8.string()
+});
+var SETTINGS_VERSION = 1;
+var settingsSchema = z8.object({
+  version: z8.literal(SETTINGS_VERSION).default(SETTINGS_VERSION),
+  channels: z8.array(channelConfigSchema).default([]),
+  profiles: z8.array(profileConfigSchema).default([])
+});
+
+// lib/engine/settings/settings-store.ts
+var FUNNEL_DIR = join2(homedir(), ".funnel");
+var SETTINGS_PATH = join2(FUNNEL_DIR, "settings.json");
+var defaultFs2 = new NodeFunnelFileSystem;
+
+class FunnelSettingsStore extends FunnelSettingsReader {
+  path;
+  fs;
+  constructor(deps = {}) {
+    super();
+    this.path = deps.path ?? SETTINGS_PATH;
+    this.fs = deps.fs ?? defaultFs2;
+    Object.freeze(this);
+  }
+  read() {
+    if (!this.fs.existsSync(this.path)) {
+      return {
+        version: SETTINGS_VERSION,
+        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:
+  mv ${this.path} ${this.path}.bak`);
+    }
+    if (parsed && typeof parsed === "object" && "version" in parsed && parsed.version !== SETTINGS_VERSION) {
+      throw new Error(`unsupported settings.json version (${this.path}): expected ${SETTINGS_VERSION}, got ${String(parsed.version)}`);
+    }
+    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(", ")}`);
+    }
+    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;
+  }
+  write(settings) {
+    this.fs.mkdirSync(dirname3(this.path), { recursive: true });
+    const versioned = { ...settings, version: SETTINGS_VERSION };
+    this.fs.writeFileSync(this.path, `${JSON.stringify(versioned, null, 2)}
+`);
+  }
+}
+
+// lib/connectors/connector-factory.ts
+import { join as join3 } from "path";
+var defaultFs3 = new NodeFunnelFileSystem;
+var defaultProcess3 = new NodeFunnelProcessRunner;
+var defaultLogger5 = new NodeFunnelLogger;
+
+class FunnelConnectorFactory {
+  fs;
+  process;
+  logger;
+  dir;
+  constructor(deps = {}) {
+    this.fs = deps.fs ?? defaultFs3;
+    this.process = deps.process ?? defaultProcess3;
+    this.logger = deps.logger ?? defaultLogger5;
+    this.dir = deps.dir ?? FUNNEL_DIR;
+    Object.freeze(this);
+  }
+  createListener(channelId, config) {
+    if (config.type === "slack") {
+      return new FunnelSlackListener({ config, logger: this.logger });
+    }
+    if (config.type === "gh") {
+      return new FunnelGhListener({ config, process: this.process, logger: this.logger });
+    }
+    if (config.type === "discord") {
+      return new FunnelDiscordListener({ config, logger: this.logger });
+    }
+    const lastFiredStore = new ScheduleStateStore({
+      path: join3(this.connectorDir(channelId, config.id), "state.json"),
+      fs: this.fs
+    });
+    return new FunnelScheduleListener({
+      config,
+      lastFiredStore,
+      logger: this.logger
+    });
+  }
+  createAdapter(config) {
+    if (config.type === "slack")
+      return new FunnelSlackAdapter({ config });
+    if (config.type === "gh")
+      return new FunnelGhAdapter({ process: this.process });
+    if (config.type === "discord")
+      return new FunnelDiscordAdapter({ config });
+    return null;
+  }
+  connectorDir(channelId, connectorId) {
+    return join3(this.dir, "channels", channelId, "connectors", connectorId);
+  }
+  channelDir(channelId) {
+    return join3(this.dir, "channels", channelId);
+  }
+}
+
+// lib/engine/time/clock.ts
+class FunnelClock {
+  millis() {
+    return this.now().getTime();
+  }
+  iso() {
+    return this.now().toISOString();
+  }
+}
+
+// lib/engine/time/node-clock.ts
+class NodeFunnelClock extends FunnelClock {
+  now() {
+    return new Date;
+  }
+}
+
+// lib/engine/id/id-generator.ts
+class FunnelIdGenerator {
+}
+
+// lib/engine/id/node-id-generator.ts
+class NodeFunnelIdGenerator extends FunnelIdGenerator {
+  generate() {
+    return crypto.randomUUID();
+  }
+}
+
+// lib/engine/channels/channels.ts
+var defaultClock = new NodeFunnelClock;
+var defaultIdGenerator = new NodeFunnelIdGenerator;
+
+class FunnelChannels {
+  store;
+  factory;
+  profileChecker;
+  clock;
+  idGenerator;
+  constructor(deps) {
+    this.store = deps.store;
+    this.factory = deps.factory;
+    this.profileChecker = deps.profileChecker;
+    this.clock = deps.clock ?? defaultClock;
+    this.idGenerator = deps.idGenerator ?? defaultIdGenerator;
+    Object.freeze(this);
+  }
+  list() {
+    return this.store.read().channels;
+  }
+  get(name) {
+    return this.list().find((c) => c.name === name) ?? null;
+  }
+  getById(id) {
+    return this.list().find((c) => c.id === id) ?? null;
+  }
+  add(input) {
+    const settings = this.store.read();
+    if (settings.channels.some((c) => c.name === input.name)) {
+      throw new Error(`channel "${input.name}" already exists`);
+    }
+    const channel = {
+      id: this.idGenerator.generate(),
+      name: input.name,
+      delivery: input.delivery ?? "fanout",
+      connectors: []
+    };
+    settings.channels.push(channel);
+    this.store.write(settings);
+    return channel;
+  }
+  setDelivery(name, delivery) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, name);
+    channel.delivery = delivery;
+    this.store.write(settings);
+  }
+  remove(name) {
+    const settings = this.store.read();
+    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`);
+    }
+    settings.channels.splice(index, 1);
+    this.store.write(settings);
+  }
+  rename(oldName, newName) {
+    const settings = this.store.read();
+    const channel = settings.channels.find((c) => c.name === oldName);
+    if (!channel)
+      throw new Error(`channel "${oldName}" not found`);
+    if (settings.channels.some((c) => c.name === newName)) {
+      throw new Error(`channel "${newName}" already exists`);
+    }
+    channel.name = newName;
+    this.store.write(settings);
+  }
+  listConnectors(channelName) {
+    return this.requireChannel(this.store.read(), channelName).connectors;
+  }
+  getConnector(channelName, connectorName) {
+    const channel = this.get(channelName);
+    if (!channel)
+      return null;
+    return channel.connectors.find((c) => c.name === connectorName) ?? null;
+  }
+  listAllConnectors() {
+    const out = [];
+    for (const channel of this.list()) {
+      for (const connector of channel.connectors) {
+        out.push({ ...connector, channelId: channel.id, channelName: channel.name });
+      }
+    }
+    return out;
+  }
+  addConnector(channelName, input) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, channelName);
+    if (channel.connectors.some((c) => c.name === input.name)) {
+      throw new Error(`connector "${input.name}" already exists in channel "${channelName}"`);
+    }
+    const candidate = this.fromInput(input);
+    this.assertNoTokenCollision(settings, candidate);
+    channel.connectors.push(candidate);
+    this.store.write(settings);
+    return candidate;
+  }
+  fromInput(input) {
+    const id = this.idGenerator.generate();
+    const now = this.clock.iso();
+    const createdAt = now;
+    const updatedAt = now;
+    if (input.type === "slack") {
+      return {
+        id,
+        type: "slack",
+        name: input.name,
+        botToken: input.botToken,
+        appToken: input.appToken,
+        createdAt,
+        updatedAt
+      };
+    }
+    if (input.type === "gh") {
+      return {
+        id,
+        type: "gh",
+        name: input.name,
+        ...input.pollInterval !== undefined ? { pollInterval: input.pollInterval } : {},
+        createdAt,
+        updatedAt
+      };
+    }
+    if (input.type === "discord") {
+      return {
+        id,
+        type: "discord",
+        name: input.name,
+        botToken: input.botToken,
+        createdAt,
+        updatedAt
+      };
+    }
+    return {
+      id,
+      type: "schedule",
+      name: input.name,
+      entries: input.entries ?? [],
+      createdAt,
+      updatedAt
+    };
+  }
+  removeConnector(channelName, connectorName) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, channelName);
+    const index = channel.connectors.findIndex((c) => c.name === connectorName);
+    if (index < 0) {
+      throw new Error(`connector "${connectorName}" not found in channel "${channelName}"`);
+    }
+    channel.connectors.splice(index, 1);
+    this.store.write(settings);
+  }
+  renameConnector(channelName, oldName, newName) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, channelName);
+    const connector = channel.connectors.find((c) => c.name === oldName);
+    if (!connector) {
+      throw new Error(`connector "${oldName}" not found in channel "${channelName}"`);
+    }
+    if (channel.connectors.some((c) => c.name === newName)) {
+      throw new Error(`connector "${newName}" already exists in channel "${channelName}"`);
+    }
+    connector.name = newName;
+    connector.updatedAt = this.clock.iso();
+    this.store.write(settings);
+  }
+  updateSlackConnector(channelName, connectorName, fields) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, channelName);
+    const connector = this.requireSlackConnector(channel, connectorName);
+    const updated = {
+      ...connector,
+      botToken: fields.botToken ?? connector.botToken,
+      appToken: fields.appToken ?? connector.appToken,
+      updatedAt: this.clock.iso()
+    };
+    this.assertNoTokenCollision(settings, updated);
+    Object.assign(connector, updated);
+    this.store.write(settings);
+  }
+  updateGhConnector(channelName, connectorName, fields) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, channelName);
+    const connector = this.requireGhConnector(channel, connectorName);
+    if (fields.pollInterval !== undefined)
+      connector.pollInterval = fields.pollInterval;
+    connector.updatedAt = this.clock.iso();
+    this.store.write(settings);
+  }
+  updateDiscordConnector(channelName, connectorName, fields) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, channelName);
+    const connector = this.requireDiscordConnector(channel, connectorName);
+    const updated = {
+      ...connector,
+      botToken: fields.botToken ?? connector.botToken,
+      updatedAt: this.clock.iso()
+    };
+    this.assertNoTokenCollision(settings, updated);
+    Object.assign(connector, updated);
+    this.store.write(settings);
+  }
+  listScheduleEntries(channelName, connectorName) {
+    const channel = this.requireChannel(this.store.read(), channelName);
+    const connector = this.requireScheduleConnector(channel, connectorName);
+    return connector.entries;
+  }
+  addScheduleEntry(channelName, connectorName, entry) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, channelName);
+    const connector = this.requireScheduleConnector(channel, connectorName);
+    const persisted = {
+      id: entry.id ?? this.idGenerator.generate(),
+      cron: entry.cron,
+      prompt: entry.prompt,
+      enabled: entry.enabled ?? true,
+      catchupPolicy: entry.catchupPolicy ?? "latest"
+    };
+    connector.entries.push(persisted);
+    connector.updatedAt = this.clock.iso();
+    this.store.write(settings);
+    return persisted;
+  }
+  removeScheduleEntry(channelName, connectorName, id) {
+    const settings = this.store.read();
+    const channel = this.requireChannel(settings, channelName);
+    const connector = this.requireScheduleConnector(channel, connectorName);
+    const index = connector.entries.findIndex((e) => e.id === id);
+    if (index < 0)
+      throw new Error(`schedule entry "${id}" not found`);
+    connector.entries.splice(index, 1);
+    connector.updatedAt = this.clock.iso();
+    this.store.write(settings);
+  }
+  async call(channelName, connectorName, input) {
+    const connector = this.getConnector(channelName, connectorName);
+    if (!connector) {
+      throw new Error(`connector "${connectorName}" not found in channel "${channelName}"`);
+    }
+    const adapter = this.factory.createAdapter(connector);
+    if (!adapter) {
+      throw new Error(`connector type "${connector.type}" does not support outbound calls`);
+    }
+    return await adapter.call(input);
+  }
+  createListener(channelName, connectorName) {
+    const channel = this.get(channelName);
+    if (!channel)
+      return null;
+    const connector = channel.connectors.find((c) => c.name === connectorName);
+    if (!connector)
+      return null;
+    return {
+      config: connector,
+      channelId: channel.id,
+      listener: this.factory.createListener(channel.id, connector)
+    };
+  }
+  createAllListeners() {
+    const out = [];
+    for (const channel of this.list()) {
+      for (const connector of channel.connectors) {
+        out.push({
+          config: connector,
+          channelId: channel.id,
+          channelName: channel.name,
+          listener: this.factory.createListener(channel.id, connector)
+        });
+      }
+    }
+    return out;
+  }
+  requireChannel(settings, name) {
+    const channel = settings.channels.find((c) => c.name === name);
+    if (!channel)
+      throw new Error(`channel "${name}" not found`);
+    return channel;
+  }
+  requireConnector(channel, connectorName) {
+    const connector = channel.connectors.find((c) => c.name === connectorName);
+    if (!connector) {
+      throw new Error(`connector "${connectorName}" not found in channel "${channel.name}"`);
+    }
+    return connector;
+  }
+  requireSlackConnector(channel, connectorName) {
+    const connector = this.requireConnector(channel, connectorName);
+    if (connector.type !== "slack") {
+      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "slack"`);
+    }
+    return connector;
+  }
+  requireGhConnector(channel, connectorName) {
+    const connector = this.requireConnector(channel, connectorName);
+    if (connector.type !== "gh") {
+      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "gh"`);
+    }
+    return connector;
+  }
+  requireDiscordConnector(channel, connectorName) {
+    const connector = this.requireConnector(channel, connectorName);
+    if (connector.type !== "discord") {
+      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "discord"`);
+    }
+    return connector;
+  }
+  requireScheduleConnector(channel, connectorName) {
+    const connector = this.requireConnector(channel, connectorName);
+    if (connector.type !== "schedule") {
+      throw new Error(`connector "${connectorName}" is type "${connector.type}", not "schedule"`);
+    }
+    return connector;
+  }
+  assertNoTokenCollision(settings, candidate) {
+    const tokens = this.tokensOf(candidate);
+    if (tokens.length === 0)
+      return;
+    for (const channel of settings.channels) {
+      for (const other of channel.connectors) {
+        if (other.id === candidate.id)
+          continue;
+        for (const token of this.tokensOf(other)) {
+          if (tokens.includes(token)) {
+            throw new Error(`token already in use by connector "${other.name}" in channel "${channel.name}"`);
+          }
+        }
+      }
+    }
+  }
+  tokensOf(connector) {
+    if (connector.type === "slack")
+      return [connector.botToken, connector.appToken];
+    if (connector.type === "discord")
+      return [connector.botToken];
+    return [];
+  }
+}
+
+// lib/engine/claude/claude.ts
+import { join as join4 } from "path";
+var defaultProcess4 = new NodeFunnelProcessRunner;
+var defaultFs4 = new NodeFunnelFileSystem;
+var defaultLogger6 = new NodeFunnelLogger;
+
+class FunnelClaude {
+  channels;
+  mcp;
+  gateway;
+  process;
+  fs;
+  logger;
+  pidDir;
+  constructor(deps) {
+    this.channels = deps.channels;
+    this.mcp = deps.mcp;
+    this.gateway = deps.gateway;
+    this.process = deps.process ?? defaultProcess4;
+    this.fs = deps.fs ?? defaultFs4;
+    this.logger = deps.logger ?? defaultLogger6;
+    this.pidDir = join4(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.profileName && this.isRunning(options.profileName)) {
+      throw new Error(`profile "${options.profileName}" is already running`);
+    }
+    const cwd = options.cwd ?? globalThis.process.cwd();
+    if (!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.profileName) {
+      this.writePidFile(options.profileName);
+      this.installCleanup(options.profileName);
+    }
+    const claudeArgs = this.buildArgs(options, cwd);
+    const env = this.buildEnv(channel.id);
+    this.logger.info(`claude launch`, {
+      channel: options.channel,
+      channelId: channel.id,
+      subAgent: options.subAgent,
+      cwd
+    });
+    try {
+      return await this.process.attach(["claude", ...claudeArgs], { cwd, env });
+    } finally {
+      if (options.profileName)
+        this.removePidFile(options.profileName);
+    }
+  }
+  isRunning(profileName) {
+    const pid = this.readPid(profileName);
+    if (!pid)
+      return false;
+    return this.isProcessAlive(pid);
+  }
+  pidPath(profileName) {
+    return join4(this.pidDir, `${profileName}.pid`);
+  }
+  readPid(profileName) {
+    const path = this.pidPath(profileName);
+    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(profileName) {
+    this.fs.mkdirSync(this.pidDir, { recursive: true });
+    this.fs.writeFileSync(this.pidPath(profileName), String(globalThis.process.pid));
+  }
+  removePidFile(profileName) {
+    const path = this.pidPath(profileName);
+    if (this.fs.existsSync(path))
+      this.fs.unlink(path);
+  }
+  installCleanup(profileName) {
+    globalThis.process.once("exit", () => this.removePidFile(profileName));
+  }
+  isProcessAlive(pid) {
+    const result = this.process.runSync(["ps", "-p", String(pid), "-o", "state="]);
+    if (result.exitCode !== 0)
+      return false;
+    const state = result.stdout.trim();
+    if (!state)
+      return false;
+    return !state.startsWith("Z");
+  }
+  buildArgs(options, cwd) {
+    const result = [...options.userArgs ?? []];
+    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}`);
+    }
+    if (!result.includes("--agent") && options.subAgent) {
+      result.push("--agent", options.subAgent);
+    }
+    return result;
+  }
+  buildEnv(channelId) {
+    const env = {};
+    for (const [key, value] of Object.entries(globalThis.process.env)) {
+      if (typeof value === "string")
+        env[key] = value;
+    }
+    env.FUNNEL_CHANNEL_ID = channelId;
+    return env;
+  }
+}
+
+// lib/engine/mcp/mcp.ts
+import { join as join5 } from "path";
+import { z as z9 } from "zod";
+var FUNNEL_MCP_COMMAND = "funnel";
+var FUNNEL_MCP_NAME = "funnel";
+var mcpEntrySchema = z9.object({
+  command: z9.string().optional(),
+  args: z9.array(z9.string()).optional()
+});
+var mcpConfigSchema = z9.object({
+  mcpServers: z9.record(z9.string(), mcpEntrySchema).optional()
+});
+var defaultFs5 = new NodeFunnelFileSystem;
+
+class FunnelMcp {
+  fs;
+  constructor(deps = {}) {
+    this.fs = deps.fs ?? defaultFs5;
+    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 existingName = this.findServerName(servers);
+    const targetName = existingName ?? FUNNEL_MCP_NAME;
+    servers[targetName] = {
+      command: FUNNEL_MCP_COMMAND,
+      args: ["mcp"]
+    };
+    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 (value?.command === FUNNEL_MCP_COMMAND)
+        return name;
+    }
+    return null;
+  }
+  readConfig(repoPath) {
+    const mcpPath = join5(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 = join5(repoPath, ".mcp.json");
+    this.fs.writeFileSync(mcpPath, `${JSON.stringify(config, null, 2)}
+`);
+  }
+}
+
+// lib/engine/profiles/profiles.ts
+class FunnelProfiles {
+  store;
+  constructor(deps) {
+    this.store = deps.store;
+    Object.freeze(this);
+  }
+  list() {
+    return this.store.read().profiles;
+  }
+  get(name) {
+    return this.list().find((p) => p.name === name) ?? null;
+  }
+  getDefault() {
+    return this.list()[0] ?? null;
+  }
+  add(config) {
+    const settings = this.store.read();
+    if (settings.profiles.some((p) => p.name === config.name)) {
+      throw new Error(`profile "${config.name}" already exists`);
+    }
+    if (!settings.channels.some((c) => c.id === config.channelId)) {
+      throw new Error(`channel id "${config.channelId}" not found`);
+    }
+    settings.profiles.push(config);
+    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);
+  }
+  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 !== undefined) {
+      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 !== undefined)
+      profile.path = fields.path;
+    if (fields.subAgent !== undefined)
+      profile.subAgent = fields.subAgent;
+    this.store.write(settings);
+  }
+}
+
+// lib/gateway/gateway.ts
+import { join as join6 } from "path";
+
+// lib/gateway/resolve-daemon-script.ts
+import { existsSync as existsSync2 } from "fs";
+import { resolve } from "path";
+var resolveDaemonScript = () => {
+  const candidates = [
+    resolve(import.meta.dir, "./daemon.ts"),
+    resolve(import.meta.dir, "./daemon.js"),
+    resolve(import.meta.dir, "./gateway/daemon.js")
+  ];
+  for (const candidate of candidates) {
+    if (existsSync2(candidate))
+      return candidate;
+  }
+  throw new Error(`daemon script not found (looked in ${candidates.join(", ")})`);
+};
+
+// lib/gateway/gateway.ts
+var DEFAULT_PORT = 9742;
+var DEFAULT_TMP_DIR = "/tmp/funnel";
+var STARTUP_TIMEOUT_MS = 5000;
+var SIGTERM_TIMEOUT_MS = 2000;
+var POLL_INTERVAL_MS = 100;
+var SIGKILL_GRACE_MS = 200;
+var defaultProcess5 = new NodeFunnelProcessRunner;
+var defaultFs6 = new NodeFunnelFileSystem;
+var defaultClock2 = new NodeFunnelClock;
+var defaultSleep = (ms) => new Promise((r) => {
+  setTimeout(r, ms);
+});
+
+class FunnelGateway {
+  process;
+  fs;
+  clock;
+  pidFile;
+  logDir;
+  gatewayLog;
+  tmpDir;
+  port;
+  sleep;
+  constructor(deps = {}) {
+    this.process = deps.process ?? defaultProcess5;
+    this.fs = deps.fs ?? defaultFs6;
+    this.clock = deps.clock ?? defaultClock2;
+    const baseDir = deps.dir ?? FUNNEL_DIR;
+    this.tmpDir = deps.tmpDir ?? DEFAULT_TMP_DIR;
+    this.pidFile = join6(baseDir, "gateway.pid");
+    this.logDir = join6(this.tmpDir, "events");
+    this.gatewayLog = join6(this.tmpDir, "gateway.log");
+    this.port = deps.port ?? DEFAULT_PORT;
+    this.sleep = deps.sleep ?? defaultSleep;
+    Object.freeze(this);
+  }
+  isRunning() {
+    const pid = this.readPid();
+    if (!pid)
+      return false;
+    return this.isProcessAlive(pid);
+  }
+  getStatus() {
+    const pid = this.readPid();
+    const running = pid !== null && this.isProcessAlive(pid);
+    return { running, pid: running ? pid : null, port: this.port };
+  }
+  async start(options = {}) {
+    if (this.isRunning())
+      return true;
+    this.fs.mkdirSync(this.tmpDir, { recursive: true });
+    const gatewayScript = resolveDaemonScript();
+    const command = this.buildStartCommand(gatewayScript, options);
+    this.process.detach(["bash", "-c", command]);
+    const deadline = Date.now() + STARTUP_TIMEOUT_MS;
+    while (Date.now() < deadline) {
+      if (this.isRunning())
+        return true;
+      await this.sleep(POLL_INTERVAL_MS);
+    }
+    return this.isRunning();
+  }
+  buildStartCommand(gatewayScript, options = {}) {
+    const useCaffeinate = options.caffeinate !== false && globalThis.process.platform === "darwin";
+    const prefix = useCaffeinate ? "caffeinate -i " : "";
+    return `nohup ${prefix}bun ${gatewayScript} >> ${this.gatewayLog} 2>&1 &`;
+  }
+  async stop() {
+    const pid = this.readPid();
+    if (!pid)
+      return true;
+    if (!this.isProcessAlive(pid)) {
+      this.removePid();
+      return true;
+    }
+    try {
+      this.process.kill(pid, "SIGTERM");
+    } catch {
+      return false;
+    }
+    const deadline = this.clock.millis() + SIGTERM_TIMEOUT_MS;
+    while (this.clock.millis() < deadline) {
+      if (!this.isProcessAlive(pid)) {
+        this.removePid();
+        return true;
+      }
+      await this.sleep(POLL_INTERVAL_MS);
+    }
+    try {
+      this.process.kill(pid, "SIGKILL");
+    } catch {}
+    await this.sleep(SIGKILL_GRACE_MS);
+    this.removePid();
+    return !this.isProcessAlive(pid);
+  }
+  async restart(options = {}) {
+    const wasRunning = this.isRunning();
+    if (options.onlyIfRunning && !wasRunning) {
+      return { ok: true, wasRunning: false, stopped: false, started: false };
+    }
+    const stopped = wasRunning ? await this.stop() : true;
+    if (!stopped) {
+      return { ok: false, wasRunning, stopped: false, started: false };
+    }
+    const started = await this.start({ caffeinate: options.caffeinate });
+    return { ok: started, wasRunning, stopped, started };
+  }
+  getLogDir() {
+    return this.logDir;
+  }
+  getGatewayLog() {
+    return this.gatewayLog;
+  }
+  getPort() {
+    return this.port;
+  }
+  readPid() {
+    if (!this.fs.existsSync(this.pidFile))
+      return null;
+    try {
+      const content = this.fs.readFileSync(this.pidFile).trim();
+      const pid = Number(content);
+      if (!pid || pid <= 0)
+        return null;
+      return pid;
+    } catch {
+      return null;
+    }
+  }
+  removePid() {
+    this.fs.unlink(this.pidFile);
+  }
+  isProcessAlive(pid) {
+    const result = this.process.runSync(["ps", "-p", String(pid), "-o", "state="]);
+    if (result.exitCode !== 0)
+      return false;
+    const state = result.stdout.trim();
+    if (!state)
+      return false;
+    return !state.startsWith("Z");
+  }
+}
+
+// lib/gateway/gateway-server.ts
+import { existsSync as existsSync3, mkdirSync as mkdirSync3 } from "fs";
+import { join as join7 } from "path";
+
+// lib/gateway/auth-middleware.ts
+import { timingSafeEqual } from "crypto";
+var requireBearerToken = (deps) => {
+  return async (c, next) => {
+    const header = c.req.header("authorization") ?? "";
+    const match = header.match(/^Bearer\s+(.+)$/i);
+    const presented = match?.[1] ?? "";
+    if (!constantTimeEqual(presented, deps.expected)) {
+      return c.text("unauthorized", 401);
+    }
+    return await next();
+  };
+};
+var 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);
+  const equal = timingSafeEqual(padA, padB);
+  return equal && bufA.length === bufB.length;
+};
+
+// lib/gateway/factory.ts
+import { createFactory } from "hono/factory";
+var factory = createFactory();
+
+// lib/engine/logger/noop-logger.ts
+class NoopFunnelLogger extends FunnelLogger {
+  file = null;
+  info() {}
+  warn() {}
+  error() {}
+}
+
+// lib/gateway/broadcaster.ts
+var 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;
+};
+var DEFAULT_MAX_BUFFERED_BYTES = 1024 * 1024;
+var DEFAULT_REPLAY_BUFFER_SIZE = 200;
+var DEFAULT_REPLAY_BUFFER_MAX_BYTES = 4 * 1024 * 1024;
+var defaultLogger7 = new NoopFunnelLogger;
+
+class FunnelBroadcaster {
+  clients = new Map;
+  subscribers = new Set;
+  logger;
+  maxBufferedBytes;
+  now;
+  replayBufferSize;
+  replayBufferMaxBytes;
+  replayBuffer = [];
+  persistentReplay;
+  exclusiveCursor = new Map;
+  replayBufferBytes = 0;
+  eventsBroadcast = 0;
+  droppedSlowClients = 0;
+  lastBroadcastAt = null;
+  latestOffset = 0;
+  constructor(deps = {}) {
+    this.logger = deps.logger ?? defaultLogger7;
+    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
+    };
+  }
+  replaySince(since, data) {
+    const oldestInMemory = this.replayBuffer[0]?.offset;
+    const needFallback = this.persistentReplay && (oldestInMemory === undefined || 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;
+    const beforeMemory = persisted.filter((event) => event.offset < cutoff);
+    return [...beforeMemory, ...fromMemory];
+  }
+  matchesClient(event, data) {
+    if (data.tapAll)
+      return true;
+    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);
+  }
+  pickRecipients(event) {
+    const exclusiveByChannel = 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);
+    const connector = 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) {
+        this.logger.error("broadcast subscriber threw", {
+          error: error instanceof Error ? error.message : String(error)
+        });
+      }
+    }
+    return event;
+  }
+  seedLatestOffset(offset) {
+    if (offset > this.latestOffset)
+      this.latestOffset = offset;
+  }
+}
+
+// lib/gateway/funnel-event-store.ts
+import { z as z10 } from "zod";
+
+// lib/logger/leuco-logger-sqlite-sink.ts
+import { Database } from "bun:sqlite";
+var COLUMN_NAME_RE = /^[a-z_][a-z0-9_]*$/;
+var RESERVED_COLUMNS = new Set(["seq", "ts", "type", "event"]);
+var 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)"
+  ]
+];
+
+class LeucoLoggerSqliteSink {
+  db;
+  maxRows;
+  maxAgeMs;
+  now;
+  indexes;
+  extractIndexes;
+  insertStmt;
+  insertWithSeqStmt;
+  maxSeqStmt;
+  countStmt;
+  trimRowsStmt;
+  trimAgeStmt;
+  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.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 < ?");
+  }
+  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 = [];
+      const apply = 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
+          });
+        }
+      });
+      apply(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 ?? 1000;
+    params.push(limit);
+    const sql = `SELECT seq, ts, type, event FROM leuco_log WHERE ${conditions.join(" AND ")} ORDER BY seq ASC LIMIT ?`;
+    const stmt = this.db.prepare(sql);
+    return stmt.all(...params).map(toRecord2);
+  }
+  getSchemaVersion() {
+    const row = this.db.prepare("PRAGMA user_version").get();
+    return row?.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;
+    const indexParams = this.indexes.map((col) => values?.[col] ?? null);
+    return [ts, type, json, ...indexParams];
+  }
+  appendWhereConditions(where, conditions, params) {
+    const widened = where;
+    for (const col of this.indexes) {
+      const value = widened[col];
+      if (value === undefined)
+        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);
+    }
+  }
+  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 row = this.db.prepare("PRAGMA user_version").get();
+    const current = row?.user_version ?? 0;
+    if (current >= MIGRATIONS.length)
+      return;
+    const pending = MIGRATIONS.slice(current);
+    let version = current;
+    for (const stmts of pending) {
+      version += 1;
+      const apply = this.db.transaction(() => {
+        for (const stmt of stmts)
+          this.db.run(stmt);
+        this.db.run(`PRAGMA user_version = ${version}`);
+      });
+      apply();
+    }
+  }
+}
+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 toRecord2(row) {
+  return {
+    seq: row.seq,
+    ts: row.ts,
+    event: JSON.parse(row.event)
+  };
+}
+
+// lib/gateway/funnel-event-store.ts
+var MAX_CONTENT_CHARS = 2000;
+var funnelEventSchema = z10.object({
+  type: z10.string(),
+  content: z10.string(),
+  channel_id: z10.string().nullable(),
+  connector_id: z10.string().nullable(),
+  meta: z10.record(z10.string(), z10.string()).nullable()
+});
+
+class FunnelEventStore {
+  sink;
+  now;
+  constructor(props) {
+    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 !== undefined ? { maxRows: props.maxRows } : {},
+      ...props.maxAgeMs !== undefined ? { maxAgeMs: props.maxAgeMs } : {}
+    });
+  }
+  record(props) {
+    const event = {
+      type: props.meta?.event_type ?? "unknown",
+      content: truncate(props.content),
+      channel_id: props.channelId,
+      connector_id: props.connectorId,
+      meta: props.meta
+    };
+    this.sink.write({ seq: props.offset, ts: this.now(), event });
+  }
+  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 ?? undefined,
+        offset: record.seq
+      });
+    }
+    return out;
+  }
+  loadForChannel(props) {
+    const where = {
+      channel_id: props.channelId
+    };
+    if (props.connectorId !== undefined)
+      where.connector_id = props.connectorId;
+    const records = this.sink.getRecords({
+      where,
+      ...props.sinceSeq !== undefined ? { sinceSeq: props.sinceSeq } : {},
+      ...props.limit !== undefined ? { limit: props.limit } : {}
+    });
+    const out = [];
+    for (const record of records) {
+      out.push({
+        content: record.event.content,
+        meta: record.event.meta ?? undefined,
+        offset: record.seq
+      });
+    }
+    return out;
+  }
+  findMaxOffset() {
+    return this.sink.getMaxSeq();
+  }
+  close() {
+    this.sink.close();
+  }
+}
+function truncate(content) {
+  if (content.length <= MAX_CONTENT_CHARS)
+    return content;
+  return `${content.slice(0, MAX_CONTENT_CHARS)}...`;
+}
+
+// lib/gateway/listener-supervisor.ts
+var defaultLogger8 = new NodeFunnelLogger;
+var DEFAULT_HEALTH_INTERVAL_MS = 30000;
+var DEFAULT_MAX_BACKOFF_MS = 60000;
+var defaultSleep2 = (ms) => new Promise((r) => {
+  setTimeout(r, ms);
+});
+
+class FunnelListenerSupervisor {
+  channels;
+  notify;
+  logger;
+  running = new Map;
+  failureCounts = new Map;
+  stats = new Map;
+  healthCheckIntervalMs;
+  maxBackoffMs;
+  sleep;
+  now;
+  healthCheckTimer = null;
+  healthCheckInFlight = false;
+  constructor(deps) {
+    this.channels = deps.channels;
+    this.notify = deps.notify;
+    this.logger = deps.logger ?? defaultLogger8;
+    this.healthCheckIntervalMs = deps.healthCheckIntervalMs ?? DEFAULT_HEALTH_INTERVAL_MS;
+    this.maxBackoffMs = deps.maxBackoffMs ?? DEFAULT_MAX_BACKOFF_MS;
+    this.sleep = deps.sleep ?? defaultSleep2;
+    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) {
+      this.logger.error(`${created.config.type} listener failed to start`, {
+        channel: channelName,
+        connector: connectorName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        ok: false,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  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) {
+      this.logger.error(`${entry.config.type} listener failed to stop`, {
+        channel: channelName,
+        connector: connectorName,
+        error: error instanceof Error ? error.message : String(error)
+      });
+      return {
+        ok: false,
+        reason: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+  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(1000 * 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);
+    const result = await this.start(channelName, connectorName);
+    if (result.ok) {
+      this.failureCounts.delete(key);
+      this.logger.info(`${type} listener recovered`, {
+        channel: channelName,
+        connector: connectorName
+      });
+    } else {
+      this.failureCounts.set(key, failureCount + 1);
+    }
+  }
+}
+
+// lib/gateway/kill-competing-slack-gateways.ts
+var defaultProcess6 = new NodeFunnelProcessRunner;
+var defaultLogger9 = new NodeFunnelLogger;
+var isBun = (args) => {
+  return args.includes("bun ") || /\/bun(\s|$)/.test(args);
+};
+var looksLikeSlackGateway = (args) => {
+  return /(gateway|bolt|slack)/i.test(args);
+};
+var killCompetingSlackGateways = async (props) => {
+  const runner = props.process ?? defaultProcess6;
+  const logger = props.logger ?? defaultLogger9;
+  const result = await runner.run(["ps", "-e", "-o", "pid=,args="]);
+  if (result.exitCode !== 0)
+    return [];
+  const killed = [];
+  for (const raw of result.stdout.split(`
+`)) {
+    const line = raw.trim();
+    if (!line)
+      continue;
+    const match = /^(\d+)\s+(.+)$/.exec(line);
+    if (!match)
+      continue;
+    const pid = Number(match[1]);
+    const args = match[2];
+    if (!Number.isInteger(pid) || pid <= 0)
+      continue;
+    if (pid === props.selfPid)
+      continue;
+    if (!isBun(args))
+      continue;
+    if (!looksLikeSlackGateway(args))
+      continue;
+    runner.kill(pid, "SIGTERM");
+    killed.push(pid);
+    logger.info("killed competing Slack gateway process", { pid, args: args.slice(0, 160) });
+  }
+  return killed;
+};
+
+// lib/gateway/routes/channels.connectors.call.ts
+import { HTTPException } from "hono/http-exception";
+import { z as z11 } from "zod";
+
+// lib/gateway/routes/validator.ts
+import { zValidator } from "@hono/zod-validator";
+var 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);
+});
+
+// lib/gateway/routes/channels.connectors.call.ts
+var bodySchema = z11.object({
+  method: z11.string().min(1),
+  path: z11.string().min(1),
+  body: z11.unknown().optional()
+});
+var channelsConnectorsCallHandler = factory.createHandlers(zParam(z11.object({ channel: z11.string().min(1), connector: z11.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 });
+});
+
+// lib/gateway/routes/health.ts
+var healthHandler = factory.createHandlers((c) => {
+  const deps = c.var.deps;
+  return c.json({
+    ok: true,
+    pid: deps.selfPid,
+    clients: deps.broadcaster.getClientCount(),
+    listeners: deps.supervisor.list()
+  });
+});
+
+// lib/gateway/routes/listeners.list.ts
+var listenersListHandler = factory.createHandlers((c) => {
+  return c.json({ listeners: c.var.deps.supervisor.list() });
+});
+
+// lib/gateway/routes/listeners.restart.ts
+import { z as z12 } from "zod";
+var listenersRestartHandler = factory.createHandlers(zParam(z12.object({ channel: z12.string().min(1), connector: z12.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);
+});
+
+// lib/gateway/routes/listeners.start.ts
+import { z as z13 } from "zod";
+var listenersStartHandler = factory.createHandlers(zParam(z13.object({ channel: z13.string().min(1), connector: z13.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);
+});
+
+// lib/gateway/routes/listeners.stop.ts
+import { z as z14 } from "zod";
+var listenersStopHandler = factory.createHandlers(zParam(z14.object({ channel: z14.string().min(1), connector: z14.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);
+});
+
+// lib/gateway/routes/status.ts
+var statusHandler = factory.createHandlers((c) => {
+  const deps = c.var.deps;
+  return c.json({
+    ok: true,
+    pid: deps.selfPid,
+    uptimeMs: deps.uptimeMs(),
+    clients: deps.broadcaster.listChannels(),
+    listeners: deps.supervisor.list(),
+    broadcaster: deps.broadcaster.getMetrics()
+  });
+});
+
+// lib/gateway/routes/index.ts
+var gatewayRoutes = factory.createApp().get("/health", ...healthHandler).get("/status", ...statusHandler).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);
+
+// lib/gateway/gateway-server.ts
+var DEFAULT_PORT2 = 9742;
+var DEFAULT_LOG_DIR = "/tmp/funnel/events";
+var DB_FILENAME = "events.db";
+var defaultLogger10 = new NodeFunnelLogger;
+
+class FunnelGatewayServer {
+  channels;
+  settings;
+  port;
+  logDir;
+  process;
+  logger;
+  selfPid;
+  killCompetingSlack;
+  token;
+  broadcaster;
+  eventStore;
+  supervisor;
+  nowMs;
+  startedAt = null;
+  server = null;
+  constructor(deps) {
+    this.channels = deps.channels;
+    this.settings = deps.settings;
+    this.port = deps.port ?? DEFAULT_PORT2;
+    this.logDir = deps.logDir ?? DEFAULT_LOG_DIR;
+    this.process = deps.process;
+    this.logger = deps.logger ?? defaultLogger10;
+    this.selfPid = deps.selfPid ?? globalThis.process.pid;
+    this.killCompetingSlack = deps.killCompetingSlack ?? true;
+    this.token = deps.token ?? "";
+    const clock = deps.clock;
+    this.nowMs = clock ? () => clock.millis() : () => Date.now();
+    if (!existsSync3(this.logDir))
+      mkdirSync3(this.logDir, { recursive: true });
+    this.eventStore = new FunnelEventStore({
+      path: join7(this.logDir, DB_FILENAME),
+      now: this.nowMs
+    });
+    this.broadcaster = new FunnelBroadcaster({
+      logger: this.logger,
+      now: this.nowMs,
+      persistentReplay: this.eventStore
+    });
+    this.broadcaster.seedLatestOffset(this.eventStore.findMaxOffset());
+    this.supervisor = new FunnelListenerSupervisor({
+      channels: this.channels,
+      logger: this.logger,
+      notify: (channelName, connectorName, content, meta) => this.notify(channelName, connectorName, content, meta),
+      now: this.nowMs
+    });
+  }
+  async start() {
+    if (this.server)
+      return this.server;
+    const app = this.buildApp();
+    this.startedAt = this.nowMs();
+    this.server = Bun.serve({
+      port: this.port,
+      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;
+  }
+  getEventStore() {
+    return this.eventStore;
+  }
+  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 ? Number.NaN : Number.parseInt(sinceRaw, 10);
+      const since = Number.isFinite(sinceParsed) && sinceParsed >= 0 ? sinceParsed : undefined;
+      const upgraded = server.upgrade(request, {
+        data: {
+          channel: channelId,
+          channelName,
+          connectors,
+          tapAll,
+          delivery,
+          since
+        }
+      });
+      if (upgraded)
+        return;
+      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.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
+      });
+      return next();
+    });
+    if (this.token) {
+      base.use("/listeners/*", requireBearerToken({ expected: this.token }));
+      base.use("/status", requireBearerToken({ expected: this.token }));
+      base.use("/channels/*", requireBearerToken({ expected: this.token }));
+    }
+    return base.route("/", gatewayRoutes);
+  }
+  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("funnel.token.".length), this.token)) {
+        return true;
+      }
+    }
+    const auth = request.headers.get("authorization") ?? "";
+    const match = auth.match(/^Bearer\s+(.+)$/i);
+    if (match && constantTimeEqual(match[1] ?? "", this.token))
+      return true;
+    return false;
+  }
+  resolveChannel(requested) {
+    const settings = this.settings.read();
+    const channel = settings?.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,
+        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: ${join7(this.logDir, DB_FILENAME)}`);
+    this.logger.info("funnel gateway running");
+  }
+  async notify(channelName, connectorName, content, meta) {
+    const channelId = this.lookupChannelId(channelName);
+    const connectorId = channelId ? this.lookupConnectorId(channelId, connectorName) : null;
+    const enriched = {
+      ...meta,
+      channel: channelName,
+      connector: connectorName
+    };
+    if (channelId)
+      enriched.channelId = channelId;
+    if (connectorId)
+      enriched.connectorId = connectorId;
+    const event = this.broadcaster.broadcast(content, enriched);
+    this.eventStore.record({
+      content,
+      channelId: channelId ?? null,
+      connectorId: connectorId ?? null,
+      meta: enriched,
+      offset: event.offset
+    });
+  }
+  lookupChannelId(channelName) {
+    const channel = this.settings.read().channels.find((c) => c.name === channelName);
+    return channel?.id ?? null;
+  }
+  lookupConnectorId(channelId, connectorName) {
+    const channel = this.settings.read().channels.find((c) => c.id === channelId);
+    const connector = channel?.connectors.find((c) => c.name === connectorName);
+    return connector?.id ?? null;
+  }
+}
+
+// lib/gateway/gateway-token.ts
+import { homedir as homedir2 } from "os";
+import { dirname as dirname4, join as join8 } from "path";
+var TOKEN_FILE_NAME = "gateway.token";
+var TOKEN_BYTES = 32;
+var defaultFs7 = new NodeFunnelFileSystem;
+var defaultGenerate = () => {
+  const buf = new Uint8Array(TOKEN_BYTES);
+  crypto.getRandomValues(buf);
+  return [...buf].map((b) => b.toString(16).padStart(2, "0")).join("");
+};
+
+class FunnelGatewayToken {
+  fs;
+  path;
+  generate;
+  constructor(deps = {}) {
+    this.fs = deps.fs ?? defaultFs7;
+    this.path = join8(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;
+  }
+  ensure() {
+    const existing = this.read();
+    if (existing)
+      return existing;
+    const token = this.generate();
+    this.fs.mkdirSync(dirname4(this.path), { recursive: true });
+    this.fs.writeSecretFileSync(this.path, `${token}
+`);
+    return token;
+  }
+  getPath() {
+    return this.path;
+  }
+}
+var DEFAULT_GATEWAY_TOKEN_PATH = join8(homedir2(), ".funnel", TOKEN_FILE_NAME);
+
+// lib/gateway/listeners-client.ts
+import { z as z15 } from "zod";
+var listenerEntrySchema = z15.object({
+  channelName: z15.string(),
+  channelId: z15.string(),
+  name: z15.string(),
+  type: z15.string(),
+  alive: z15.boolean()
+});
+var listenersResponseSchema = z15.object({
+  listeners: z15.array(listenerEntrySchema)
+});
+var opErrorBodySchema = z15.object({
+  reason: z15.string().optional()
+});
+var OFFLINE = { state: "offline" };
+
+class FunnelListenersClient {
+  port;
+  isDaemonRunning;
+  getToken;
+  constructor(deps) {
+    this.port = deps.port;
+    this.isDaemonRunning = deps.isDaemonRunning;
+    this.getToken = deps.getToken ?? (() => null);
+    Object.freeze(this);
+  }
+  async list() {
+    if (!this.isDaemonRunning())
+      return { state: "offline" };
+    try {
+      const res = await fetch(`http://localhost:${this.port}/listeners`, {
+        headers: this.authHeaders()
+      });
+      if (!res.ok)
+        return { state: "error", reason: `HTTP ${res.status}` };
+      const parsed = listenersResponseSchema.safeParse(await res.json());
+      if (!parsed.success) {
+        return { state: "error", reason: "malformed daemon response" };
+      }
+      return { state: "ok", listeners: parsed.data.listeners };
+    } catch (error) {
+      return { state: "error", reason: error instanceof Error ? error.message : String(error) };
+    }
+  }
+  async start(channelName, connectorName) {
+    if (!this.isDaemonRunning())
+      return OFFLINE;
+    return await this.call("POST", `/listeners/${this.path(channelName, connectorName)}/start`);
+  }
+  async stop(channelName, connectorName) {
+    if (!this.isDaemonRunning())
+      return OFFLINE;
+    return await this.call("DELETE", `/listeners/${this.path(channelName, connectorName)}`);
+  }
+  async restart(channelName, connectorName) {
+    if (!this.isDaemonRunning())
+      return OFFLINE;
+    return await this.call("POST", `/listeners/${this.path(channelName, connectorName)}/restart`);
+  }
+  path(channelName, connectorName) {
+    return `${encodeURIComponent(channelName)}/${encodeURIComponent(connectorName)}`;
+  }
+  authHeaders() {
+    const token = this.getToken();
+    return token ? { authorization: `Bearer ${token}` } : {};
+  }
+  async call(method, path) {
+    try {
+      const res = await fetch(`http://localhost:${this.port}${path}`, {
+        method,
+        headers: this.authHeaders()
+      });
+      if (!res.ok) {
+        const parsed = opErrorBodySchema.safeParse(await res.json().catch(() => null));
+        const reason = parsed.success ? parsed.data.reason : undefined;
+        return { state: "error", reason: reason ?? `HTTP ${res.status}` };
+      }
+      return { state: "ok" };
+    } catch (error) {
+      return { state: "error", reason: error instanceof Error ? error.message : String(error) };
+    }
+  }
+}
+
+// lib/funnel.ts
+class Funnel {
+  props;
+  constructor(props = {}) {
+    this.props = props;
+    Object.freeze(this);
+  }
+  get store() {
+    return this.props.store ?? new FunnelSettingsStore({
+      path: join9(this.props.dir ?? FUNNEL_DIR, "settings.json"),
+      fs: this.props.fs
+    });
+  }
+  get process() {
+    return this.props.process ?? new NodeFunnelProcessRunner;
+  }
+  get logger() {
+    return this.props.logger ?? new NodeFunnelLogger;
+  }
+  get factory() {
+    return new FunnelConnectorFactory({
+      fs: this.props.fs,
+      process: this.props.process,
+      logger: this.props.logger,
+      dir: this.props.dir
+    });
+  }
+  get channels() {
+    return new FunnelChannels({
+      store: this.store,
+      factory: this.factory,
+      profileChecker: this.profiles,
+      clock: this.props.clock,
+      idGenerator: this.props.idGenerator
+    });
+  }
+  get profiles() {
+    return new FunnelProfiles({ store: this.store });
+  }
+  get mcp() {
+    return new FunnelMcp({ fs: this.props.fs });
+  }
+  get claude() {
+    return new FunnelClaude({
+      channels: this.channels,
+      mcp: this.mcp,
+      gateway: this.gateway,
+      fs: this.props.fs,
+      process: this.props.process,
+      logger: this.props.logger,
+      dir: this.props.dir
+    });
+  }
+  get gateway() {
+    return new FunnelGateway({
+      fs: this.props.fs,
+      process: this.props.process,
+      clock: this.props.clock,
+      dir: this.props.dir,
+      tmpDir: this.props.tmpDir
+    });
+  }
+  get gatewayToken() {
+    return new FunnelGatewayToken({ fs: this.props.fs, dir: this.props.dir });
+  }
+  get listeners() {
+    const gateway = this.gateway;
+    const token = this.gatewayToken;
+    return new FunnelListenersClient({
+      port: gateway.getPort(),
+      isDaemonRunning: () => gateway.isRunning(),
+      getToken: () => token.read()
+    });
+  }
+  gatewayServer(options = {}) {
+    return new FunnelGatewayServer({
+      channels: this.channels,
+      settings: this.store,
+      port: options.port,
+      logDir: options.logDir,
+      process: this.props.process,
+      clock: this.props.clock,
+      logger: this.props.logger,
+      killCompetingSlack: options.killCompetingSlack,
+      token: options.token ?? this.gatewayToken.ensure()
+    });
+  }
+}
+// lib/engine/settings/mock-settings-reader.ts
+var createSettings = (partial = {}) => ({
+  version: SETTINGS_VERSION,
+  channels: [],
+  profiles: [],
+  ...partial
+});
+
+class MockFunnelSettingsReader extends FunnelSettingsReader {
+  state;
+  constructor(initial) {
+    super();
+    this.state = createSettings(initial);
+  }
+  read() {
+    return this.state;
+  }
+  write(settings) {
+    this.state = settings;
+  }
+}
+// lib/engine/fs/memory-file-system.ts
+var SECRET_MODE2 = 384;
+
+class MemoryFunnelFileSystem extends FunnelFileSystem {
+  dirs;
+  files;
+  mtimes;
+  modes;
+  now;
+  constructor(props = {}) {
+    super();
+    this.dirs = new Set(props.dirs ?? []);
+    this.files = new Map(Object.entries(props.files ?? {}));
+    this.mtimes = new Map(Object.entries(props.mtimes ?? {}));
+    this.modes = new Map(Object.entries(props.modes ?? {}));
+    this.now = props.now ?? (() => Date.now());
+  }
+  existsSync(path) {
+    return this.dirs.has(path) || this.files.has(path);
+  }
+  readFileSync(path) {
+    return this.files.get(path) ?? "";
+  }
+  writeFileSync(path, data) {
+    this.files.set(path, data);
+    this.touch(path);
+  }
+  writeSecretFileSync(path, data) {
+    this.files.set(path, data);
+    this.modes.set(path, SECRET_MODE2);
+    this.touch(path);
+  }
+  appendFileSync(path, data) {
+    const prev = this.files.get(path) ?? "";
+    this.files.set(path, prev + data);
+    this.touch(path);
+  }
+  unlink(path) {
+    this.files.delete(path);
+    this.mtimes.delete(path);
+    this.modes.delete(path);
+  }
+  mkdirSync(path, options) {
+    this.dirs.add(path);
+  }
+  readdirSync(path) {
+    const prefix = path.endsWith("/") ? path : `${path}/`;
+    const names = [];
+    for (const file of this.files.keys()) {
+      if (!file.startsWith(prefix))
+        continue;
+      const rest = file.slice(prefix.length);
+      if (!rest.includes("/"))
+        names.push(rest);
+    }
+    return names;
+  }
+  statSync(path) {
+    const mtimeMs = this.mtimes.get(path);
+    if (mtimeMs === undefined) {
+      throw new Error(`not found: ${path}`);
+    }
+    return { mtimeMs, mode: this.modes.get(path) ?? null };
+  }
+  setMtime(path, mtimeMs) {
+    this.mtimes.set(path, mtimeMs);
+  }
+  setMode(path, mode) {
+    this.modes.set(path, mode);
+  }
+  touch(path) {
+    if (!this.mtimes.has(path))
+      this.mtimes.set(path, this.now());
+    else
+      this.mtimes.set(path, this.now());
+  }
+}
+// lib/engine/process/memory-process-runner.ts
+var empty = { exitCode: 0, stdout: "", stderr: "" };
+
+class MemoryFunnelProcessRunner extends FunnelProcessRunner {
+  calls = [];
+  killed = [];
+  handler = () => empty;
+  syncHandler = () => empty;
+  on(handler) {
+    this.handler = handler;
+    return this;
+  }
+  onSync(handler) {
+    this.syncHandler = handler;
+    return this;
+  }
+  async run(command, options = {}) {
+    this.calls.push({ kind: "run", command, options });
+    const result = await this.handler(command);
+    return {
+      exitCode: result.exitCode ?? 0,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? ""
+    };
+  }
+  runSync(command) {
+    this.calls.push({ kind: "runSync", command });
+    const result = this.syncHandler(command);
+    return {
+      exitCode: result.exitCode ?? 0,
+      stdout: result.stdout ?? "",
+      stderr: result.stderr ?? ""
+    };
+  }
+  async attach(command, options = {}) {
+    this.calls.push({ kind: "attach", command, options });
+    const result = await this.handler(command);
+    return result.exitCode ?? 0;
+  }
+  detach(command, options = {}) {
+    this.calls.push({ kind: "detach", command, options });
+  }
+  kill(pid, signal = "SIGTERM") {
+    this.calls.push({ kind: "kill", command: [String(pid), signal] });
+    this.killed.push({ pid, signal });
+  }
+}
+// lib/engine/logger/memory-logger.ts
+class MemoryFunnelLogger extends FunnelLogger {
+  file = null;
+  entries = [];
+  info(message, meta) {
+    this.entries.push({ level: "info", message, meta });
+  }
+  warn(message, meta) {
+    this.entries.push({ level: "warn", message, meta });
+  }
+  error(message, meta) {
+    this.entries.push({ level: "error", message, meta });
+  }
+  clear() {
+    this.entries.length = 0;
+  }
+}
+// lib/engine/time/memory-clock.ts
+class MemoryFunnelClock extends FunnelClock {
+  current;
+  constructor(props = {}) {
+    super();
+    this.current = props.start ?? new Date(0);
+  }
+  now() {
+    return new Date(this.current.getTime());
+  }
+  set(date) {
+    this.current = date;
+  }
+  advance(ms) {
+    this.current = new Date(this.current.getTime() + ms);
+  }
+}
+// lib/engine/id/memory-id-generator.ts
+class MemoryFunnelIdGenerator extends FunnelIdGenerator {
+  counter = 0;
+  prefix;
+  constructor(props = {}) {
+    super();
+    this.prefix = props.prefix ?? "id";
+  }
+  generate() {
+    this.counter++;
+    return `${this.prefix}-${this.counter}`;
+  }
+}
+export {
+  slackConnectorSchema,
+  settingsSchema,
+  scheduleEntrySchema,
+  scheduleConnectorSchema,
+  scheduleCatchupPolicySchema,
+  profileConfigSchema,
+  funnelEventSchema,
+  createSettings,
+  connectorConfigSchema,
+  channelDeliveryModeSchema,
+  channelConfigSchema,
+  SETTINGS_VERSION,
+  SETTINGS_PATH,
+  NoopFunnelLogger,
+  NodeFunnelProcessRunner,
+  NodeFunnelLogger,
+  NodeFunnelIdGenerator,
+  NodeFunnelFileSystem,
+  NodeFunnelClock,
+  MockFunnelSettingsReader,
+  MemoryFunnelProcessRunner,
+  MemoryFunnelLogger,
+  MemoryFunnelIdGenerator,
+  MemoryFunnelFileSystem,
+  MemoryFunnelClock,
+  FunnelSettingsStore,
+  FunnelSettingsReader,
+  FunnelProfiles,
+  FunnelProcessRunner,
+  FunnelMcp,
+  FunnelLogger,
+  FunnelListenersClient,
+  FunnelListenerSupervisor,
+  FunnelIdGenerator,
+  FunnelGatewayServer,
+  FunnelGateway,
+  FunnelFileSystem,
+  FunnelEventStore,
+  FunnelConnectorListener,
+  FunnelConnectorFactory,
+  FunnelClock,
+  FunnelClaude,
+  FunnelChannels,
+  FunnelBroadcaster,
+  Funnel,
+  FUNNEL_MCP_NAME,
+  FUNNEL_MCP_COMMAND,
+  FUNNEL_DIR
+};