@interactive-inc/claude-funnel 0.59.1 → 0.60.1

package/dist/index.d.ts

@@ -1,17 +1,1558 @@
-import { a as Settings, c as profileConfigSchema, i as SETTINGS_VERSION, l as settingsSchema, n as ChannelDeliveryMode, o as channelConfigSchema, r as ProfileConfig, s as channelDeliveryModeSchema, t as ChannelConfig } from "./settings-schema-1hh11jnN.js";
-import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-DPwqOVUm.js";
-import { S as FunnelLogger, _ as connectorConnectionEventSchema, a as ConnectorConnectionStatus, b as FunnelConnectorListener, c as ConnectorProcessedQuery, d as ConnectorRawEvent, f as ConnectorRawQuery, g as StoredRawEvent, h as StoredProcessedEvent, i as ConnectorConnectionRecord, l as ConnectorProcessedRecord, m as StoredConnectionEvent, n as ConnectorConnectionEvent, o as ConnectorDiagnosticLog, p as ConnectorRawRecord, r as ConnectorConnectionQuery, s as ConnectorProcessedEvent, t as CONNECTOR_CONNECTION_STATUSES, u as ConnectorQuery, v as connectorProcessedEventSchema, x as NotifyFn, y as connectorRawEventSchema } from "./diagnostic-log-Cb3v8P7p.js";
-import { a as RunOptions, i as ProcessSnapshot, n as DetachOptions, o as RunResult, r as FunnelProcessRunner, t as AttachOptions } from "./process-runner-DIm1cy95.js";
-import { n as FunnelFileSystem, t as FileStat } from "./file-system-DxpnnUVb.js";
-import { a as ChannelConnectorView, c as FunnelConnectorFactory, d as ConnectorConfig, f as ConnectorType, l as ScheduleListenerOptions, o as FunnelChannels, p as connectorConfigSchema, s as FunnelClock, u as SlackListenerOptions } from "./local-config-sync-BGPAS9Be.js";
-import { n as FunnelConnectorAdapter, r as JsonValue, t as CallInput } from "./connector-adapter-DGacCppE.js";
-import { a as ScheduleEntry, c as scheduleEntrySchema, i as ScheduleConnectorConfig, o as scheduleCatchupPolicySchema, r as ScheduleCatchupPolicy, s as scheduleConnectorSchema } from "./schedule-listener-DoMPjHZj.js";
-import { a as slackConnectorSchema, c as SlackProcessedEmit, d as SlackSkipReason, i as SlackConnectorConfig, l as SlackProcessedSkip, o as FunnelSlackEventProcessor, s as SlackProcessed, u as SlackRawEvent } from "./slack-listener-Dj9NFbAJ.js";
-import { a as DiagnosticsGatewayProbe, c as FunnelDiagnostics, d as DiagnosticEvent, f as previewOf, g as ConnectorDiagnosticSqlReader, h as toDiagnosticEvent, i as DiagnosticsChannelSource, l as ReplayResult, m as toDiagnosticConnectionError, n as DiagnoseAllReport, o as DiagnosticsPublisher, p as queryRows, r as DiagnosisStatus, s as DiagnosticsTokenReader, t as ChannelDiagnosis, u as DiagnosticConnectionError } from "./funnel-diagnostics-K-wON25Y.js";
-import { n as FunnelDocs, t as DocsTopicListing } from "./funnel-docs-DYBs1-H_.js";
-import { a as RecoveryListenerControl, i as RecoveryGatewayControl, n as RecoveryAction, o as RecoveryResult, r as RecoveryChannelSource, t as FunnelRecovery } from "./funnel-recovery-COExL9MD.js";
-import { n as DoctorReport, r as FunnelDoctor, t as DoctorFixMode } from "./funnel-doctor-vxO96TCA.js";
-import { a as HttpResponse, i as HttpRequest, n as discordConnectorSchema, r as FunnelHttpClient, t as DiscordConnectorConfig } from "./discord-connector-schema-CQyfDkLD.js";
-import { n as ghConnectorSchema, t as GhConnectorConfig } from "./gh-connector-schema-CZzwzvqY.js";
-import { $ as PublishResponse, A as MemoryFunnelFileSystem, B as Funnel, C as MemoryProcessCall, Ct as OnFunnelError, D as ProcessListStub, E as MemoryProcessSyncHandler, F as FUNNEL_DIR, G as ListenerOpResult, H as FunnelListenersClient, I as FunnelSettingsStore, J as SqliteConnectorDiagnosticLog, K as FunnelGateway, L as SETTINGS_PATH, M as MockFunnelSettingsReader, N as createSettings, O as StartTimeStub, P as DEFAULT_GATEWAY_PORT, Q as PublishRequest, R as resolveFunnelDir, S as MemoryFunnelProcessRunner, St as ReplayableEvent, T as MemoryProcessResponse, U as ListListenersResult, V as GatewayServerOptions, W as ListenerEntry, X as SqliteFunnelEventLog, Y as MemoryFunnelEventLog, Z as FunnelChannelPublisher, _ as NoopFunnelLogger, _t as GatewayRouteDeps, a as toRequest, at as gatewayLoopbackUrl, b as NodeFunnelLogger, bt as BroadcastSubscriber, c as buildServiceRoutes, ct as channelWsUrl, d as MemoryHttpResponse, dt as FunnelEvent, et as PublishResult, f as NodeFunnelHttpClient, ft as FunnelEventLog, g as NodeFunnelClock, gt as GatewayEmitInput, h as MemoryFunnelClock, ht as Env$1, i as queryToCliArgs, it as FunnelGatewayToken, j as NodeFunnelFileSystem, k as NodeFunnelProcessRunner, l as MemoryFunnelHttpClient, lt as FunnelGatewayServer, m as NodeFunnelIdGenerator, mt as funnelEventSchema, n as CliApp, nt as publishResponseSchema, o as Env, ot as ChannelWsUrlInput, p as MemoryFunnelIdGenerator, pt as FunnelEventRecord, q as MemoryConnectorDiagnosticLog, r as routes, rt as DEFAULT_GATEWAY_TOKEN_PATH, s as factory, st as channelWsProtocols, t as GatewayApp, tt as publishRequestSchema, u as MemoryHttpHandler, ut as GatewayEventStore, v as LogEntry, vt as FunnelListenerSupervisor, w as MemoryProcessHandler, x as AliveStub, xt as FunnelBroadcaster, y as MemoryFunnelLogger, yt as BroadcastEvent, z as resolveFunnelPort } from "./index-D7mjirUL.js";
-export { AliveStub, AttachOptions, BroadcastEvent, BroadcastSubscriber, CONNECTOR_CONNECTION_STATUSES, CallInput, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelDiagnosis, ChannelWsUrlInput, CliApp, ConnectorConfig, ConnectorConnectionEvent, ConnectorConnectionQuery, ConnectorConnectionRecord, ConnectorConnectionStatus, ConnectorDiagnosticLog, ConnectorDiagnosticSqlReader, ConnectorProcessedEvent, ConnectorProcessedQuery, ConnectorProcessedRecord, ConnectorQuery, ConnectorRawEvent, ConnectorRawQuery, ConnectorRawRecord, ConnectorType, DEFAULT_GATEWAY_PORT, DEFAULT_GATEWAY_TOKEN_PATH, DetachOptions, DiagnoseAllReport, DiagnosisStatus, DiagnosticConnectionError, DiagnosticEvent, DiagnosticsChannelSource, DiagnosticsGatewayProbe, DiagnosticsPublisher, DiagnosticsTokenReader, DiscordConnectorConfig, DocsTopicListing, DoctorFixMode, DoctorReport, Env, FUNNEL_DIR, FileStat, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClock, FunnelConnectorAdapter, FunnelConnectorFactory, FunnelConnectorListener, FunnelDiagnostics, FunnelDocs, FunnelDoctor, FunnelEvent, FunnelEventLog, FunnelEventRecord, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelHttpClient, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLogger, FunnelProcessRunner, FunnelRecovery, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, GatewayApp, GatewayEmitInput, GatewayEventStore, GatewayRouteDeps, Env$1 as GatewayServerEnv, GatewayServerOptions, GhConnectorConfig, HttpRequest, HttpResponse, JsonValue, ListListenersResult, ListenerEntry, ListenerOpResult, LogEntry, MemoryConnectorDiagnosticLog, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelHttpClient, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryHttpHandler, MemoryHttpResponse, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelHttpClient, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NoopFunnelLogger, NotifyFn, OnFunnelError, ProcessListStub, ProcessSnapshot, ProfileConfig, PublishRequest, PublishResponse, PublishResult, RecoveryAction, RecoveryChannelSource, RecoveryGatewayControl, RecoveryListenerControl, RecoveryResult, ReplayResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleListenerOptions, Settings, SlackConnectorConfig, SlackListenerOptions, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SlackSkipReason, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, StartTimeStub, StoredConnectionEvent, StoredProcessedEvent, StoredRawEvent, buildServiceRoutes, channelConfigSchema, channelDeliveryModeSchema, channelWsProtocols, channelWsUrl, routes as cliRoutes, connectorConfigSchema, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, createSettings, discordConnectorSchema, factory, funnelEventSchema, gatewayLoopbackUrl, ghConnectorSchema, previewOf, profileConfigSchema, publishRequestSchema, publishResponseSchema, queryRows, queryToCliArgs, resolveFunnelDir, resolveFunnelPort, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, toDiagnosticConnectionError, toDiagnosticEvent, toRequest };
+import { a as Settings, c as profileConfigSchema, i as SETTINGS_VERSION, l as settingsSchema, n as ChannelDeliveryMode, o as channelConfigSchema, r as ProfileConfig, s as channelDeliveryModeSchema, t as ChannelConfig } from "./settings-schema-D1xcOqRu.js";
+import { n as FunnelClaude, t as FileProcessGuard } from "./file-process-guard-C_PLxfUX.js";
+import { n as FunnelIdGenerator, t as FunnelSettingsReader } from "./settings-reader-BIFB_j2f.js";
+import { A as FunnelConnectorAdapter, B as FunnelLogger, C as StoredRawEvent, D as FunnelConnectorListener, E as connectorRawEventSchema, F as DetachOptions, I as FunnelProcessRunner, L as ProcessSnapshot, M as BaseConnectorConfig, N as baseConnectorConfigSchema, O as NotifyFn, P as AttachOptions, R as RunOptions, S as StoredProcessedEvent, T as connectorProcessedEventSchema, _ as ConnectorQuery, a as ConnectorOperation, b as ConnectorRawRecord, c as CONNECTOR_CONNECTION_STATUSES, d as ConnectorConnectionRecord, f as ConnectorConnectionStatus, g as ConnectorProcessedRecord, h as ConnectorProcessedQuery, i as ConnectorListenerDeps, j as JsonValue, k as CallInput, l as ConnectorConnectionEvent, m as ConnectorProcessedEvent, n as ConnectorBuildContext, o as ConnectorOperationContext, p as ConnectorDiagnosticLog, r as ConnectorDescriptor, s as ConnectorUpdateContext, t as ConnectorAdapterDeps, u as ConnectorConnectionQuery, v as ConnectorRawEvent, w as connectorConnectionEventSchema, x as StoredConnectionEvent, y as ConnectorRawQuery, z as RunResult } from "./connector-descriptor-6SXJoszo.js";
+import { n as FunnelFileSystem, t as FileStat } from "./file-system-o51IsM0W.js";
+import { t as FunnelProfiles } from "./profiles-Cy5wXQ0L.js";
+import { a as FunnelLocalConfig, i as FunnelTokenPrompter, n as FunnelLocalConfigSync } from "./local-config-sync-Dh1Croqe.js";
+import { a as FunnelConnectorRegistry, i as FunnelClock, n as ChannelConnectorView, r as FunnelChannels, t as AddConnectorInput } from "./channels-2g_BU1N0.js";
+import { a as DiagnosticsGatewayProbe, c as FunnelDiagnostics, d as DiagnosticEvent, f as previewOf, g as ConnectorDiagnosticSqlReader, h as toDiagnosticEvent, i as DiagnosticsChannelSource, l as ReplayResult, m as toDiagnosticConnectionError, n as DiagnoseAllReport, o as DiagnosticsPublisher, p as queryRows, r as DiagnosisStatus, s as DiagnosticsTokenReader, t as ChannelDiagnosis, u as DiagnosticConnectionError } from "./funnel-diagnostics-DpXOsCty.js";
+import { n as FunnelDocs, t as DocsTopicListing } from "./funnel-docs-CNklHvbt.js";
+import { a as RecoveryListenerControl, i as RecoveryGatewayControl, n as RecoveryAction, o as RecoveryResult, r as RecoveryChannelSource, t as FunnelRecovery } from "./funnel-recovery-DnLrdWO9.js";
+import { n as DoctorReport, r as FunnelDoctor, t as DoctorFixMode } from "./funnel-doctor-CZf_0Luq.js";
+import { n as HttpRequest, r as HttpResponse, t as FunnelHttpClient } from "./http-client-oICicjuO.js";
+import { A as FunnelBroadcaster, C as funnelEventSchema, D as FunnelListenerSupervisor, E as GatewayRouteDeps, M as OnFunnelError, O as BroadcastEvent, S as FunnelEventRecord, T as GatewayEmitInput, _ as channelWsUrl, a as SqliteFunnelEventLog, b as FunnelEvent, c as PublishResponse, d as publishResponseSchema, f as DEFAULT_GATEWAY_TOKEN_PATH, g as channelWsProtocols, h as ChannelWsUrlInput, i as MemoryFunnelEventLog, j as ReplayableEvent, k as BroadcastSubscriber, l as PublishResult, m as gatewayLoopbackUrl, n as MemoryConnectorDiagnosticLog, o as FunnelChannelPublisher, p as FunnelGatewayToken, r as SqliteConnectorDiagnosticLog, s as PublishRequest, t as GatewayApp, u as publishRequestSchema, v as FunnelGatewayServer, w as Env$1, x as FunnelEventLog, y as GatewayEventStore } from "./index-CgY8NdMz.js";
+import { hc } from "hono/client";
+import { z } from "zod";
+import * as _$hono_factory0 from "hono/factory";
+import { Hono } from "hono";
+import * as _$hono_utils_http_status0 from "hono/utils/http-status";
+import * as _$hono_hono_base0 from "hono/hono-base";
+
+//#region lib/gateway/gateway.d.ts
+type Deps$3 = {
+  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 dir;
+  private readonly pidFile;
+  private readonly gatewayLog;
+  private readonly tmpDir;
+  private readonly port;
+  private readonly sleep;
+  constructor(deps?: Deps$3);
+  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;
+  }>;
+  getGatewayLog(): string;
+  getPort(): number;
+  private readPid;
+  private removePid;
+  private isProcessAlive;
+}
+//#endregion
+//#region lib/gateway/listeners-client.d.ts
+type Deps$2 = {
+  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$2);
+  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 `<os.tmpdir()>/funnel`. */
+  tmpDir?: string;
+  /**
+   * Connector types this funnel handles, passed as descriptors. Core imports no
+   * connector, so a type's (heavy) listener/adapter code is bundled only when its
+   * descriptor is imported and listed here. Import from the per-type sub-entries:
+   * `import { slackConnector } from "@interactive-inc/claude-funnel/connectors/slack"`.
+   * Type-specific launch hooks (Slack `onAppCreated`/`preprocessEvent`, Schedule
+   * `onFired`) are passed to the descriptor factory, e.g. `slackConnector({ onAppCreated })`.
+   * Defaults to `[]` — no connectors handled.
+   */
+  connectors?: ConnectorDescriptor[];
+  /**
+   * Diagnostic log of inbound connector traffic (raw events before filtering
+   * and the processor's verdict after). Threaded into listeners that record
+   * it. Only the gateway daemon injects a `SqliteConnectorDiagnosticLog`; everywhere
+   * else this stays absent and recording is a no-op.
+   */
+  diagnosticLog?: ConnectorDiagnosticLog;
+  /**
+   * Called when Funnel catches an exception that would otherwise be silently
+   * swallowed (subscriber throw, listener start/stop failure, etc.). Pass
+   * `Sentry.captureException` from the host to surface these. Defaults to no-op.
+   */
+  onError?: OnFunnelError;
+  /**
+   * Gateway daemon port. Passed directly to FunnelGateway so hosts can override
+   * the default (9742) without setting FUNNEL_PORT in the environment.
+   */
+  port?: number;
+  /**
+   * Token prompter used by FunnelLocalConfigSync when funnel.json omits a token.
+   * Defaults to a TTY-only stdin prompter. Inject MemoryFunnelTokenPrompter in tests.
+   */
+  tokenPrompter?: FunnelTokenPrompter;
+};
+/**
+ * Options for `Funnel.gatewayServer()`. The event store is a union (`dbPath`
+ * xor `eventLog`) so the two storage modes can't be mixed.
+ */
+type GatewayServerOptions = GatewayEventStore & {
+  port?: number;
+  hostname?: string;
+  killCompetingSlack?: boolean;
+  token?: string; /** Permit a non-loopback `hostname` without a token. See FunnelGatewayServer. */
+  allowInsecureHost?: boolean;
+  extraRoutes?: Hono<Env$1>;
+};
+/**
+ * Facade that wires every funnel facet together and exposes the public surface.
+ *
+ * All side-effecting boundaries (filesystem, process, logger, clock, id, paths)
+ * are injected via Props — passing memory implementations gives a fully sandboxed
+ * Funnel that touches no real disk, processes, or wall-clock time.
+ *
+ * Fully immutable: all fields are resolved in the constructor and frozen.
+ * No lazy initialisation — every dependency is wired at construction time.
+ *
+ * @example
+ * ```ts
+ * import { slackConnector } from "@interactive-inc/claude-funnel/connectors/slack"
+ *
+ * const funnel = new Funnel({ connectors: [slackConnector()] })
+ * 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 {
+  readonly paths: {
+    dir: string;
+    tmpDir: string;
+    settings: string;
+  };
+  readonly channels: FunnelChannels;
+  readonly gateway: FunnelGateway;
+  readonly gatewayToken: FunnelGatewayToken;
+  readonly publisher: FunnelChannelPublisher;
+  readonly listeners: FunnelListenersClient;
+  readonly claude: FunnelClaude;
+  readonly profiles: FunnelProfiles;
+  readonly localConfig: FunnelLocalConfig;
+  readonly localConfigSync: FunnelLocalConfigSync;
+  readonly diagnostics: FunnelDiagnostics;
+  readonly recovery: FunnelRecovery;
+  readonly doctor: FunnelDoctor;
+  readonly docs: FunnelDocs;
+  private readonly fs;
+  private readonly process;
+  private readonly logger;
+  private readonly clock;
+  private readonly onError;
+  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;
+  /**
+   * 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?: GatewayServerOptions): FunnelGatewayServer;
+  /**
+   * Create a ProcessGuard scoped to this Funnel's home directory.
+   * Useful for hosts that need to check or manage singleton PID files
+   * independently of FunnelClaude (e.g. checking if a named profile is running).
+   */
+  createProcessGuard(): FileProcessGuard;
+  /**
+   * Run the gateway daemon in the foreground (tied to this terminal).
+   * For background daemon management, use `funnel.gateway.start()` instead.
+   */
+  runGatewayForeground(options?: {
+    caffeinate?: boolean;
+  }): Promise<number>;
+  gatewayClient(): ReturnType<typeof hc<GatewayApp>>;
+}
+//#endregion
+//#region lib/engine/settings/settings-store.d.ts
+/**
+ * Resolves the funnel home dir. Defaults to `~/.funnel`, overridable via
+ * `FUNNEL_DIR` so a funnel.json-scoped launch can point everything (settings,
+ * gateway pid/token, claude pids) at a repo-local `<repo>/.funnel` and never
+ * touch the global home. Read at call time, not module load, so a daemon
+ * spawned with the env set resolves the override.
+ */
+declare function resolveFunnelDir(): string;
+declare const DEFAULT_GATEWAY_PORT = 9742;
+/**
+ * Resolves the gateway port. Defaults to 9742 — the port a programmatically
+ * hosted gateway (`new Funnel().gatewayServer()`) uses. The `funnel` CLI entry
+ * sets `FUNNEL_PORT` to a distinct default so a CLI launch never collides with
+ * an embedding app's gateway on 9742. Read at call time so a daemon spawned
+ * with the env set resolves the override.
+ */
+declare function resolveFunnelPort(): number;
+declare const FUNNEL_DIR: string;
+declare const SETTINGS_PATH: string;
+type Deps$1 = {
+  path?: string;
+  fs?: FunnelFileSystem;
+  idGenerator?: FunnelIdGenerator;
+};
+declare class FunnelSettingsStore extends FunnelSettingsReader {
+  private readonly path;
+  private readonly fs;
+  private readonly idGenerator;
+  constructor(deps?: Deps$1);
+  read(): Settings;
+  private looksLikeLegacy;
+  /**
+   * Non-destructive migration for profiles written before `id` existed. Mints a
+   * uuid for each profile lacking one and returns whether anything was minted, so
+   * `read` can persist it immediately — a profile id must be STABLE across reads,
+   * otherwise `setSessionId` (a second read) sees a different id and can't match
+   * the one the launch used. Mutates `parsed` in place (freshly JSON-parsed).
+   */
+  private backfillProfileIds;
+  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;
+  isAlive(pid: number): boolean;
+  listProcessesContaining(marker: string): ProcessSnapshot[];
+  getStartTime(pid: number): string | null;
+  private isAlivePosix;
+  private isAliveWindows;
+  private listProcessesContainingPosix;
+  private getStartTimePosix;
+  private getStartTimeWindows;
+  private listProcessesContainingWindows;
+}
+//#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[];
+};
+type AliveStub = (pid: number) => boolean;
+type ProcessListStub = (marker: string) => ProcessSnapshot[];
+type StartTimeStub = (pid: number) => string | null;
+declare class MemoryFunnelProcessRunner extends FunnelProcessRunner {
+  readonly calls: MemoryProcessCall[];
+  readonly killed: {
+    pid: number;
+    signal: string;
+  }[];
+  private handler;
+  private syncHandler;
+  private aliveStub;
+  private listStub;
+  private startTimeStub;
+  on(handler: MemoryProcessHandler): this;
+  onSync(handler: MemoryProcessSyncHandler): this;
+  onIsAlive(stub: AliveStub): this;
+  onListProcessesContaining(stub: ProcessListStub): this;
+  onGetStartTime(stub: StartTimeStub): 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;
+  isAlive(pid: number): boolean;
+  listProcessesContaining(marker: string): ProcessSnapshot[];
+  getStartTime(pid: number): string | null;
+}
+//#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/engine/http/node-http-client.d.ts
+declare class NodeFunnelHttpClient extends FunnelHttpClient {
+  constructor();
+  fetch(request: HttpRequest): Promise<HttpResponse>;
+}
+//#endregion
+//#region lib/engine/http/memory-http-client.d.ts
+type MemoryHttpResponse = {
+  status?: number;
+  body?: string;
+};
+type MemoryHttpHandler = (request: HttpRequest) => MemoryHttpResponse | Promise<MemoryHttpResponse>;
+declare class MemoryFunnelHttpClient extends FunnelHttpClient {
+  readonly calls: HttpRequest[];
+  private handler;
+  on(handler: MemoryHttpHandler): this;
+  fetch(request: HttpRequest): Promise<HttpResponse>;
+}
+//#endregion
+//#region lib/gateway/service-routes.d.ts
+type Deps = {
+  diagnostics: FunnelDiagnostics;
+  doctor: FunnelDoctor; /** Bearer token to gate every endpoint. Empty string disables auth (tests only). */
+  token: string;
+};
+/**
+ * Mountable Hono app that exposes the service layer (`FunnelDiagnostics` +
+ * `FunnelDoctor`) over loopback HTTP. The MCP server, which lives in a
+ * different process, calls these endpoints to drive the autonomous
+ * troubleshooting loop. The CLI bypasses HTTP and calls the same services
+ * directly through the in-process funnel facade, so CLI and MCP share one
+ * code path.
+ */
+declare const buildServiceRoutes: (deps: Deps) => Hono<Env$1>;
+//#endregion
+//#region lib/cli/factory.d.ts
+type Env = {
+  Bindings: {
+    funnel: Funnel;
+    claude: FunnelClaude;
+    profiles: FunnelProfiles;
+    localConfig: FunnelLocalConfig;
+    localConfigSync: FunnelLocalConfigSync;
+  };
+};
+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
+declare const routes: _$hono_hono_base0.HonoBase<Env, {
+  "/claude": {
+    $get: {
+      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 first channel from funnel.json, or the default profile\n  funnel claude --channel <name>         with funnel.json: select that channel; without: raw launch\n  funnel claude -p <name>                launch a named profile\n  funnel claude --profile <name>         (long form)\n  funnel claude [...]                    any other argument is forwarded to the claude CLI\n\nresolution order:\n  1. --help                              print this help\n  2. --profile <name>                    named profile (ignores funnel.json)\n  3. ./funnel.json in the current directory + --channel selects (or first wins)\n  4. --channel <name> with no funnel.json → raw launch using an existing settings.json channel\n  5. the default profile (first entry in fnl profiles)\n\nfunnel-specific options (everything else passes through to claude verbatim):\n  -p, --profile      profile name to launch\n  --channel          channel name (selects from funnel.json, or raw-launches if no funnel.json)\n  -h, --help         show this help\n\nPositional args, unknown short flags (e.g. -c, -r), and claude's own flags\n(--agent, --resume, --model, --print, --output-format ...) are all forwarded.\nOn launch the FUNNEL_CHANNEL_ID env var is set and MCP connects to the gateway.\n\nsee also:\n  fnl docs claude              full resolution order, side effects, double-launch guard\n  fnl docs mcp                 what the MCP server exposes once Claude is up\n  fnl docs debugging           the diagnose → recover → verify loop\n\nprogrammable: funnel.claude.launch({ profileId | channelId, options, env, resume })";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/add": {
+    $post: {
+      input: {};
+      output: "funnel channels add — add a channel\n\nusage: funnel channels add <name> [--delivery fanout|exclusive]\n\noptions:\n  --delivery    routing mode (default fanout):\n                  fanout      every connected client receives every event\n                  exclusive   each event delivered to exactly one client (round-robin)\n\nA channel is a named event stream. After creating it, add connectors\n(Slack, Discord, GitHub, schedule) to feed events into it, then connect\nClaude Code clients to consume them.\n\nexamples:\n  funnel channels add production\n  funnel channels add ci-events --delivery exclusive\n\nsee also: funnel channels, funnel channels <name> connectors add";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/add/:channel": {
+    $post: {
+      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: "funnel channels remove — remove a channel and all its connectors\n\nusage: funnel channels remove <name>\n\nThe channel, its connectors, and their schedules are deleted from the\nconfiguration file. The gateway drops the channel on the next reload.\nNo external resources (Slack apps, Discord bots, etc.) are touched.\n\nexamples:\n  funnel channels remove staging\n\nsee also: funnel channels, funnel channels add";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/remove/:channel": {
+    $post: {
+      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: `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: `renamed channel "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/rename": {
+    $post: {
+      input: {};
+      output: "funnel channels rename — rename a channel\n\nusage:\n  funnel channels rename <old-channel-name> <new-channel-name>\n  funnel channels <old-channel-name> rename <new-channel-name>\n\nRenames the channel in the configuration file. Connectors, schedules,\nand delivery mode are preserved. The gateway picks up the new name on\nthe next reload.\n\nexamples:\n  funnel channels rename staging production\n  funnel channels staging rename production\n\nsee also: funnel channels, funnel channels <name>";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: "funnel channels rename — rename a channel\n\nusage:\n  funnel channels rename <old-channel-name> <new-channel-name>\n  funnel channels <old-channel-name> rename <new-channel-name>\n\nRenames the channel in the configuration file. Connectors, schedules,\nand delivery mode are preserved. The gateway picks up the new name on\nthe next reload.\n\nexamples:\n  funnel channels rename staging production\n  funnel channels staging rename production\n\nsee also: funnel channels, funnel channels <name>";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/set/delivery/:mode": {
+    $post: {
+      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: "funnel channels <channel> publish — push arbitrary content into a channel\n\nusage: funnel channels <channel> publish --content=\"<text>\" [--connector=<name>] [--meta-<key>=<value> ...]\n\noptions:\n  --content       Required. The event body delivered to subscribers.\n  --connector     Optional. Stamp the event with a connector name (resolved to id when found).\n  --meta-<key>    Optional. Repeatable. Added to meta. Example: --meta-source=cron";
+      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: `published (offset=${number})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/validate": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+        };
+      } & {
+        query: Record<string, never>;
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/validate": {
+    $get: {
+      input: {};
+      output: "funnel channels <channel> validate — check connector configuration\n\nusage: funnel channels <channel> validate [--json]\n\noptions:\n  --json   output as JSON\n\nChecks that each connector has the required tokens and fields set.\nDoes not make any network calls — static config check only.\n\nexamples:\n  funnel channels open-karte validate\n  funnel channels open-karte validate --json";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/add": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: "funnel channels <channel> connectors add <name> — add a connector to a channel\n\nusage:\n  funnel channels <channel> connectors add <name> --type=slack --bot-token=xoxb-... --app-token=xapp-...\n  funnel channels <channel> connectors add <name> --type=gh [--poll-interval=60]\n  funnel channels <channel> connectors add <name> --type=discord --bot-token=...\n  funnel channels <channel> connectors add <name> --type=schedule\n\nconnector types:\n  slack      Slack Socket Mode (requires bot-token + app-token)\n  gh         GitHub webhook polling\n  discord    Discord bot gateway\n  schedule   cron / one-shot timer (no external service)\n\nToken uniqueness is enforced across all channels — the same bot-token\ncannot appear in two connectors.\n\nexamples:\n  funnel channels prod connectors add main-slack --type=slack --bot-token=xoxb-... --app-token=xapp-...\n  funnel channels ci connectors add gh-events --type=gh --poll-interval=30\n  funnel channels alerts connectors add daily --type=schedule\n\nsee also: funnel channels <channel> connectors, funnel channels <channel> connectors remove";
+      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: `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: "funnel channels <channel> connectors remove <connector> — remove a connector\n\nusage: funnel channels <channel> connectors remove <connector>\n\nRemoves the connector from the channel configuration. The gateway drops\nit on the next reload. No external resources (Slack apps, Discord bots,\nGitHub webhooks) are touched.\n\nexamples:\n  funnel channels production connectors remove slack-main\n\nsee also: funnel channels <channel> connectors, funnel channels <channel> connectors add";
+      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: `removed connector "${string}" from channel "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/set": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: "funnel channels <channel> connectors set <connector> — update connector fields\n\nusage:\n  funnel channels <ch> connectors set <conn> [--bot-token=...] [--app-token=...]   # slack\n  funnel channels <ch> connectors set <conn> [--bot-token=...]                    # discord\n  funnel channels <ch> connectors set <conn> [--poll-interval=N]                  # gh";
+      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: `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: `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: `renamed connector "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        };
+      };
+      output: "funnel channels <channel> connectors rename <old-connector-name> <new-connector-name> — rename a connector\n\nusage: funnel channels <channel> connectors rename <old-connector-name> <new-connector-name>\n\nRenames the connector in the configuration file. Tokens, type, and\nschedules are preserved. The gateway picks up the new name on the\nnext reload.\n\nexamples:\n  funnel channels production connectors rename slack-1 slack-main\n\nsee also: funnel channels <channel> connectors";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/rename": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: string;
+        };
+      };
+      output: "funnel channels <channel> connectors rename <connector> <new-name>\n\nusage: funnel channels <channel> connectors rename <connector> <new-name>";
+      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[];
+          path?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules": {
+    $get: {
+      input: {
+        param: {
+          channel: string;
+          connector: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/channels/:channel/connectors/:connector/schedules/add": {
+    $post: {
+      input: {
+        param: {
+          channel: string;
+        } & {
+          connector: string;
+        };
+      };
+      output: "funnel channels <ch> connectors <conn> schedules add <id> — add a schedule entry\n\nusage: funnel channels <ch> connectors <conn> schedules add <id> --cron=\"*/5 * * * *\" --prompt=\"...\" [--enabled|--enabled=false] [--catchup-policy=latest|all|skip]\n\noptions:\n  --cron <expr> / 5-field cron expression (required)\n  --prompt <text> / prompt delivered on each fire (required)\n  --enabled / fire on schedule (default: true; --enabled=false stores it disabled)\n  --catchup-policy latest|all|skip / how missed fires are replayed after downtime (default: latest)";
+      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;
+          prompt: string;
+          enabled?: "" | "true" | "false" | 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: "funnel channels <ch> connectors <conn> schedules remove <id>\n\nusage: funnel channels <ch> connectors <conn> schedules remove <id>";
+      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: `removed schedule entry "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/add": {
+    $post: {
+      input: {};
+      output: "funnel profiles add — add a profile\n\nusage: funnel profiles add <name> --path <path> --channel <channel-name> [recipe]\n\noptions:\n  --path        working directory passed to claude as cwd\n  --channel     channel name (resolved to channel id internally)\n  --agent       sub-agent name, prepended to the launch argv as --agent <name>\n  --options     extra launch argv as one whitespace-split string (e.g. \"--brief\")\n  --env         env vars layered under the process, as \"KEY=VAL,KEY2=VAL2\"\n  --no-resume   start a fresh claude session every launch (default resumes)\n\nThe launch recipe (--agent / --options / --env / --resume) lives on the\nprofile; the channel only declares transport (connectors / delivery).";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/add/:profile": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path: string;
+          channel: string;
+          agent?: string | undefined;
+          options?: string | undefined;
+          env?: string | undefined;
+          resume?: string | undefined;
+          "no-resume"?: string | undefined;
+        };
+      };
+      output: `added profile "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/set": {
+    $post: {
+      input: {};
+      output: "funnel profiles <name> set — update a profile\n\nusage: funnel profiles <name> set [--path <path>] [--channel <channel-name>] [recipe]\n\noptions:\n  --path        working directory passed to claude as cwd\n  --channel     channel name (resolved to channel id internally)\n  --agent       sub-agent name, prepended to the launch argv as --agent <name>\n  --options     extra launch argv as one whitespace-split string (e.g. \"--brief\")\n  --env         env vars layered under the process, as \"KEY=VAL,KEY2=VAL2\"\n  --resume / --no-resume  toggle claude session reuse\n\nOnly the flags you pass are changed; --agent and --options together replace\nthe profile's whole options list.";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/set/:profile": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      } & {
+        query: {
+          path?: string | undefined;
+          channel?: string | undefined;
+          agent?: string | undefined;
+          options?: string | undefined;
+          env?: string | undefined;
+          resume?: string | undefined;
+          "no-resume"?: string | undefined;
+        };
+      };
+      output: `updated profile "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/remove": {
+    $post: {
+      input: {};
+      output: "funnel profiles remove — remove a profile\n\nusage: funnel profiles remove <name>";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/remove/:profile": {
+    $post: {
+      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: `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: `renamed profile "${string}" to "${string}"`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/rename": {
+    $post: {
+      input: {};
+      output: "funnel profiles rename — rename a profile\n\nusage:\n  funnel profiles rename <old> <new>\n  funnel profiles <old> rename <new>";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/rename": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      };
+      output: "funnel profiles rename — rename a profile\n\nusage:\n  funnel profiles rename <old> <new>\n  funnel profiles <old> rename <new>";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/profiles/:profile/as-default": {
+    $post: {
+      input: {
+        param: {
+          profile: string;
+        };
+      };
+      output: `profile "${string}" is now the default`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/status": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/start": {
+    $get: {
+      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 (pid null, port ${number}) but /health did not respond within ${number}s \u2014 check \`fnl gateway logs\`` | `funnel gateway: started (pid ${number}, port ${number}) but /health did not respond within ${number}s \u2014 check \`fnl gateway logs\``;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {
+        query: {
+          "no-caffeine"?: string | undefined;
+        };
+      };
+      output: `funnel gateway: started (pid null, port ${number})` | `funnel gateway: started (pid ${number}, port ${number})`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/stop": {
+    $get: {
+      input: {};
+      output: "funnel gateway: no running process";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    } | {
+      input: {};
+      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/logs": {
+    $get: {
+      input: {
+        query: {
+          n?: string | undefined;
+          format?: "json" | "plain" | undefined;
+        };
+      };
+      output: "no logs";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/sql": {
+    $get: {
+      input: {
+        query: {
+          query?: string | undefined;
+          preset?: string | undefined;
+          channel?: string | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/gateway/listeners": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          all?: "" | "true" | "false" | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug/events": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug/dropped": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug/errors": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          limit?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/debug/replay": {
+    $get: {
+      input: {
+        query: {
+          channel?: string | undefined;
+          seq?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/docs": {
+    $get: {
+      input: {};
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/docs/:topic": {
+    $get: {
+      input: {
+        param: {
+          topic: string;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/doctor": {
+    $get: {
+      input: {
+        query: {
+          fix?: "" | "true" | "false" | undefined;
+          aggressive?: "" | "true" | "false" | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/schema": {
+    $get: {
+      input: {};
+      output: `${string}
+`;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/status": {
+    $get: {
+      input: {
+        query: {
+          watch?: "" | "true" | "false" | undefined;
+          interval?: string | undefined;
+        };
+      };
+      output: string;
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+} & {
+  "/update": {
+    $get: {
+      input: {};
+      output: "updated @interactive-inc/claude-funnel";
+      outputFormat: "text";
+      status: _$hono_utils_http_status0.ContentfulStatusCode;
+    };
+  };
+}, "/", "/update">;
+type CliApp = typeof routes;
+//#endregion
+export { AddConnectorInput, AliveStub, AttachOptions, BaseConnectorConfig, BroadcastEvent, BroadcastSubscriber, CONNECTOR_CONNECTION_STATUSES, CallInput, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelDiagnosis, ChannelWsUrlInput, type CliApp, ConnectorAdapterDeps, ConnectorBuildContext, ConnectorConnectionEvent, ConnectorConnectionQuery, ConnectorConnectionRecord, ConnectorConnectionStatus, ConnectorDescriptor, ConnectorDiagnosticLog, ConnectorDiagnosticSqlReader, ConnectorListenerDeps, ConnectorOperation, ConnectorOperationContext, ConnectorProcessedEvent, ConnectorProcessedQuery, ConnectorProcessedRecord, ConnectorQuery, ConnectorRawEvent, ConnectorRawQuery, ConnectorRawRecord, ConnectorUpdateContext, DEFAULT_GATEWAY_PORT, DEFAULT_GATEWAY_TOKEN_PATH, DetachOptions, DiagnoseAllReport, DiagnosisStatus, DiagnosticConnectionError, DiagnosticEvent, DiagnosticsChannelSource, DiagnosticsGatewayProbe, DiagnosticsPublisher, DiagnosticsTokenReader, DocsTopicListing, DoctorFixMode, DoctorReport, Env, FUNNEL_DIR, FileStat, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClock, FunnelConnectorAdapter, FunnelConnectorListener, FunnelConnectorRegistry, FunnelDiagnostics, FunnelDocs, FunnelDoctor, FunnelEvent, FunnelEventLog, FunnelEventRecord, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelHttpClient, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLogger, FunnelProcessRunner, FunnelRecovery, FunnelSettingsReader, FunnelSettingsStore, type GatewayApp, type GatewayEmitInput, GatewayEventStore, type GatewayRouteDeps, type Env$1 as GatewayServerEnv, GatewayServerOptions, HttpRequest, HttpResponse, JsonValue, ListListenersResult, ListenerEntry, ListenerOpResult, LogEntry, MemoryConnectorDiagnosticLog, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelHttpClient, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryHttpHandler, MemoryHttpResponse, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelHttpClient, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NoopFunnelLogger, NotifyFn, OnFunnelError, ProcessListStub, ProcessSnapshot, ProfileConfig, PublishRequest, PublishResponse, PublishResult, RecoveryAction, RecoveryChannelSource, RecoveryGatewayControl, RecoveryListenerControl, RecoveryResult, ReplayResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, Settings, SqliteConnectorDiagnosticLog, SqliteFunnelEventLog, StartTimeStub, StoredConnectionEvent, StoredProcessedEvent, StoredRawEvent, baseConnectorConfigSchema, buildServiceRoutes, channelConfigSchema, channelDeliveryModeSchema, channelWsProtocols, channelWsUrl, routes as cliRoutes, connectorConnectionEventSchema, connectorProcessedEventSchema, connectorRawEventSchema, createSettings, factory, funnelEventSchema, gatewayLoopbackUrl, previewOf, profileConfigSchema, publishRequestSchema, publishResponseSchema, queryRows, queryToCliArgs, resolveFunnelDir, resolveFunnelPort, settingsSchema, toDiagnosticConnectionError, toDiagnosticEvent, toRequest };