@interactive-inc/claude-funnel 0.25.2 → 0.26.1

package/dist/index.d.ts

@@ -64,7 +64,7 @@ type SlackListenerOptions = {
 type ScheduleListenerOptions = {
   onFired?: ScheduleOnFired;
 };
-type Deps$16 = {
+type Deps$15 = {
   fs?: FunnelFileSystem;
   process?: FunnelProcessRunner;
   logger?: FunnelLogger;
@@ -91,7 +91,7 @@ declare class FunnelConnectorFactory {
   private readonly dir;
   private readonly slackListenerOptions;
   private readonly scheduleListenerOptions;
-  constructor(deps?: Deps$16);
+  constructor(deps?: Deps$15);
   createListener(channelId: string, config: ConnectorConfig): FunnelConnectorListener;
   createAdapter(config: ConnectorConfig): FunnelConnectorAdapter | null;
   connectorDir(channelId: string, connectorId: string): string;
@@ -195,12 +195,14 @@ declare const channelConfigSchema: z.ZodObject<{
 }, z.core.$strip>;
 type ChannelConfig = z.infer<typeof channelConfigSchema>;
 declare const profileConfigSchema: z.ZodObject<{
+  id: z.ZodString;
   name: z.ZodString;
   path: z.ZodString;
   channelId: z.ZodString;
   options: z.ZodDefault<z.ZodArray<z.ZodString>>;
   env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
   resume: z.ZodDefault<z.ZodBoolean>;
+  sessionId: z.ZodOptional<z.ZodString>;
 }, z.core.$strip>;
 type ProfileConfig = z.infer<typeof profileConfigSchema>;
 declare const SETTINGS_VERSION = 1;
@@ -256,12 +258,14 @@ declare const settingsSchema: z.ZodObject<{
     }, z.core.$strip>], "type">>>;
   }, z.core.$strip>>>;
   profiles: z.ZodDefault<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
     name: z.ZodString;
     path: z.ZodString;
     channelId: z.ZodString;
     options: z.ZodDefault<z.ZodArray<z.ZodString>>;
     env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
     resume: z.ZodDefault<z.ZodBoolean>;
+    sessionId: z.ZodOptional<z.ZodString>;
   }, z.core.$strip>>>;
 }, z.core.$strip>;
 type Settings = z.infer<typeof settingsSchema>;
@@ -273,7 +277,7 @@ declare abstract class FunnelSettingsReader {
 }
 //#endregion
 //#region lib/engine/channels/channels.d.ts
-type Deps$15 = {
+type Deps$14 = {
   store: FunnelSettingsReader;
   factory: FunnelConnectorFactory;
   profileChecker: ProfileChannelChecker;
@@ -317,7 +321,7 @@ declare class FunnelChannels {
   private readonly profileChecker;
   private readonly clock;
   private readonly idGenerator;
-  constructor(deps: Deps$15);
+  constructor(deps: Deps$14);
   list(): ChannelConfig[];
   get(name: string): ChannelConfig | null;
   getById(id: string): ChannelConfig | null;
@@ -375,7 +379,7 @@ type GatewayController = {
 //#region lib/engine/mcp/mcp.d.ts
 declare const FUNNEL_MCP_COMMAND = "funnel";
 declare const FUNNEL_MCP_NAME = "funnel";
-type Deps$14 = {
+type Deps$13 = {
   fs?: FunnelFileSystem;
 };
 /**
@@ -385,7 +389,7 @@ type Deps$14 = {
  */
 declare class FunnelMcp {
   private readonly fs;
-  constructor(deps?: Deps$14);
+  constructor(deps?: Deps$13);
   install(repoPath: string): void;
   uninstall(repoPath: string): void;
   findInstalledName(cwd: string): string | null;
@@ -394,46 +398,53 @@ declare class FunnelMcp {
   private writeConfig;
 }
 //#endregion
-//#region lib/engine/sessions/sessions.d.ts
-type Deps$13 = {
-  fs: FunnelFileSystem;
+//#region lib/engine/profiles/profiles.d.ts
+type Deps$12 = {
+  store: FunnelSettingsReader;
   idGenerator: FunnelIdGenerator;
-  dir: string;
 };
 /**
- * Per-channel persistent Claude Code session IDs, keyed by the cwd the
- * channel was launched from. The whole point is to give each (channel, cwd)
- * its own stable conversation: relaunching from the same path resumes the
- * previous claude session via `--resume <uuid>`, while a different cwd (or
- * a different channel) gets an independent one — so sessions never silently
- * bleed across workspaces the way claude's `-c` does.
+ * Named launch presets for `fnl claude`. Each profile bundles a working
+ * directory, the channel id its Claude instance subscribes to, and the launch
+ * recipe (`options` prepended to the claude argv, `env` layered under the
+ * process, `resume` toggling session reuse). Implements ProfileChannelChecker
+ * so FunnelChannels can refuse to remove a channel that is still referenced.
  *
- * `get` and `create` are intentionally separate: claude's `--session-id`
- * only accepts a fresh UUID (it errors if the session jsonl already
- * exists), so callers must check `get` first and fall back to `create`
- * only when there is nothing to resume.
+ * Each profile has a stable `id` (uuid) minted at `add`. That id is the unit
+ * everything internal keys on — the PID file, the resumable session id — so a
+ * rename never strands either. `name` is purely the CLI/TUI handle; the CRUD
+ * methods here take it because that is what the user types, but resolve to the
+ * id before touching id-keyed state. The first array entry is the default
+ * profile; `asDefault` reorders to put one first.
  *
- * Storage lives under `<dir>/channels/<channel-id>/sessions.json` (channel
- * id, not name, so renames don't lose history). The file is a flat
- * `{ cwd: uuid }` map; the channel directory itself is created lazily.
+ * `channelId` always stores the channel's stable id (uuid). CLI surfaces
+ * resolve channel name → id before calling `add`/`update` here.
  */
-declare class FunnelSessions {
-  private readonly fs;
+declare class FunnelProfiles {
+  private readonly store;
   private readonly idGenerator;
-  private readonly dir;
-  constructor(deps: Deps$13);
-  /** Returns the existing session id for (channelId, cwd) or null. */
-  get(channelId: string, cwd: string): string | null;
-  /** Generates a new session id for (channelId, cwd) and persists it, overwriting any prior entry. */
-  create(channelId: string, cwd: string): string;
-  /** Drops the recorded session id for (channelId, cwd). No-op if absent. */
-  clear(channelId: string, cwd: string): void;
-  /** Drops the whole session map for the channel (e.g. when the channel is deleted). */
-  clearAll(channelId: string): void;
-  private readMap;
-  private writeMap;
-  private channelDir;
-  private pathFor;
+  constructor(deps: Deps$12);
+  list(): ProfileConfig[];
+  get(name: string): ProfileConfig | null;
+  getById(id: string): ProfileConfig | null;
+  getDefault(): ProfileConfig | null;
+  add(input: {
+    name: string;
+    path: string;
+    channelId: string;
+    options?: string[];
+    env?: Record<string, string>;
+    resume?: boolean;
+  }): void;
+  remove(name: string): void;
+  rename(oldName: string, newName: string): void;
+  asDefault(name: string): void;
+  hasChannelRef(channelId: string): boolean;
+  /** Resumable claude session id last launched by this profile (by id), or null. */
+  getSessionId(id: string): string | null;
+  /** Records the claude session id this profile launched, overwriting any prior one. */
+  setSessionId(id: string, sessionId: string): void;
+  update(name: string, fields: Partial<Omit<ProfileConfig, "name">>): void;
 }
 //#endregion
 //#region lib/engine/claude/claude.d.ts
@@ -441,9 +452,16 @@ type LaunchOptions = {
   channel: string;
   cwd?: string;
   userArgs?: string[];
-  profileName?: string; /** Args prepended to the claude argv (typically a profile's recipe). Defaults to none. */
+  /** Stable id of the launching profile (uuid). Keys the singleton PID file and
+   *  the resumable session. Absent for a profile-less launch (raw `--channel`),
+   *  which never enforces singleton-ness and never resumes. */
+  profileId?: string; /** Args prepended to the claude argv (typically a profile's recipe). Defaults to none. */
   options?: string[]; /** Env vars layered under the launched claude process. process.env wins on collision. */
-  env?: Record<string, string>; /** Whether to inject a `--session-id`/`--resume` for the (channel, cwd). Defaults to true. */
+  env?: Record<string, string>;
+  /** Whether to inject a `--session-id`/`--resume` for this profile.
+   *  Defaults to false: resuming is opt-in and only meaningful for a profile,
+   *  since the persisted session is owned by the profile (by id). A launch
+   *  without a profile always starts a fresh session regardless of this flag. */
   resume?: boolean;
   /** Invoked synchronously after the child claude process has been spawned, with its PID.
    *  Useful for hosts that need to register the spawned process before it exits
@@ -454,13 +472,14 @@ type LaunchOptions = {
    *  does not need the funnel binary as an MCP endpoint. */
   installMcp?: boolean;
 };
-type Deps$12 = {
+type Deps$11 = {
   channels: FunnelChannels;
   mcp: FunnelMcp;
   gateway: GatewayController;
-  sessions: FunnelSessions;
+  profiles: FunnelProfiles;
   process?: FunnelProcessRunner;
   fs?: FunnelFileSystem;
+  idGenerator?: FunnelIdGenerator;
   logger?: FunnelLogger;
   dir?: string;
 };
@@ -474,14 +493,15 @@ declare class FunnelClaude {
   private readonly channels;
   private readonly mcp;
   private readonly gateway;
-  private readonly sessions;
+  private readonly profiles;
   private readonly process;
   private readonly fs;
+  private readonly idGenerator;
   private readonly logger;
   private readonly pidDir;
-  constructor(deps: Deps$12);
+  constructor(deps: Deps$11);
   launch(options: LaunchOptions): Promise<number>;
-  isRunning(profileName: string): boolean;
+  isRunning(profileId: string): boolean;
   private pidPath;
   private readPid;
   private writePidFile;
@@ -495,10 +515,16 @@ declare class FunnelClaude {
    * session-shaping flag, since combining them would either confuse claude
    * or override the explicit user intent.
    *
+   * The session is owned by the profile (by id), not by cwd: two profiles
+   * pointing at the same repo each keep their own conversation, and a launch
+   * with no profile never resumes — so an unrelated session in the same repo
+   * can't bleed in. The channel never enters into it; sessions belong to the
+   * launch layer (profiles), keeping the transport layer ignorant of them.
+   *
    * A persisted id is only resumed when its session jsonl still exists on
    * disk. claude errors out on `--resume <id>` for a missing conversation, and
    * a persisted id can outlive its jsonl (claude pruned it, or the very first
-   * launch was aborted after `create` wrote the id but before the jsonl
+   * launch was aborted after the id was written but before the jsonl
    * appeared). When the file is gone we mint a fresh session instead, which
    * overwrites the dangling entry — so the store self-heals.
    */
@@ -527,7 +553,7 @@ declare class FunnelClaude {
 type OnFunnelError = (error: Error, context?: Record<string, unknown>) => void;
 //#endregion
 //#region lib/engine/local-config/dotenv-reader.d.ts
-type Deps$11 = {
+type Deps$10 = {
   fs: FunnelFileSystem;
 };
 /**
@@ -538,7 +564,7 @@ type Deps$11 = {
  */
 declare class FunnelDotenvReader {
   private readonly fs;
-  constructor(deps: Deps$11);
+  constructor(deps: Deps$10);
   read(cwd: string): Record<string, string>;
 }
 //#endregion
@@ -599,7 +625,6 @@ declare const channelSpecSchema: z.ZodObject<{
 }, z.core.$strip>;
 type ChannelSpec = z.infer<typeof channelSpecSchema>;
 declare const profileSpecSchema: z.ZodObject<{
-  name: z.ZodString;
   channel: z.ZodString;
   options: z.ZodOptional<z.ZodArray<z.ZodString>>;
   env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -637,7 +662,6 @@ declare const localConfigSchema: z.ZodObject<{
     }, z.core.$strip>], "type">>>;
   }, z.core.$strip>>;
   profiles: z.ZodOptional<z.ZodArray<z.ZodObject<{
-    name: z.ZodString;
     channel: z.ZodString;
     options: z.ZodOptional<z.ZodArray<z.ZodString>>;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
@@ -649,7 +673,7 @@ declare const LOCAL_CONFIG_FILENAME = "funnel.json";
 declare const LOCAL_ENV_FILENAME = ".env.local";
 //#endregion
 //#region lib/engine/local-config/local-config.d.ts
-type Deps$10 = {
+type Deps$9 = {
   fs: FunnelFileSystem;
 };
 /**
@@ -660,8 +684,9 @@ type Deps$10 = {
  */
 declare class FunnelLocalConfig {
   private readonly fs;
-  constructor(deps: Deps$10);
+  constructor(deps: Deps$9);
   read(cwd: string): LocalConfig | null;
+  private assertProfilesValid;
 }
 //#endregion
 //#region lib/engine/token-prompter/token-prompter.d.ts
@@ -676,7 +701,7 @@ declare abstract class FunnelTokenPrompter {
 }
 //#endregion
 //#region lib/engine/local-config/local-config-sync.d.ts
-type Deps$9 = {
+type Deps$8 = {
   channels: FunnelChannels;
   dotenv: FunnelDotenvReader;
   prompter: FunnelTokenPrompter;
@@ -714,7 +739,7 @@ declare class FunnelLocalConfigSync {
   private readonly dotenv;
   private readonly prompter;
   private readonly env;
-  constructor(deps: Deps$9);
+  constructor(deps: Deps$8);
   ensure(channel: ChannelSpec, cwd: string): Promise<LocalConfigSyncResult>;
   private ensureConnector;
   private ensureSlack;
@@ -729,44 +754,6 @@ declare class FunnelLocalConfigSync {
   private resolveField;
 }
 //#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, the channel id its Claude instance subscribes to, and the launch
- * recipe (`options` prepended to the claude argv, `env` layered under the
- * process, `resume` toggling session reuse). Implements ProfileChannelChecker
- * so FunnelChannels can refuse to remove a channel that is still referenced.
- *
- * 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(input: {
-    name: string;
-    path: string;
-    channelId: string;
-    options?: string[];
-    env?: Record<string, string>;
-    resume?: boolean;
-  }): 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
@@ -832,9 +819,9 @@ type ReplayableEvent = BroadcastEvent & {
 };
 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
+ * Optional persistent replay source. Wired in by the gateway-server with a
+ * `FunnelEventLog` (SQLite-backed by default) so reconnects across daemon
+ * restarts can recover events older than the in-memory buffer via an indexed
  * `seq > since` range scan.
  */
 type ReplaySource = {
@@ -873,8 +860,7 @@ type BroadcasterMetrics = {
  * `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`.
+ * older history is served from the event log wired in as `persistentReplay`.
  */
 declare class FunnelBroadcaster {
   private readonly clients;
@@ -902,8 +888,8 @@ declare class FunnelBroadcaster {
    * 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.
+   *      is wired in (SQLite by default), the gap is filled from it. This covers reconnects
+   *      across daemon restarts where the in-memory buffer was lost.
    *
    * Result is sorted ascending by offset and de-duplicated against the in-memory buffer.
    */
@@ -1038,6 +1024,51 @@ type Env$1 = {
   };
 };
 //#endregion
+//#region lib/gateway/funnel-event-log.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 log, which keeps the offset 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>;
+/** One broadcast event to persist, carrying the offset the broadcaster assigned. */
+type FunnelEventRecord = {
+  content: string;
+  channelId: string | null;
+  connectorId: string | null;
+  meta: Record<string, string> | null;
+  offset: number;
+};
+/**
+ * Durable, append-only log of broadcaster events keyed by the offset the
+ * broadcaster assigns. The gateway persists every domain event here, and
+ * across restarts it both seeds the broadcaster's offset counter
+ * (`findMaxOffset`) and serves reconnect replay (`loadSince`) from it.
+ *
+ * `loadSince` is the only method the broadcaster itself needs, which makes
+ * any implementation assignable to the broadcaster's narrow `ReplaySource`.
+ *
+ * Implementations:
+ *   - `SqliteFunnelEventLog` — the default; durable across daemon restarts.
+ *   - `MemoryFunnelEventLog` — an in-process double for tests and embedders
+ *     that do not need durability (replay is lost when the process exits).
+ */
+declare abstract class FunnelEventLog {
+  abstract record(record: FunnelEventRecord): void;
+  abstract loadSince(since: number): ReplayableEvent[];
+  abstract findMaxOffset(): number;
+  abstract close(): void;
+}
+//#endregion
 //#region lib/gateway/gateway.d.ts
 type Deps$4 = {
   process?: FunnelProcessRunner;
@@ -1093,88 +1124,13 @@ declare class FunnelGateway {
   private isProcessAlive;
 }
 //#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$6 = {
-  /** 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$6);
-  /**
-   * 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/gateway-server.d.ts
 type Deps$3 = {
   channels: FunnelChannels;
   settings: FunnelSettingsReader;
-  port?: number; /** SQLite event store file path. Parent directory is created on demand. Defaults to `<os.tmpdir()>/funnel/events.db`. */
-  dbPath?: string;
+  port?: number; /** SQLite event store file path. Parent directory is created on demand. Defaults to `<os.tmpdir()>/funnel/events.db`. Ignored when `eventLog` is supplied. */
+  dbPath?: string; /** Durable replay log. Defaults to a `SqliteFunnelEventLog` at `dbPath`. Inject a `MemoryFunnelEventLog` (or any `FunnelEventLog`) to swap or disable persistence. */
+  eventLog?: FunnelEventLog;
   process?: FunnelProcessRunner;
   clock?: FunnelClock;
   logger?: FunnelLogger; /** Host hook for surfacing internal exceptions (broadcaster / supervisor). Defaults to no-op. */
@@ -1202,7 +1158,7 @@ type WsData = {
 /**
  * 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).
+ * `FunnelBroadcaster`, and persists them via a `FunnelEventLog` (SQLite by default).
  * System events (gateway lifecycle, connect/disconnect) flow to `FunnelLogger`
  * instead — keeping the SQLite seq space exclusive to broadcaster traffic so
  * the broadcaster's offset counter and `getMaxSeq()` stay aligned without
@@ -1222,7 +1178,7 @@ declare class FunnelGatewayServer {
   private readonly killCompetingSlack;
   private readonly token;
   private readonly broadcaster;
-  private readonly eventStore;
+  private readonly eventLog;
   private readonly supervisor;
   private readonly nowMs;
   private readonly extraRoutes;
@@ -1240,7 +1196,15 @@ declare class FunnelGatewayServer {
   };
   getBroadcaster(): FunnelBroadcaster;
   getSupervisor(): FunnelListenerSupervisor;
-  getEventStore(): FunnelEventStore;
+  getEventLog(): FunnelEventLog;
+  /**
+   * Register an in-process observer for every broadcast event. Fires after
+   * the event is fanned out to WS clients and recorded in the event log.
+   * Returns an unsubscribe function. Only meaningful in-process (embedded
+   * hosts / `new Funnel(...)` running their own gateway-server); a separate
+   * daemon process cannot be observed this way — use a WS client for that.
+   */
+  onEvent(handler: BroadcastSubscriber): () => void;
   private handleFetch;
   private handleWsOpen;
   private handleWsClose;
@@ -1360,7 +1324,7 @@ declare class FunnelListenersClient {
 }
 //#endregion
 //#region lib/funnel.d.ts
-type Props$5 = {
+type Props$6 = {
   /** 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. */
@@ -1410,13 +1374,13 @@ type Props$5 = {
 declare class Funnel {
   private readonly props;
   private readonly memos;
-  constructor(props?: Props$5);
+  constructor(props?: Props$6);
   /**
    * 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$5): Funnel;
+  static inMemory(props?: Props$6): Funnel;
   /** Resolved on-disk paths the facade will read/write when methods are called. Pure compute, not memoized. */
   get paths(): {
     dir: string;
@@ -1427,8 +1391,8 @@ declare class Funnel {
   get fs(): FunnelFileSystem;
   /** Process runner boundary. Defaults to NodeFunnelProcessRunner. */
   get process(): FunnelProcessRunner;
-  /** Logger boundary. Defaults to NodeFunnelLogger. */
-  get logger(): FunnelLogger;
+  /** Logger boundary. Optional — when no logger is injected, every facet's `this.logger?.x` call is a silent no-op. Production entry points (cli, daemon) inject a NodeFunnelLogger. */
+  get logger(): FunnelLogger | undefined;
   /** Clock boundary. Defaults to NodeFunnelClock. */
   get clock(): FunnelClock;
   /**
@@ -1446,8 +1410,6 @@ declare class Funnel {
   get channels(): FunnelChannels;
   /** Launch profiles (named presets for `fnl claude`: path + sub-agent + channel id). */
   get profiles(): FunnelProfiles;
-  /** Per-(channel, cwd) claude session-id store. Backs `--session-id` injection on launch. */
-  get sessions(): FunnelSessions;
   /** Reads `funnel.json` from a cwd. `fnl claude` consults it before falling back to the default profile. */
   get localConfig(): FunnelLocalConfig;
   /** Parses `.env.local` from a cwd (used by sync to back $VAR references). */
@@ -1485,7 +1447,8 @@ declare class Funnel {
     port?: number;
     dbPath?: string;
     killCompetingSlack?: boolean; /** Override the auth token. Defaults to the persisted gateway.token. Pass "" to disable auth (tests). */
-    token?: string;
+    token?: string; /** Durable replay log. Defaults to a SqliteFunnelEventLog at dbPath; inject a MemoryFunnelEventLog (or any FunnelEventLog) to swap or disable persistence. */
+    eventLog?: FunnelEventLog;
     /**
      * Additional hono app mounted before the built-in gateway routes.
      * Use to embed host-specific endpoints (e.g. an MCP route, custom `/api/*`).
@@ -1520,13 +1483,23 @@ declare const SETTINGS_PATH: string;
 type Deps = {
   path?: string;
   fs?: FunnelFileSystem;
+  idGenerator?: FunnelIdGenerator;
 };
 declare class FunnelSettingsStore extends FunnelSettingsReader {
   private readonly path;
   private readonly fs;
+  private readonly idGenerator;
   constructor(deps?: Deps);
   read(): Settings;
   private looksLikeLegacy;
+  /**
+   * Non-destructive migration for profiles written before `id` existed. The id
+   * is a later addition to an otherwise-compatible schema, so rather than
+   * rejecting the file we mint a uuid for each profile that lacks one; the next
+   * `write` persists it. Mutates `parsed` in place (it is freshly JSON-parsed
+   * and discarded after the schema parse, so no shared state is touched).
+   */
+  private backfillProfileIds;
   write(settings: Settings): void;
 }
 //#endregion
@@ -1556,7 +1529,7 @@ declare class NodeFunnelFileSystem extends FunnelFileSystem {
 }
 //#endregion
 //#region lib/engine/fs/memory-file-system.d.ts
-type Props$4 = {
+type Props$5 = {
   dirs?: string[];
   files?: Record<string, string>;
   mtimes?: Record<string, number>;
@@ -1569,7 +1542,7 @@ declare class MemoryFunnelFileSystem extends FunnelFileSystem {
   private readonly mtimes;
   private readonly modes;
   private readonly now;
-  constructor(props?: Props$4);
+  constructor(props?: Props$5);
   existsSync(path: string): boolean;
   readFileSync(path: string): string;
   writeFileSync(path: string, data: string): void;
@@ -1655,14 +1628,14 @@ declare class MemoryFunnelProcessRunner extends FunnelProcessRunner {
 }
 //#endregion
 //#region lib/engine/logger/node-logger.d.ts
-type Props$3 = {
+type Props$4 = {
   file?: string;
   now?: () => Date;
 };
 declare class NodeFunnelLogger extends FunnelLogger {
   readonly file: string;
   private readonly now;
-  constructor(props?: Props$3);
+  constructor(props?: Props$4);
   info(message: string, meta?: Record<string, unknown>): void;
   warn(message: string, meta?: Record<string, unknown>): void;
   error(message: string, meta?: Record<string, unknown>): void;
@@ -1698,12 +1671,12 @@ declare class NodeFunnelClock extends FunnelClock {
 }
 //#endregion
 //#region lib/engine/time/memory-clock.d.ts
-type Props$2 = {
+type Props$3 = {
   start?: Date;
 };
 declare class MemoryFunnelClock extends FunnelClock {
   private current;
-  constructor(props?: Props$2);
+  constructor(props?: Props$3);
   now(): Date;
   set(date: Date): void;
   advance(ms: number): void;
@@ -1715,13 +1688,13 @@ declare class NodeFunnelIdGenerator extends FunnelIdGenerator {
 }
 //#endregion
 //#region lib/engine/id/memory-id-generator.d.ts
-type Props$1 = {
+type Props$2 = {
   prefix?: string;
 };
 declare class MemoryFunnelIdGenerator extends FunnelIdGenerator {
   private counter;
   private readonly prefix;
-  constructor(props?: Props$1);
+  constructor(props?: Props$2);
   generate(): string;
 }
 //#endregion
@@ -1738,7 +1711,7 @@ declare class NodeFunnelTokenPrompter extends FunnelTokenPrompter {
 }
 //#endregion
 //#region lib/engine/token-prompter/memory-token-prompter.d.ts
-type Props = {
+type Props$1 = {
   answers?: Record<string, string>;
 };
 /**
@@ -1748,10 +1721,82 @@ type Props = {
 declare class MemoryFunnelTokenPrompter extends FunnelTokenPrompter {
   private readonly answers;
   readonly asked: string[];
-  constructor(props?: Props);
+  constructor(props?: Props$1);
   promptSecret(label: string): Promise<string>;
 }
 //#endregion
+//#region lib/gateway/sqlite-funnel-event-log.d.ts
+type Props = {
+  /** 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 `FunnelEventLog`. One indexed table holds every broadcaster
+ * event with `channel_id` and `connector_id` as dedicated columns, so
+ * per-channel and per-connector replay is an indexed range scan.
+ *
+ * Concurrency: `seq` is `INTEGER PRIMARY KEY`, so SQLite assigns it
+ * atomically. The broadcaster owns its own offset counter at runtime
+ * (seeded from `findMaxOffset()` at startup); each broadcaster event
+ * flows in here via `record()` with that pre-assigned offset, which the
+ * sink stores via `write()` — PK uniqueness catches double-emit bugs.
+ *
+ * System events (gateway lifecycle, channel connect/disconnect, etc.) do
+ * NOT go through this store. They are diagnostic only and live in
+ * `FunnelLogger`'s file so the seq space here stays exclusive to
+ * broadcaster traffic. This is what makes the broadcaster's seq seeding
+ * (`getMaxSeq()` at startup) correct without per-event coordination.
+ */
+declare class SqliteFunnelEventLog extends FunnelEventLog {
+  private readonly sink;
+  private readonly now;
+  constructor(props: Props);
+  /**
+   * Persist a broadcaster-driven event with its assigned offset. Caller
+   * (the gateway-server) supplies the offset from `broadcaster.broadcast()`
+   * so this store and the broadcaster's in-memory ring stay aligned.
+   */
+  record(record: FunnelEventRecord): 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/memory-funnel-event-log.d.ts
+/**
+ * In-process `FunnelEventLog` backed by a plain array. Used by tests and by
+ * embedders that do not need durability — replay works within the process
+ * lifetime but is lost when the process exits. Unlike the SQLite log it does
+ * not truncate content or prune, so it is not meant for unbounded production
+ * traffic.
+ */
+declare class MemoryFunnelEventLog extends FunnelEventLog {
+  private readonly events;
+  constructor();
+  record(record: FunnelEventRecord): void;
+  loadSince(since: number): ReplayableEvent[];
+  findMaxOffset(): number;
+  close(): void;
+}
+//#endregion
 //#region lib/cli/factory.d.ts
 type Env = {
   Variables: {
@@ -4386,4 +4431,4 @@ ${string}`;
 //#region lib/tui/tui.d.ts
 declare function launchTui(funnel: Funnel): Promise<void>;
 //#endregion
-export { AliveStub, AttachOptions, BroadcastEvent, BroadcastSubscriber, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelServerOptions, ChannelSpec, ConnectorConfig, ConnectorSpec, ConnectorSyncOutcome, 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, FunnelDotenvReader, FunnelEvent, FunnelEventStore, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSessions, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, type GatewayEmitInput, type GatewayRouteDeps, type Env$1 as GatewayServerEnv, GhConnectorConfig, LOCAL_CONFIG_FILENAME, LOCAL_ENV_FILENAME, LaunchOptions, ListListenersResult, ListenerEntry, ListenerOpResult, LocalConfig, LocalConfigSyncResult, LogEntry, MemoryFunnelClock, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, NotifyFn, OnFunnelError, ProcessListStub, ProcessSnapshot, ProfileConfig, ProfileSpec, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleListenerOptions, Settings, SlackConnectorConfig, SlackListenerOptions, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, app as cliApp, connectorConfigSchema, connectorSpecSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, launchTui, localConfigSchema, profileConfigSchema, profileSpecSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };
+export { AliveStub, AttachOptions, BroadcastEvent, BroadcastSubscriber, ChannelConfig, ChannelConnectorView, ChannelDeliveryMode, ChannelServerOptions, ChannelSpec, ConnectorConfig, ConnectorSpec, ConnectorSyncOutcome, 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, FunnelDotenvReader, FunnelEvent, FunnelEventLog, FunnelEventRecord, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, type GatewayEmitInput, type GatewayRouteDeps, type Env$1 as GatewayServerEnv, GhConnectorConfig, LOCAL_CONFIG_FILENAME, LOCAL_ENV_FILENAME, LaunchOptions, ListListenersResult, ListenerEntry, ListenerOpResult, LocalConfig, LocalConfigSyncResult, LogEntry, MemoryFunnelClock, MemoryFunnelEventLog, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MemoryProcessCall, MemoryProcessHandler, MemoryProcessResponse, MemoryProcessSyncHandler, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, NotifyFn, OnFunnelError, ProcessListStub, ProcessSnapshot, ProfileConfig, ProfileSpec, PublishRequest, PublishResponse, PublishResult, ReplayableEvent, RunOptions, RunResult, SETTINGS_PATH, SETTINGS_VERSION, ScheduleCatchupPolicy, ScheduleConnectorConfig, ScheduleEntry, ScheduleListenerOptions, Settings, SlackConnectorConfig, SlackListenerOptions, SlackProcessed, SlackProcessedEmit, SlackProcessedSkip, SlackRawEvent, SqliteFunnelEventLog, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, app as cliApp, connectorConfigSchema, connectorSpecSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, launchTui, localConfigSchema, profileConfigSchema, profileSpecSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };