@interactive-inc/claude-funnel 0.8.0 → 0.10.0

package/dist/index.d.ts

@@ -0,0 +1,3888 @@
+import { n as FunnelConnectorAdapter, t as CallInput } from "./connector-adapter-CXB-q_XC.js";
+import { n as discordConnectorSchema, t as DiscordConnectorConfig } from "./discord-connector-schema-Dww2I4zH.js";
+import { n as FunnelConnectorListener, r as NotifyFn, t as FunnelLogger } from "./logger-CTlXs7z4.js";
+import { a as FunnelProcessRunner, i as DetachOptions, n as ghConnectorSchema, o as RunOptions, r as AttachOptions, s as RunResult, t as GhConnectorConfig } from "./gh-connector-schema-BZFAS-p-.js";
+import { a as ScheduleEntry, c as scheduleEntrySchema, i as ScheduleConnectorConfig, n as FunnelFileSystem, o as scheduleCatchupPolicySchema, r as ScheduleCatchupPolicy, s as scheduleConnectorSchema, t as FileStat } from "./file-system-Co60LrmR.js";
+import { n as slackConnectorSchema, t as SlackConnectorConfig } from "./slack-connector-schema-D7zAHN8k.js";
+import { z } from "zod";
+import { Server, ServerWebSocket } from "bun";
+import * as _$hono_factory0 from "hono/factory";
+import * as _$hono_utils_http_status0 from "hono/utils/http-status";
+import * as _$hono_hono_base0 from "hono/hono-base";
+
+//#region lib/connectors/connector-config-schema.d.ts
+declare const connectorConfigSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"slack">;
+  botToken: z.ZodString;
+  appToken: z.ZodString;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"gh">;
+  pollInterval: z.ZodOptional<z.ZodNumber>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"discord">;
+  botToken: z.ZodString;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodLiteral<"schedule">;
+  entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    cron: z.ZodString;
+    prompt: z.ZodString;
+    enabled: z.ZodDefault<z.ZodBoolean>;
+    catchupPolicy: z.ZodDefault<z.ZodEnum<{
+      latest: "latest";
+      all: "all";
+      skip: "skip";
+    }>>;
+  }, z.core.$strip>>>;
+  createdAt: z.ZodOptional<z.ZodString>;
+  updatedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>], "type">;
+type ConnectorConfig = z.infer<typeof connectorConfigSchema>;
+type ConnectorType = ConnectorConfig["type"];
+//#endregion
+//#region lib/connectors/connector-factory.d.ts
+type Deps$12 = {
+  fs?: FunnelFileSystem;
+  process?: FunnelProcessRunner;
+  logger?: FunnelLogger;
+  dir?: string;
+};
+/**
+ * Pure factory for per-type listeners and adapters. The factory has no CRUD
+ * responsibility — connector configs live inside settings.json under their
+ * channel, and FunnelChannels passes them in by value.
+ *
+ * `dir` is the funnel home (defaults to ~/.funnel); per-connector state files
+ * land at `<dir>/channels/<channel-id>/connectors/<connector-id>/state.json`.
+ */
+declare class FunnelConnectorFactory {
+  private readonly fs;
+  private readonly process;
+  private readonly logger;
+  private readonly dir;
+  constructor(deps?: Deps$12);
+  createListener(channelId: string, config: ConnectorConfig): FunnelConnectorListener;
+  createAdapter(config: ConnectorConfig): FunnelConnectorAdapter | null;
+  connectorDir(channelId: string, connectorId: string): string;
+  channelDir(channelId: string): string;
+}
+//#endregion
+//#region lib/engine/profiles/profile-channel-checker.d.ts
+/**
+ * Read-side dependency that lets FunnelChannels ask whether a profile
+ * references a given channel id, without depending on FunnelProfiles directly.
+ */
+type ProfileChannelChecker = {
+  hasChannelRef(channelId: string): boolean;
+};
+//#endregion
+//#region lib/engine/time/clock.d.ts
+/**
+ * Time boundary. Default NodeFunnelClock returns `new Date()`; MemoryFunnelClock
+ * is settable and `advance(ms)`-able for deterministic schedule / timeout tests.
+ */
+declare abstract class FunnelClock {
+  abstract now(): Date;
+  millis(): number;
+  iso(): string;
+}
+//#endregion
+//#region lib/engine/id/id-generator.d.ts
+/**
+ * ID generator boundary. Default NodeFunnelIdGenerator wraps `crypto.randomUUID()`;
+ * MemoryFunnelIdGenerator emits `<prefix>-1, <prefix>-2, ...` for deterministic tests.
+ */
+declare abstract class FunnelIdGenerator {
+  abstract generate(): string;
+}
+//#endregion
+//#region lib/engine/settings/settings-schema.d.ts
+/**
+ * Routing mode when multiple WS clients are subscribed to the same channel.
+ *
+ * - `fanout` (default): every connected client receives every event. Right when each
+ *   subscriber has its own job (e.g., TUI mirrors, distinct Claude profiles each running
+ *   their own pipeline against the same source).
+ * - `exclusive`: each event is delivered to exactly one connected client, picked
+ *   round-robin per channel. Right when subscribers are interchangeable workers and you
+ *   want each event handled once. Tap=all clients (TUI dashboard) always receive,
+ *   regardless of mode, so they can passively observe.
+ */
+declare const channelDeliveryModeSchema: z.ZodEnum<{
+  fanout: "fanout";
+  exclusive: "exclusive";
+}>;
+type ChannelDeliveryMode = z.infer<typeof channelDeliveryModeSchema>;
+declare const channelConfigSchema: z.ZodObject<{
+  id: z.ZodString;
+  name: z.ZodString;
+  delivery: z.ZodDefault<z.ZodEnum<{
+    fanout: "fanout";
+    exclusive: "exclusive";
+  }>>;
+  connectors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"slack">;
+    botToken: z.ZodString;
+    appToken: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"gh">;
+    pollInterval: z.ZodOptional<z.ZodNumber>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"discord">;
+    botToken: z.ZodString;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    type: z.ZodLiteral<"schedule">;
+    entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+      id: z.ZodString;
+      cron: z.ZodString;
+      prompt: z.ZodString;
+      enabled: z.ZodDefault<z.ZodBoolean>;
+      catchupPolicy: z.ZodDefault<z.ZodEnum<{
+        latest: "latest";
+        all: "all";
+        skip: "skip";
+      }>>;
+    }, z.core.$strip>>>;
+    createdAt: z.ZodOptional<z.ZodString>;
+    updatedAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>], "type">>>;
+}, z.core.$strip>;
+type ChannelConfig = z.infer<typeof channelConfigSchema>;
+declare const profileConfigSchema: z.ZodObject<{
+  name: z.ZodString;
+  path: z.ZodString;
+  subAgent: z.ZodString;
+  channelId: z.ZodString;
+  brief: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type ProfileConfig = z.infer<typeof profileConfigSchema>;
+declare const SETTINGS_VERSION = 1;
+declare const settingsSchema: z.ZodObject<{
+  version: z.ZodDefault<z.ZodLiteral<1>>;
+  channels: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    name: z.ZodString;
+    delivery: z.ZodDefault<z.ZodEnum<{
+      fanout: "fanout";
+      exclusive: "exclusive";
+    }>>;
+    connectors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodLiteral<"slack">;
+      botToken: z.ZodString;
+      appToken: z.ZodString;
+      createdAt: z.ZodOptional<z.ZodString>;
+      updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodLiteral<"gh">;
+      pollInterval: z.ZodOptional<z.ZodNumber>;
+      createdAt: z.ZodOptional<z.ZodString>;
+      updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodLiteral<"discord">;
+      botToken: z.ZodString;
+      createdAt: z.ZodOptional<z.ZodString>;
+      updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+      id: z.ZodString;
+      name: z.ZodString;
+      type: z.ZodLiteral<"schedule">;
+      entries: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        id: z.ZodString;
+        cron: z.ZodString;
+        prompt: z.ZodString;
+        enabled: z.ZodDefault<z.ZodBoolean>;
+        catchupPolicy: z.ZodDefault<z.ZodEnum<{
+          latest: "latest";
+          all: "all";
+          skip: "skip";
+        }>>;
+      }, z.core.$strip>>>;
+      createdAt: z.ZodOptional<z.ZodString>;
+      updatedAt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>], "type">>>;
+  }, z.core.$strip>>>;
+  profiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    name: z.ZodString;
+    path: z.ZodString;
+    subAgent: z.ZodString;
+    channelId: z.ZodString;
+    brief: z.ZodOptional<z.ZodBoolean>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Settings = z.infer<typeof settingsSchema>;
+//#endregion
+//#region lib/engine/settings/settings-reader.d.ts
+declare abstract class FunnelSettingsReader {
+  abstract read(): Settings;
+  abstract write(settings: Settings): void;
+}
+//#endregion
+//#region lib/engine/channels/channels.d.ts
+type Deps$11 = {
+  store: FunnelSettingsReader;
+  factory: FunnelConnectorFactory;
+  profileChecker: ProfileChannelChecker;
+  clock?: FunnelClock;
+  idGenerator?: FunnelIdGenerator;
+};
+type ChannelConnectorView = ConnectorConfig & {
+  channelId: string;
+  channelName: string;
+};
+type AddConnectorInput = {
+  type: "slack";
+  name: string;
+  botToken: string;
+  appToken: string;
+} | {
+  type: "gh";
+  name: string;
+  pollInterval?: number;
+} | {
+  type: "discord";
+  name: string;
+  botToken: string;
+} | {
+  type: "schedule";
+  name: string;
+  entries?: ScheduleEntry[];
+};
+/**
+ * Channels own their connectors. Each channel has a stable id (UUID); the
+ * `name` is the human-facing label used by the CLI. Connectors live nested
+ * inside `channel.connectors[]`, so add/remove/rename are channel-scoped — no
+ * global connector namespace exists. Token uniqueness is enforced across all
+ * channels at add/update time so the same Slack/Discord credentials cannot
+ * be registered twice.
+ */
+declare class FunnelChannels {
+  private readonly store;
+  private readonly factory;
+  private readonly profileChecker;
+  private readonly clock;
+  private readonly idGenerator;
+  constructor(deps: Deps$11);
+  list(): ChannelConfig[];
+  get(name: string): ChannelConfig | null;
+  getById(id: string): ChannelConfig | null;
+  add(input: {
+    name: string;
+    delivery?: ChannelDeliveryMode;
+  }): ChannelConfig;
+  setDelivery(name: string, delivery: ChannelDeliveryMode): void;
+  remove(name: string): void;
+  rename(oldName: string, newName: string): void;
+  listConnectors(channelName: string): ConnectorConfig[];
+  getConnector(channelName: string, connectorName: string): ConnectorConfig | null;
+  listAllConnectors(): ChannelConnectorView[];
+  addConnector(channelName: string, input: AddConnectorInput): ConnectorConfig;
+  private fromInput;
+  removeConnector(channelName: string, connectorName: string): void;
+  renameConnector(channelName: string, oldName: string, newName: string): void;
+  updateSlackConnector(channelName: string, connectorName: string, fields: {
+    botToken?: string;
+    appToken?: string;
+  }): void;
+  updateGhConnector(channelName: string, connectorName: string, fields: {
+    pollInterval?: number;
+  }): void;
+  updateDiscordConnector(channelName: string, connectorName: string, fields: {
+    botToken?: string;
+  }): void;
+  listScheduleEntries(channelName: string, connectorName: string): ScheduleEntry[];
+  addScheduleEntry(channelName: string, connectorName: string, entry: Pick<ScheduleEntry, "cron" | "prompt"> & Partial<Pick<ScheduleEntry, "id" | "enabled" | "catchupPolicy">>): ScheduleEntry;
+  removeScheduleEntry(channelName: string, connectorName: string, id: string): void;
+  call(channelName: string, connectorName: string, input: CallInput): Promise<unknown>;
+  createListener(channelName: string, connectorName: string): {
+    config: ConnectorConfig;
+    channelId: string;
+    listener: FunnelConnectorListener;
+  } | null;
+  createAllListeners(): {
+    config: ConnectorConfig;
+    channelId: string;
+    channelName: string;
+    listener: FunnelConnectorListener;
+  }[];
+  private requireChannel;
+  private requireConnector;
+  private requireSlackConnector;
+  private requireGhConnector;
+  private requireDiscordConnector;
+  private requireScheduleConnector;
+  private assertNoTokenCollision;
+  private tokensOf;
+}
+//#endregion
+//#region lib/engine/claude/gateway-controller.d.ts
+type GatewayController = {
+  isRunning(): boolean;
+  start(options?: {
+    caffeinate?: boolean;
+  }): Promise<boolean>;
+};
+//#endregion
+//#region lib/engine/mcp/mcp.d.ts
+declare const FUNNEL_MCP_COMMAND = "funnel";
+declare const FUNNEL_MCP_NAME = "funnel";
+type Deps$10 = {
+  fs?: FunnelFileSystem;
+};
+/**
+ * Installs/uninstalls the funnel MCP entry into a target repository's
+ * `.mcp.json`. Detects an existing entry by command match so renaming is
+ * preserved across re-installs.
+ */
+declare class FunnelMcp {
+  private readonly fs;
+  constructor(deps?: Deps$10);
+  install(repoPath: string): void;
+  uninstall(repoPath: string): void;
+  findInstalledName(cwd: string): string | null;
+  private findServerName;
+  private readConfig;
+  private writeConfig;
+}
+//#endregion
+//#region lib/engine/claude/claude.d.ts
+type LaunchOptions = {
+  channel: string;
+  cwd?: string;
+  subAgent?: string;
+  userArgs?: string[];
+  profileName?: string; /** Forward `--brief` to claude on launch (enables the SendUserMessage tool). */
+  brief?: boolean;
+};
+type Deps$9 = {
+  channels: FunnelChannels;
+  mcp: FunnelMcp;
+  gateway: GatewayController;
+  process?: FunnelProcessRunner;
+  fs?: FunnelFileSystem;
+  logger?: FunnelLogger;
+  dir?: string;
+};
+/**
+ * Launches Claude Code with funnel pre-wired: ensures the gateway is running,
+ * installs the funnel MCP into the target repo's `.mcp.json` if missing,
+ * injects `FUNNEL_CHANNEL_ID` into the child env, and writes a per-profile
+ * PID file to enforce singleton launches.
+ */
+declare class FunnelClaude {
+  private readonly channels;
+  private readonly mcp;
+  private readonly gateway;
+  private readonly process;
+  private readonly fs;
+  private readonly logger;
+  private readonly pidDir;
+  constructor(deps: Deps$9);
+  launch(options: LaunchOptions): Promise<number>;
+  isRunning(profileName: string): boolean;
+  private pidPath;
+  private readPid;
+  private writePidFile;
+  private removePidFile;
+  private installCleanup;
+  private isProcessAlive;
+  private buildArgs;
+  private buildEnv;
+}
+//#endregion
+//#region lib/engine/profiles/profiles.d.ts
+type Deps$8 = {
+  store: FunnelSettingsReader;
+};
+/**
+ * Named launch presets for `fnl claude`. Each profile bundles a working
+ * directory, a sub-agent name, and the channel id its Claude instance will
+ * subscribe to. Implements ProfileChannelChecker so FunnelChannels can refuse
+ * to remove a channel that is still referenced.
+ *
+ * The first entry in the persisted array is treated as the default profile;
+ * `asDefault` reorders the array to put a named profile first.
+ *
+ * `channelId` always stores the channel's stable id (uuid). CLI surfaces
+ * resolve channel name → id before calling `add`/`update` here.
+ */
+declare class FunnelProfiles {
+  private readonly store;
+  constructor(deps: Deps$8);
+  list(): ProfileConfig[];
+  get(name: string): ProfileConfig | null;
+  getDefault(): ProfileConfig | null;
+  add(config: ProfileConfig): void;
+  remove(name: string): void;
+  rename(oldName: string, newName: string): void;
+  asDefault(name: string): void;
+  hasChannelRef(channelId: string): boolean;
+  update(name: string, fields: Partial<Omit<ProfileConfig, "name">>): void;
+}
+//#endregion
+//#region lib/gateway/publish-schema.d.ts
+/**
+ * Shared schema for `POST /channels/:channel/publish` — used by both the
+ * gateway route handler (input validation) and the CLI / programmable client
+ * (request shape). The route resolves `channel` from the path; this body
+ * covers everything else.
+ */
+declare const publishRequestSchema: z.ZodObject<{
+  content: z.ZodString;
+  meta: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  connector: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type PublishRequest = z.infer<typeof publishRequestSchema>;
+declare const publishResponseSchema: z.ZodObject<{
+  ok: z.ZodLiteral<true>;
+  offset: z.ZodNumber;
+}, z.core.$strip>;
+type PublishResponse = z.infer<typeof publishResponseSchema>;
+type PublishResult = {
+  state: "ok";
+  offset: number;
+} | {
+  state: "offline";
+} | {
+  state: "error";
+  reason: string;
+};
+//#endregion
+//#region lib/gateway/channel-publisher.d.ts
+type Deps$7 = {
+  port: number;
+  isDaemonRunning: () => boolean; /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
+  getToken?: () => string | null;
+};
+/**
+ * HTTP client for `POST /channels/:channel/publish` on a running gateway
+ * daemon. Returns `{ state: "offline" }` when the daemon isn't up so callers
+ * can branch without exceptions, mirroring `FunnelListenersClient`.
+ */
+declare class FunnelChannelPublisher {
+  private readonly port;
+  private readonly isDaemonRunning;
+  private readonly getToken;
+  constructor(deps: Deps$7);
+  publish(channelName: string, request: PublishRequest): Promise<PublishResult>;
+  private authHeaders;
+}
+//#endregion
+//#region lib/gateway/gateway.d.ts
+type Deps$6 = {
+  process?: FunnelProcessRunner;
+  fs?: FunnelFileSystem;
+  clock?: FunnelClock;
+  dir?: string;
+  tmpDir?: string;
+  port?: number;
+  sleep?: (ms: number) => Promise<void>;
+};
+/**
+ * Manages the gateway daemon as a separate process via PID file.
+ * Use `start()` to spawn `bun daemon.ts` in the background and `stop()` to
+ * terminate it. For an in-process gateway, use `Funnel.gatewayServer` instead.
+ */
+declare class FunnelGateway {
+  private readonly process;
+  private readonly fs;
+  private readonly clock;
+  private readonly pidFile;
+  private readonly logDir;
+  private readonly gatewayLog;
+  private readonly tmpDir;
+  private readonly port;
+  private readonly sleep;
+  constructor(deps?: Deps$6);
+  isRunning(): boolean;
+  getStatus(): {
+    running: boolean;
+    pid: number | null;
+    port: number;
+  };
+  start(options?: {
+    caffeinate?: boolean;
+  }): Promise<boolean>;
+  buildStartCommand(gatewayScript: string, options?: {
+    caffeinate?: boolean;
+  }): string;
+  stop(): Promise<boolean>;
+  restart(options?: {
+    onlyIfRunning?: boolean;
+    caffeinate?: boolean;
+  }): Promise<{
+    ok: boolean;
+    wasRunning: boolean;
+    stopped: boolean;
+    started: boolean;
+  }>;
+  getLogDir(): string;
+  getGatewayLog(): string;
+  getPort(): number;
+  private readPid;
+  private removePid;
+  private isProcessAlive;
+}
+//#endregion
+//#region lib/gateway/broadcaster.d.ts
+type ClientData = {
+  /** Stable channel id (uuid) that the WS client subscribed to. */channel: string; /** Human-facing channel name resolved at upgrade time, kept for log readability. */
+  channelName?: string | null; /** Connector names belonging to that channel; used by tap-all replay filtering. */
+  connectors: string[];
+  tapAll?: boolean; /** Routing mode resolved from channel config at upgrade time. Defaults to fanout. */
+  delivery?: "fanout" | "exclusive";
+};
+type BroadcastEvent = {
+  content: string;
+  meta?: Record<string, string>;
+};
+type ReplayableEvent = BroadcastEvent & {
+  offset: number;
+};
+type BroadcastSubscriber = (event: ReplayableEvent) => void;
+/**
+ * Optional persistent replay source. Wired in by the gateway-server with
+ * `FunnelEventStore` (SQLite-backed) so reconnects across daemon restarts
+ * can recover events older than the in-memory buffer via an indexed
+ * `seq > since` range scan.
+ */
+type ReplaySource = {
+  loadSince(since: number): ReplayableEvent[];
+};
+type Deps$5 = {
+  logger?: FunnelLogger;
+  maxBufferedBytes?: number;
+  now?: () => number; /** Number of recent events kept in the in-memory replay buffer. */
+  replayBufferSize?: number; /** Hard byte cap on replay buffer payloads. Older events are evicted FIFO until under this cap. */
+  replayBufferMaxBytes?: number; /** Persistent replay source consulted when the in-memory buffer cannot satisfy `since`. */
+  persistentReplay?: ReplaySource;
+};
+type BroadcasterMetrics = {
+  clients: number;
+  subscribers: number;
+  eventsBroadcast: number;
+  droppedSlowClients: number;
+  lastBroadcastAt: string | null; /** Latest emitted offset. Clients can `?since=<offset>` to ask for events strictly after this point. */
+  latestOffset: number; /** Oldest offset still held in the replay buffer. Older values cannot be replayed and trigger a full resync. */
+  oldestReplayableOffset: number | null;
+};
+/**
+ * In-process pub/sub for connector events.
+ *
+ * Two outbound paths:
+ *   - WS clients connected via the gateway's `/ws` endpoint, scoped per channel
+ *   - In-process subscribers registered via `subscribe()` (programmable API)
+ *
+ * Backpressure: if a WS client's `bufferedAmount` exceeds `maxBufferedBytes`
+ * (default 1 MiB), the client is closed with code 1009 and dropped from the
+ * registry to keep one slow consumer from blocking the daemon.
+ *
+ * Replay: every emitted event gets a strictly increasing `offset`. The latest
+ * `replayBufferSize` events are kept in memory; reconnecting WS clients can
+ * pass `?since=<offset>` and the broadcaster resends matching events before
+ * resuming the live stream. The in-memory ring covers short reconnects;
+ * older history is served from the SQLite event store wired in as
+ * `persistentReplay`.
+ */
+declare class FunnelBroadcaster {
+  private readonly clients;
+  private readonly subscribers;
+  private readonly logger;
+  private readonly maxBufferedBytes;
+  private readonly now;
+  private readonly replayBufferSize;
+  private readonly replayBufferMaxBytes;
+  private readonly replayBuffer;
+  private readonly persistentReplay;
+  private readonly exclusiveCursor;
+  private replayBufferBytes;
+  private eventsBroadcast;
+  private droppedSlowClients;
+  private lastBroadcastAt;
+  private latestOffset;
+  constructor(deps?: Deps$5);
+  getMetrics(): BroadcasterMetrics;
+  /**
+   * Returns events with offset > since, filtered by the connector subscription
+   * rules of `data`. Used at WS upgrade time when the client passes `?since=<offset>`.
+   *
+   * Two-tier lookup:
+   *   1. The in-memory ring buffer (covers short reconnects, last `replayBufferSize` events).
+   *   2. If `since` predates the oldest in-memory entry and a persistent replay source
+   *      is wired in (SQLite), the gap is filled from disk. This covers reconnects across
+   *      daemon restarts where the in-memory buffer was lost.
+   *
+   * Result is sorted ascending by offset and de-duplicated against the in-memory buffer.
+   */
+  replaySince(since: number, data: ClientData): ReplayableEvent[];
+  private matchesClient;
+  /**
+   * Returns the list of WS clients that should receive `event`. Tap=all clients always
+   * receive (passive observation). For each per-channel group:
+   *   - fanout → every matching client receives
+   *   - exclusive → exactly one client receives, picked round-robin per channel
+   */
+  private pickRecipients;
+  addClient(ws: ServerWebSocket<unknown>, data: ClientData): void;
+  removeClient(ws: ServerWebSocket<unknown>): void;
+  getClientCount(): number;
+  listChannels(): {
+    channel: string;
+    connectors: string[];
+  }[];
+  subscribe(handler: BroadcastSubscriber): () => void;
+  broadcast(content: string, meta?: Record<string, string>): ReplayableEvent;
+  /** Forward-seed the offset counter (used at startup from the persisted event store). */
+  seedLatestOffset(offset: number): void;
+}
+//#endregion
+//#region lib/gateway/funnel-event-store.d.ts
+/**
+ * Replayable event payload persisted by the gateway. Domain events the
+ * broadcaster emits to WS clients land here so reconnects across daemon
+ * restarts can be served from disk. System events (gateway start, channel
+ * connected, etc.) are routed to `FunnelLogger` instead — they never go
+ * through this store, which keeps the seq space clean for replay.
+ */
+declare const funnelEventSchema: z.ZodObject<{
+  type: z.ZodString;
+  content: z.ZodString;
+  channel_id: z.ZodNullable<z.ZodString>;
+  connector_id: z.ZodNullable<z.ZodString>;
+  meta: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodString>>;
+}, z.core.$strip>;
+type FunnelEvent = z.infer<typeof funnelEventSchema>;
+type Props$5 = {
+  /** SQLite database file path. Created on first write. ":memory:" for tests. */path: string; /** Override for tests. Defaults to `Date.now`. */
+  now?: () => number; /** Optional row cap. Pruned on every insert. */
+  maxRows?: number; /** Optional age cap in ms. Pruned on every insert. */
+  maxAgeMs?: number;
+};
+/**
+ * SQLite-backed event store. One indexed table holds every broadcaster
+ * event with `channel_id` and `connector_id` as dedicated columns, so
+ * per-channel and per-connector replay is an indexed range scan.
+ *
+ * Concurrency: `seq` is `INTEGER PRIMARY KEY`, so SQLite assigns it
+ * atomically. The broadcaster owns its own offset counter at runtime
+ * (seeded from `findMaxOffset()` at startup); each broadcaster event
+ * flows in here via `record()` with that pre-assigned offset, which the
+ * sink stores via `write()` — PK uniqueness catches double-emit bugs.
+ *
+ * System events (gateway lifecycle, channel connect/disconnect, etc.) do
+ * NOT go through this store. They are diagnostic only and live in
+ * `FunnelLogger`'s file so the seq space here stays exclusive to
+ * broadcaster traffic. This is what makes the broadcaster's seq seeding
+ * (`getMaxSeq()` at startup) correct without per-event coordination.
+ */
+declare class FunnelEventStore {
+  private readonly sink;
+  private readonly now;
+  constructor(props: Props$5);
+  /**
+   * Persist a broadcaster-driven event with its assigned offset. Caller
+   * (the gateway-server) supplies the offset from `broadcaster.broadcast()`
+   * so this store and the broadcaster's in-memory ring stay aligned.
+   */
+  record(props: {
+    content: string;
+    channelId: string | null;
+    connectorId: string | null;
+    meta: Record<string, string> | null;
+    offset: number;
+  }): void;
+  /**
+   * Returns events with offset > since. Filtering by channel/connector is
+   * the broadcaster's responsibility (it knows the client's subscription),
+   * so this returns the full slice and lets the caller filter.
+   */
+  loadSince(since: number): ReplayableEvent[];
+  /**
+   * Returns events for one channel (and optionally one connector). Used
+   * by the gateway logs CLI for scoped queries. Channel/connector filters
+   * are indexed columns, so this is an indexed range scan.
+   */
+  loadForChannel(props: {
+    channelId: string;
+    connectorId?: string;
+    sinceSeq?: number;
+    limit?: number;
+  }): ReplayableEvent[];
+  findMaxOffset(): number;
+  close(): void;
+}
+//#endregion
+//#region lib/gateway/listener-supervisor.d.ts
+type ConnectorRegistry = {
+  listAllConnectors(): ChannelConnectorView[];
+  createListener(channelName: string, connectorName: string): {
+    config: ConnectorConfig;
+    channelId: string;
+    listener: FunnelConnectorListener;
+  } | null;
+};
+type SupervisorNotify = (channelName: string, connectorName: string, content: string, meta?: Record<string, string>) => Promise<void>;
+type Deps$4 = {
+  channels: ConnectorRegistry;
+  notify: SupervisorNotify;
+  logger?: FunnelLogger;
+  healthCheckIntervalMs?: number;
+  maxBackoffMs?: number;
+  sleep?: (ms: number) => Promise<void>;
+  now?: () => number;
+};
+type ListenerEntryStatus = {
+  channelName: string;
+  channelId: string;
+  name: string;
+  type: ConnectorConfig["type"];
+  alive: boolean;
+  events: number;
+  errors: number;
+  failureCount: number;
+  lastEventAt: string | null;
+};
+/**
+ * Owns the running listener instances and their lifecycle.
+ *
+ * Lives in the gateway process and is the only place that calls
+ * `listener.start()` / `listener.stop()`. Each entry is keyed by
+ * `${channelName}/${connectorName}` so the same connector name can exist in
+ * multiple channels without colliding.
+ *
+ * Periodically polls each running listener's `isAlive()` and auto-restarts
+ * dead listeners with exponential backoff (1s, 2s, 4s, ... capped). Resets
+ * the backoff counter on successful restart.
+ */
+declare class FunnelListenerSupervisor {
+  private readonly channels;
+  private readonly notify;
+  private readonly logger;
+  private readonly running;
+  private readonly failureCounts;
+  private readonly stats;
+  private readonly healthCheckIntervalMs;
+  private readonly maxBackoffMs;
+  private readonly sleep;
+  private readonly now;
+  private healthCheckTimer;
+  private healthCheckInFlight;
+  constructor(deps: Deps$4);
+  static keyOf(channelName: string, connectorName: string): string;
+  isRunning(channelName: string, connectorName: string): boolean;
+  list(): ListenerEntryStatus[];
+  start(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  stop(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  restart(channelName: string, connectorName: string): Promise<{
+    ok: boolean;
+    reason?: string;
+  }>;
+  startAll(): Promise<void>;
+  stopAll(): Promise<void>;
+  private ensureStats;
+  private recordEvent;
+  private recordError;
+  private startHealthCheck;
+  private stopHealthCheck;
+  private runHealthCheck;
+  private recoverDead;
+}
+//#endregion
+//#region lib/gateway/gateway-server.d.ts
+type Deps$3 = {
+  channels: FunnelChannels;
+  settings: FunnelSettingsReader;
+  port?: number; /** Directory holding the SQLite event store. The DB file lives at `<logDir>/events.db`. */
+  logDir?: string;
+  process?: FunnelProcessRunner;
+  clock?: FunnelClock;
+  logger?: FunnelLogger;
+  selfPid?: number;
+  killCompetingSlack?: boolean; /** Bearer token required for `/listeners*`, `/status`, and `/ws`. Empty string disables auth (tests only). */
+  token?: string;
+};
+type WsData = {
+  /** Stable channel id (uuid) the client subscribed to. "" for tap-all clients. */channel: string; /** Resolved channel name (for log readability). null for tap-all or unknown. */
+  channelName: string | null; /** Connector names belonging to that channel; used by tap-all replay filtering. */
+  connectors: string[];
+  tapAll?: boolean; /** Routing mode for this channel; resolved at upgrade time from settings. */
+  delivery: "fanout" | "exclusive"; /** Replay any events with offset strictly greater than this on open, then resume the live stream. */
+  since?: number;
+};
+/**
+ * In-process gateway: runs `Bun.serve` (HTTP + WebSocket /ws), boots connector
+ * listeners through `FunnelListenerSupervisor`, fans events out via
+ * `FunnelBroadcaster`, and persists them via `FunnelEventStore` (SQLite).
+ * System events (gateway lifecycle, connect/disconnect) flow to `FunnelLogger`
+ * instead — keeping the SQLite seq space exclusive to broadcaster traffic so
+ * the broadcaster's offset counter and `getMaxSeq()` stay aligned without
+ * per-event coordination. Exposes `/listeners` HTTP for runtime
+ * start/stop/restart of individual connectors.
+ */
+declare class FunnelGatewayServer {
+  private readonly channels;
+  private readonly settings;
+  private readonly port;
+  private readonly logDir;
+  private readonly process?;
+  private readonly logger;
+  private readonly selfPid;
+  private readonly killCompetingSlack;
+  private readonly token;
+  private readonly broadcaster;
+  private readonly eventStore;
+  private readonly supervisor;
+  private readonly nowMs;
+  private startedAt;
+  private server;
+  constructor(deps: Deps$3);
+  start(): Promise<Server<WsData>>;
+  stop(): Promise<void>;
+  getStatus(): {
+    clients: number;
+    channels: {
+      channel: string;
+      connectors: string[];
+    }[];
+  };
+  getBroadcaster(): FunnelBroadcaster;
+  getSupervisor(): FunnelListenerSupervisor;
+  getEventStore(): FunnelEventStore;
+  private handleFetch;
+  private handleWsOpen;
+  private handleWsClose;
+  private logServerStarted;
+  private buildApp;
+  /**
+   * Reads the bearer token from the WebSocket upgrade request. Accepts:
+   *   - `Sec-WebSocket-Protocol: funnel.token.<value>` (preferred — header, never logged in URLs)
+   *   - `Authorization: Bearer <value>` (also header-based)
+   * Returns true on a constant-time match against the daemon token.
+   */
+  private tokenMatchesUpgrade;
+  private resolveChannel;
+  private bootListeners;
+  /**
+   * Broadcast `content` to subscribers of `channel`, persisting the event in
+   * the SQLite store and stamping `meta.channel{,Id}` / `meta.connector{,Id}`
+   * when they resolve. Used by both the connector-listener path (via the
+   * supervisor's `notify` callback) and the public `/channels/:channel/publish`
+   * route. Returns the assigned event offset.
+   */
+  emit(input: {
+    channel: string;
+    connector?: string;
+    content: string;
+    meta?: Record<string, string>;
+  }): {
+    offset: number;
+  };
+  private lookupChannelId;
+  private lookupConnectorId;
+}
+//#endregion
+//#region lib/gateway/gateway-token.d.ts
+type Deps$2 = {
+  fs?: FunnelFileSystem;
+  dir?: string;
+  generate?: () => string;
+};
+/**
+ * Reads / generates the gateway daemon token used to authenticate
+ * `/listeners*`, `/status`, and `/ws` connections.
+ *
+ * Token file: `<dir>/gateway.token` (default `~/.funnel/gateway.token`),
+ * written with mode 0600. Clients on the same machine as the daemon read
+ * the file directly; the token never leaves the user's home directory.
+ */
+declare class FunnelGatewayToken {
+  private readonly fs;
+  private readonly path;
+  private readonly generate;
+  constructor(deps?: Deps$2);
+  read(): string | null;
+  /**
+   * Returns the existing token or, if missing, generates one and writes it with mode 0600.
+   *
+   * NOTE: not atomic — two concurrent `ensure()` calls (e.g., `fnl gateway start` racing
+   * itself before the PID lock is acquired) could each generate independent tokens. The
+   * gateway PID file makes this practically a non-issue; if you need stronger guarantees,
+   * take a file lock around this call externally.
+   */
+  ensure(): string;
+  getPath(): string;
+}
+declare const DEFAULT_GATEWAY_TOKEN_PATH: string;
+//#endregion
+//#region lib/gateway/listeners-client.d.ts
+type Deps$1 = {
+  port: number;
+  isDaemonRunning: () => boolean; /** Returns the daemon's gateway token, or null if unavailable. Sent as `Authorization: Bearer`. */
+  getToken?: () => string | null;
+};
+declare const listenerEntrySchema: z.ZodObject<{
+  channelName: z.ZodString;
+  channelId: z.ZodString;
+  name: z.ZodString;
+  type: z.ZodString;
+  alive: z.ZodBoolean;
+}, z.core.$strip>;
+type ListenerEntry = z.infer<typeof listenerEntrySchema>;
+type ListenerOpResult = {
+  state: "ok";
+} | {
+  state: "offline";
+} | {
+  state: "error";
+  reason: string;
+};
+type ListListenersResult = {
+  state: "ok";
+  listeners: ListenerEntry[];
+} | {
+  state: "offline";
+} | {
+  state: "error";
+  reason: string;
+};
+/**
+ * HTTP client for listener operations on a running gateway daemon.
+ *
+ * Returns `{ state: "offline" }` when the daemon isn't running so callers
+ * (CLI hot-reload paths) can treat that as a no-op without parsing strings.
+ * Pair this with `FunnelGateway` (process control) for the full picture.
+ */
+declare class FunnelListenersClient {
+  private readonly port;
+  private readonly isDaemonRunning;
+  private readonly getToken;
+  constructor(deps: Deps$1);
+  list(): Promise<ListListenersResult>;
+  start(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+  stop(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+  restart(channelName: string, connectorName: string): Promise<ListenerOpResult>;
+  private path;
+  private authHeaders;
+  private call;
+}
+//#endregion
+//#region lib/funnel.d.ts
+type Props$4 = {
+  /** Settings persistence (channels with nested connectors / profiles). Defaults to a FunnelSettingsStore rooted at `dir`. */store?: FunnelSettingsReader; /** Filesystem boundary. Replace with MemoryFunnelFileSystem to sandbox all disk I/O. */
+  fs?: FunnelFileSystem; /** Process runner used by gateway / claude / gh listener. Replace with MemoryFunnelProcessRunner for tests. */
+  process?: FunnelProcessRunner; /** Logger flowed into every facet. Replace with MemoryFunnelLogger or NoopFunnelLogger to silence/inspect. */
+  logger?: FunnelLogger; /** Clock used by schedule listener, gh poll watermarks, and gateway timeouts. */
+  clock?: FunnelClock; /** ID generator for channel and connector ids. Use MemoryFunnelIdGenerator for deterministic tests. */
+  idGenerator?: FunnelIdGenerator; /** Funnel home directory (settings.json + per-channel/per-connector dirs). Defaults to ~/.funnel. */
+  dir?: string; /** Temp / runtime directory (gateway logs and PID adjacent files). Defaults to /tmp/funnel. */
+  tmpDir?: string;
+};
+/**
+ * Facade exposing every funnel facet as a getter.
+ *
+ * The same `Funnel` is used by the CLI, the TUI, and as a programmable library.
+ * All side-effecting boundaries (filesystem, process, logger, clock, id, paths) are
+ * injectable via `Props` — passing memory implementations gives a fully sandboxed
+ * Funnel that touches no real disk, processes, or wall-clock time.
+ *
+ * Connectors live nested inside their owning channel (channels[].connectors[]),
+ * so connector CRUD is reached via `funnel.channels.addConnector(...)` etc.
+ *
+ * @example
+ * ```ts
+ * const funnel = new Funnel({})
+ * const channel = funnel.channels.add({ name: "inbox" })
+ * funnel.channels.addConnector("inbox", { type: "slack", name: "ops", botToken, appToken })
+ * await funnel.gatewayServer({ port: 9742 }).start()
+ * ```
+ */
+declare class Funnel {
+  private readonly props;
+  private readonly cache;
+  constructor(props?: Props$4);
+  /**
+   * Sandboxed Funnel wired with in-memory implementations for every IO boundary.
+   * Touches no real disk, processes, wall-clock time, or UUIDs — safe for tests
+   * and ad-hoc experiments. Override individual fields by passing them in `props`.
+   */
+  static inMemory(props?: Props$4): Funnel;
+  private memo;
+  /** Resolved on-disk paths the facade will read/write when methods are called. Pure compute, not memoized. */
+  get paths(): {
+    dir: string;
+    tmpDir: string;
+    settings: string;
+  };
+  /** Filesystem boundary. Defaults to NodeFunnelFileSystem. */
+  get fs(): FunnelFileSystem;
+  /** Process runner boundary. Defaults to NodeFunnelProcessRunner. */
+  get process(): FunnelProcessRunner;
+  /** Logger boundary. Defaults to NodeFunnelLogger. */
+  get logger(): FunnelLogger;
+  /** Clock boundary. Defaults to NodeFunnelClock. */
+  get clock(): FunnelClock;
+  /** ID generator boundary. Defaults to NodeFunnelIdGenerator. */
+  get idGenerator(): FunnelIdGenerator;
+  /** Settings reader. If not injected, a FunnelSettingsStore rooted at `dir` is created. */
+  get store(): FunnelSettingsReader;
+  /** Pure factory that constructs per-type listeners and adapters from connector configs. */
+  get factory(): FunnelConnectorFactory;
+  /** Channel CRUD + nested connector CRUD + schedule entries + listener/adapter dispatch. */
+  get channels(): FunnelChannels;
+  /** Launch profiles (named presets for `fnl claude`: path + sub-agent + channel id). */
+  get profiles(): FunnelProfiles;
+  /** funnel MCP installer (writes/removes `.mcp.json` entries in target repos). */
+  get mcp(): FunnelMcp;
+  /** Launch Claude Code with a channel injected via env, MCP installed, gateway ensured. */
+  get claude(): FunnelClaude;
+  /** Gateway daemon controller (PID-file, start/stop the separate `bun daemon.ts` process). */
+  get gateway(): FunnelGateway;
+  /** Read / generate the daemon's gateway token (mode 0600 file under `dir`). */
+  get gatewayToken(): FunnelGatewayToken;
+  /**
+   * HTTP client for `POST /channels/:channel/publish` on the running gateway
+   * daemon. Use it to push arbitrary content into a channel from outside any
+   * connector. Returns `{ state: "offline" }` if the daemon isn't up.
+   */
+  get publisher(): FunnelChannelPublisher;
+  /**
+   * HTTP client for listener operations on the running gateway daemon.
+   * Returns `{ state: "offline" }` when the daemon is offline so hot-reload
+   * paths stay write-only without parsing strings.
+   */
+  get listeners(): FunnelListenersClient;
+  /**
+   * In-process gateway server. Unlike `gateway.start()` (which spawns a daemon),
+   * this returns a class that runs `Bun.serve` + listeners inside the current process —
+   * useful for tests, embedding, or custom hosts.
+   */
+  gatewayServer(options?: {
+    port?: number;
+    logDir?: string;
+    killCompetingSlack?: boolean; /** Override the auth token. Defaults to the persisted gateway.token. Pass "" to disable auth (tests). */
+    token?: string;
+  }): FunnelGatewayServer;
+}
+//#endregion
+//#region lib/engine/mcp/channel-server.d.ts
+type ChannelServerOptions = {
+  /** Funnel home directory (settings.json + gateway.token). Defaults to ~/.funnel. */dir?: string; /** Gateway base URL. Defaults to `$FUNNEL_GATEWAY_URL` or `http://localhost:9742`. */
+  gatewayUrl?: string; /** Channel id to subscribe to. Defaults to `$FUNNEL_CHANNEL_ID`. */
+  channelId?: string; /** Auth token. Defaults to `$FUNNEL_GATEWAY_TOKEN` then `<dir>/gateway.token`. */
+  token?: string;
+};
+declare const startChannelServer: (options?: ChannelServerOptions) => Promise<void>;
+//#endregion
+//#region lib/engine/settings/settings-store.d.ts
+declare const FUNNEL_DIR: string;
+declare const SETTINGS_PATH: string;
+type Deps = {
+  path?: string;
+  fs?: FunnelFileSystem;
+};
+declare class FunnelSettingsStore extends FunnelSettingsReader {
+  private readonly path;
+  private readonly fs;
+  constructor(deps?: Deps);
+  read(): Settings;
+  private looksLikeLegacy;
+  write(settings: Settings): void;
+}
+//#endregion
+//#region lib/engine/settings/mock-settings-reader.d.ts
+declare const createSettings: (partial?: Partial<Settings>) => Settings;
+declare class MockFunnelSettingsReader extends FunnelSettingsReader {
+  private state;
+  constructor(initial?: Partial<Settings>);
+  read(): Settings;
+  write(settings: Settings): void;
+}
+//#endregion
+//#region lib/engine/fs/node-file-system.d.ts
+declare class NodeFunnelFileSystem extends FunnelFileSystem {
+  constructor();
+  existsSync(path: string): boolean;
+  readFileSync(path: string): string;
+  writeFileSync(path: string, data: string): void;
+  writeSecretFileSync(path: string, data: string): void;
+  appendFileSync(path: string, data: string): void;
+  unlink(path: string): void;
+  mkdirSync(path: string, options?: {
+    recursive?: boolean;
+  }): void;
+  readdirSync(path: string): string[];
+  statSync(path: string): FileStat;
+}
+//#endregion
+//#region lib/engine/fs/memory-file-system.d.ts
+type Props$3 = {
+  dirs?: string[];
+  files?: Record<string, string>;
+  mtimes?: Record<string, number>;
+  modes?: Record<string, number>;
+  now?: () => number;
+};
+declare class MemoryFunnelFileSystem extends FunnelFileSystem {
+  private readonly dirs;
+  private readonly files;
+  private readonly mtimes;
+  private readonly modes;
+  private readonly now;
+  constructor(props?: Props$3);
+  existsSync(path: string): boolean;
+  readFileSync(path: string): string;
+  writeFileSync(path: string, data: string): void;
+  writeSecretFileSync(path: string, data: string): void;
+  appendFileSync(path: string, data: string): void;
+  unlink(path: string): void;
+  mkdirSync(path: string, options?: {
+    recursive?: boolean;
+  }): void;
+  readdirSync(path: string): string[];
+  statSync(path: string): FileStat;
+  setMtime(path: string, mtimeMs: number): void;
+  setMode(path: string, mode: number): void;
+  private touch;
+}
+//#endregion
+//#region lib/engine/process/node-process-runner.d.ts
+declare class NodeFunnelProcessRunner extends FunnelProcessRunner {
+  constructor();
+  runSync(command: string[]): RunResult;
+  run(command: string[], options?: RunOptions): Promise<RunResult>;
+  attach(command: string[], options?: AttachOptions): Promise<number>;
+  detach(command: string[], options?: DetachOptions): void;
+  kill(pid: number, signal?: string): void;
+}
+//#endregion
+//#region lib/engine/process/memory-process-runner.d.ts
+type MemoryProcessResponse = {
+  exitCode?: number;
+  stdout?: string;
+  stderr?: string;
+};
+type MemoryProcessHandler = (command: string[]) => MemoryProcessResponse | Promise<MemoryProcessResponse>;
+type MemoryProcessSyncHandler = (command: string[]) => MemoryProcessResponse;
+type MemoryProcessCall = {
+  kind: "run";
+  command: string[];
+  options: RunOptions;
+} | {
+  kind: "runSync";
+  command: string[];
+} | {
+  kind: "attach";
+  command: string[];
+  options: AttachOptions;
+} | {
+  kind: "detach";
+  command: string[];
+  options: DetachOptions;
+} | {
+  kind: "kill";
+  command: string[];
+};
+declare class MemoryFunnelProcessRunner extends FunnelProcessRunner {
+  readonly calls: MemoryProcessCall[];
+  readonly killed: {
+    pid: number;
+    signal: string;
+  }[];
+  private handler;
+  private syncHandler;
+  on(handler: MemoryProcessHandler): this;
+  onSync(handler: MemoryProcessSyncHandler): this;
+  run(command: string[], options?: RunOptions): Promise<RunResult>;
+  runSync(command: string[]): RunResult;
+  attach(command: string[], options?: AttachOptions): Promise<number>;
+  detach(command: string[], options?: DetachOptions): void;
+  kill(pid: number, signal?: string): void;
+}
+//#endregion
+//#region lib/engine/logger/node-logger.d.ts
+type Props$2 = {
+  file?: string;
+  now?: () => Date;
+};
+declare class NodeFunnelLogger extends FunnelLogger {
+  readonly file: string;
+  private readonly now;
+  constructor(props?: Props$2);
+  info(message: string, meta?: Record<string, unknown>): void;
+  warn(message: string, meta?: Record<string, unknown>): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+  private write;
+}
+//#endregion
+//#region lib/engine/logger/memory-logger.d.ts
+type LogEntry = {
+  level: "info" | "warn" | "error";
+  message: string;
+  meta?: Record<string, unknown>;
+};
+declare class MemoryFunnelLogger extends FunnelLogger {
+  readonly file: null;
+  readonly entries: LogEntry[];
+  info(message: string, meta?: Record<string, unknown>): void;
+  warn(message: string, meta?: Record<string, unknown>): void;
+  error(message: string, meta?: Record<string, unknown>): void;
+  clear(): void;
+}
+//#endregion
+//#region lib/engine/logger/noop-logger.d.ts
+declare class NoopFunnelLogger extends FunnelLogger {
+  readonly file: null;
+  info(): void;
+  warn(): void;
+  error(): void;
+}
+//#endregion
+//#region lib/engine/time/node-clock.d.ts
+declare class NodeFunnelClock extends FunnelClock {
+  now(): Date;
+}
+//#endregion
+//#region lib/engine/time/memory-clock.d.ts
+type Props$1 = {
+  start?: Date;
+};
+declare class MemoryFunnelClock extends FunnelClock {
+  private current;
+  constructor(props?: Props$1);
+  now(): Date;
+  set(date: Date): void;
+  advance(ms: number): void;
+}
+//#endregion
+//#region lib/engine/id/node-id-generator.d.ts
+declare class NodeFunnelIdGenerator extends FunnelIdGenerator {
+  generate(): string;
+}
+//#endregion
+//#region lib/engine/id/memory-id-generator.d.ts
+type Props = {
+  prefix?: string;
+};
+declare class MemoryFunnelIdGenerator extends FunnelIdGenerator {
+  private counter;
+  private readonly prefix;
+  constructor(props?: Props);
+  generate(): string;
+}
+//#endregion
+//#region lib/cli/factory.d.ts
+type Env = {
+  Variables: {
+    funnel: Funnel;
+  };
+};
+declare const factory: _$hono_factory0.Factory<Env, string>;
+//#endregion
+//#region lib/cli/router/to-request.d.ts
+declare const toRequest: (args: string[]) => {
+  method: string;
+  path: string;
+  url: string;
+};
+//#endregion
+//#region lib/cli/router/query-to-cli-args.d.ts
+declare const queryToCliArgs: (url: string, reservedKeys?: string[]) => string[];
+//#endregion
+//#region lib/cli/routes/index.d.ts
+/**
+ * Build the CLI Hono app wired to a specific Funnel instance.
+ * Exposed so library consumers can mount the same routes their `fnl` CLI
+ * uses against a custom Funnel (e.g. one with sandboxed boundaries).
+ *
+ * All CLI verbs (`add` / `remove` / `set` / `rename` / `as-default` / `request`) map to POST in
+ * to-request.ts and stay in the URL as a literal segment. Read paths (list / show / launch) keep GET.
+ * Help shortcuts at parameterless URLs return the help text directly so `funnel <verb>` (no args) is
+ * informative instead of 404.
+ */
+declare const createCliApp: (funnel: Funnel) => _$hono_hono_base0.HonoBase<Env, {
+  "/claude": {
+    $get: {
+      input: {
+        query: {
+          [x: string]: string | string[];
+          profile?: string | undefined;
+          channel?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          [x: string]: string | string[];
+          profile?: string | undefined;
+          channel?: string | undefined;
+        };
+      };
+      output: "funnel claude — launch Claude Code\n\nusage:\n  funnel claude                          launch the default profile (first in the list)\n  funnel claude -p <name>                launch a named profile\n  funnel claude --profile <name>         (long form)\n  funnel claude --channel <name>         raw launch (no profile, cwd = current dir)\n\noptions:\n  -p, --profile      profile name to launch\n  --channel          channel name (raw launch, ignored when --profile is given)\n\nAny other arguments are forwarded to the claude CLI.\nOn launch the FUNNEL_CHANNEL_ID env var is set and MCP connects to the gateway.";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/add": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/add/:channel": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          delivery?: "fanout" | "exclusive" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          delivery?: "fanout" | "exclusive" | undefined;
+        };
+      };
+      output: `added channel "${string}" (id: ${string})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/remove": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/remove/:channel": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `removed channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/rename/:channel/:newName": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed channel "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/rename/:newName": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed channel "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/rename": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/set/delivery/:mode": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          mode: "fanout" | "exclusive";
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          mode: "fanout" | "exclusive";
+        };
+      };
+      output: `channel "${string}" delivery set to fanout` | `channel "${string}" delivery set to exclusive`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/publish": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/publish": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          content: string | string[];
+          connector?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          content: string | string[];
+          connector?: string | undefined;
+        };
+      };
+      output: `published (offset=${number})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/add": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/add/:connector": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: `added slack connector "${string}" to channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: `added gh connector "${string}" to channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: `added discord connector "${string}" to channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: `added schedule connector "${string}" to channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/remove": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/remove/:connector": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `removed connector "${string}" from channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/set": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/set/:connector": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          "bot-token"?: string | undefined;
+          "app-token"?: string | undefined;
+          "poll-interval"?: string | string[] | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          "bot-token"?: string | undefined;
+          "app-token"?: string | undefined;
+          "poll-interval"?: string | string[] | undefined;
+        };
+      };
+      output: `updated connector "${string}" in channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/rename/:connector/:newName": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed connector "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/rename/:newName": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed connector "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/request": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          method: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/add": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/add/:id": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          id: string;
+        };
+      } & {
+        query: {
+          cron: string | string[];
+          prompt: string | string[];
+          enabled?: string | string[] | undefined;
+          "catchup-policy"?: "latest" | "all" | "skip" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          id: string;
+        };
+      } & {
+        query: {
+          cron: string | string[];
+          prompt: string | string[];
+          enabled?: string | string[] | undefined;
+          "catchup-policy"?: "latest" | "all" | "skip" | undefined;
+        };
+      };
+      output: `added schedule entry "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/remove": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/remove/:id": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          id: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          id: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `removed schedule entry "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/add": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/add/:profile": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path: string | string[];
+          "sub-agent": string | string[];
+          channel: string | string[];
+          brief?: string | string[] | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path: string | string[];
+          "sub-agent": string | string[];
+          channel: string | string[];
+          brief?: string | string[] | undefined;
+        };
+      };
+      output: `added profile "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/set": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/set/:profile": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path?: string | undefined;
+          "sub-agent"?: string | undefined;
+          channel?: string | undefined;
+          brief?: string | string[] | undefined;
+          "no-brief"?: string | string[] | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path?: string | undefined;
+          "sub-agent"?: string | undefined;
+          channel?: string | undefined;
+          brief?: string | string[] | undefined;
+          "no-brief"?: string | string[] | undefined;
+        };
+      };
+      output: `updated profile "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/remove": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/remove/:profile": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `removed profile "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/rename/:profile/:newName": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed profile "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/rename/:newName": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed profile "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/rename": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/rename": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/as-default": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `profile "${string}" is now the default`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/run": {
+    $get: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile": {
+    $get: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/gateway": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      output: "funnel gateway: running (pid null) — health check failed" | `funnel gateway: running (pid ${number}) \u2014 health check failed`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      output: `funnel gateway: running (pid null)
+  port: ${number}
+  clients: ${string}` | `funnel gateway: running (pid ${number})
+  port: ${number}
+  clients: ${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/status": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      output: "funnel gateway: running (pid null) — health check failed" | `funnel gateway: running (pid ${number}) \u2014 health check failed`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      output: `funnel gateway: running (pid null)
+  port: ${number}
+  clients: ${string}` | `funnel gateway: running (pid ${number})
+  port: ${number}
+  clients: ${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/start": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: "funnel gateway: already running (pid null)" | `funnel gateway: already running (pid ${number})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: "funnel gateway: started";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/stop": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "funnel gateway: no running process";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "funnel gateway: stopped";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/restart": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/run": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/gateway/logs": {
+    $get: {
+      input: {
+        query: {
+          n?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          n?: string | undefined;
+        };
+      };
+      output: "no logs";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/listeners": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "funnel gateway: no running listeners";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: `funnel gateway: running listeners
+${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/status": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/update": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "updated @interactive-inc/claude-funnel";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+}, "/", "/update">;
+/** CLI Hono app wired to a default `new Funnel()`. For embedding with a custom Funnel use `createCliApp`. */
+declare const app: _$hono_hono_base0.HonoBase<Env, {
+  "/claude": {
+    $get: {
+      input: {
+        query: {
+          [x: string]: string | string[];
+          profile?: string | undefined;
+          channel?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          [x: string]: string | string[];
+          profile?: string | undefined;
+          channel?: string | undefined;
+        };
+      };
+      output: "funnel claude — launch Claude Code\n\nusage:\n  funnel claude                          launch the default profile (first in the list)\n  funnel claude -p <name>                launch a named profile\n  funnel claude --profile <name>         (long form)\n  funnel claude --channel <name>         raw launch (no profile, cwd = current dir)\n\noptions:\n  -p, --profile      profile name to launch\n  --channel          channel name (raw launch, ignored when --profile is given)\n\nAny other arguments are forwarded to the claude CLI.\nOn launch the FUNNEL_CHANNEL_ID env var is set and MCP connects to the gateway.";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/add": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/add/:channel": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          delivery?: "fanout" | "exclusive" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          delivery?: "fanout" | "exclusive" | undefined;
+        };
+      };
+      output: `added channel "${string}" (id: ${string})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/remove": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/remove/:channel": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `removed channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/rename/:channel/:newName": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed channel "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/rename/:newName": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed channel "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/rename": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/set/delivery/:mode": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          mode: "fanout" | "exclusive";
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          mode: "fanout" | "exclusive";
+        };
+      };
+      output: `channel "${string}" delivery set to fanout` | `channel "${string}" delivery set to exclusive`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/publish": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/publish": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          content: string | string[];
+          connector?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          content: string | string[];
+          connector?: string | undefined;
+        };
+      };
+      output: `published (offset=${number})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/add": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/add/:connector": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: `added slack connector "${string}" to channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: `added gh connector "${string}" to channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: `added discord connector "${string}" to channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          type: string | string[];
+          "bot-token": string | string[];
+          "app-token": string | string[];
+        } | {
+          type: string | string[];
+          "poll-interval"?: string | string[] | undefined;
+        } | {
+          type: string | string[];
+          "bot-token": string | string[];
+        } | {
+          type: string | string[];
+        };
+      };
+      output: `added schedule connector "${string}" to channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/remove": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/remove/:connector": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `removed connector "${string}" from channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/set": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/set/:connector": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          "bot-token"?: string | undefined;
+          "app-token"?: string | undefined;
+          "poll-interval"?: string | string[] | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          "bot-token"?: string | undefined;
+          "app-token"?: string | undefined;
+          "poll-interval"?: string | string[] | undefined;
+        };
+      };
+      output: `updated connector "${string}" in channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/rename/:connector/:newName": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed connector "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/rename/:newName": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed connector "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/request": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+          method: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/add": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/add/:id": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          id: string;
+        };
+      } & {
+        query: {
+          cron: string | string[];
+          prompt: string | string[];
+          enabled?: string | string[] | undefined;
+          "catchup-policy"?: "latest" | "all" | "skip" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          id: string;
+        };
+      } & {
+        query: {
+          cron: string | string[];
+          prompt: string | string[];
+          enabled?: string | string[] | undefined;
+          "catchup-policy"?: "latest" | "all" | "skip" | undefined;
+        };
+      };
+      output: `added schedule entry "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/remove": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/remove/:id": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          id: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+          id: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `removed schedule entry "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/add": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/add/:profile": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path: string | string[];
+          "sub-agent": string | string[];
+          channel: string | string[];
+          brief?: string | string[] | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path: string | string[];
+          "sub-agent": string | string[];
+          channel: string | string[];
+          brief?: string | string[] | undefined;
+        };
+      };
+      output: `added profile "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/set": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/set/:profile": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path?: string | undefined;
+          "sub-agent"?: string | undefined;
+          channel?: string | undefined;
+          brief?: string | string[] | undefined;
+          "no-brief"?: string | string[] | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path?: string | undefined;
+          "sub-agent"?: string | undefined;
+          channel?: string | undefined;
+          brief?: string | string[] | undefined;
+          "no-brief"?: string | string[] | undefined;
+        };
+      };
+      output: `updated profile "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/remove": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/remove/:profile": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `removed profile "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/rename/:profile/:newName": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed profile "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/rename/:newName": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+          newName: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `renamed profile "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/rename": {
+    $post: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/rename": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/as-default": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: `profile "${string}" is now the default`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/run": {
+    $get: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile": {
+    $get: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          [x: string]: string | string[];
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/gateway": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      output: "funnel gateway: running (pid null) — health check failed" | `funnel gateway: running (pid ${number}) \u2014 health check failed`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      output: `funnel gateway: running (pid null)
+  port: ${number}
+  clients: ${string}` | `funnel gateway: running (pid ${number})
+  port: ${number}
+  clients: ${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/status": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      output: "funnel gateway: running (pid null) — health check failed" | `funnel gateway: running (pid ${number}) \u2014 health check failed`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      output: `funnel gateway: running (pid null)
+  port: ${number}
+  clients: ${string}` | `funnel gateway: running (pid ${number})
+  port: ${number}
+  clients: ${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/start": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: "funnel gateway: already running (pid null)" | `funnel gateway: already running (pid ${number})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: "funnel gateway: started";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/stop": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "funnel gateway: no running process";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "funnel gateway: stopped";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/restart": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/run": {
+    $get: {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: Promise<never>;
+      outputFormat: "json";
+      status: _$hono_utils_http_status0.StatusCode;
+    };
+  };
+} & {
+  "/gateway/logs": {
+    $get: {
+      input: {
+        query: {
+          n?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          n?: string | undefined;
+        };
+      };
+      output: "no logs";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/listeners": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "funnel gateway: no running listeners";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: `funnel gateway: running listeners
+${string}`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/status": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/update": {
+    $get: {
+      input: {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: Record<string, never>;
+      };
+      output: "updated @interactive-inc/claude-funnel";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+}, "/", "/update">;
+//#endregion
+//#region lib/tui/tui.d.ts
+declare function launchTui(funnel: Funnel): Promise<void>;
+//#endregion
+export { AttachOptions, BroadcastEvent, BroadcastSubscriber, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelServerOptions, ConnectorConfig, ConnectorType, DEFAULT_GATEWAY_TOKEN_PATH, DetachOptions, DiscordConnectorConfig, Env, FUNNEL_DIR, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, FileStat, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelEvent, FunnelEventStore, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, GhConnectorConfig, LaunchOptions, ListListenersResult, ListenerEntry, ListenerOpResult, LogEntry, MemoryFunnelClock, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NoopFunnelLogger, NotifyFn, ProfileConfig, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, ScheduleCatchupPolicy, type ScheduleConnectorConfig, ScheduleEntry, Settings, SlackConnectorConfig, channelConfigSchema, channelDeliveryModeSchema, app as cliApp, connectorConfigSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, ghConnectorSchema, launchTui, profileConfigSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };