@interactive-inc/claude-funnel 0.19.0 → 0.20.1

package/dist/index.d.ts

@@ -63,7 +63,7 @@ type SlackListenerOptions = {
 type ScheduleListenerOptions = {
   onFired?: ScheduleOnFired;
 };
-type Deps$15 = {
+type Deps$16 = {
   fs?: FunnelFileSystem;
   process?: FunnelProcessRunner;
   logger?: FunnelLogger;
@@ -90,7 +90,7 @@ declare class FunnelConnectorFactory {
   private readonly dir;
   private readonly slackListenerOptions;
   private readonly scheduleListenerOptions;
-  constructor(deps?: Deps$15);
+  constructor(deps?: Deps$16);
   createListener(channelId: string, config: ConnectorConfig): FunnelConnectorListener;
   createAdapter(config: ConnectorConfig): FunnelConnectorAdapter | null;
   connectorDir(channelId: string, connectorId: string): string;
@@ -152,6 +152,7 @@ declare const channelConfigSchema: z.ZodObject<{
   }>>;
   options: z.ZodDefault<z.ZodArray<z.ZodString>>;
   env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+  resume: z.ZodDefault<z.ZodBoolean>;
   connectors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
     id: z.ZodString;
     name: z.ZodString;
@@ -212,6 +213,7 @@ declare const settingsSchema: z.ZodObject<{
     }>>;
     options: z.ZodDefault<z.ZodArray<z.ZodString>>;
     env: z.ZodDefault<z.ZodRecord<z.ZodString, z.ZodString>>;
+    resume: z.ZodDefault<z.ZodBoolean>;
     connectors: z.ZodDefault<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
       id: z.ZodString;
       name: z.ZodString;
@@ -268,7 +270,7 @@ declare abstract class FunnelSettingsReader {
 }
 //#endregion
 //#region lib/engine/channels/channels.d.ts
-type Deps$14 = {
+type Deps$15 = {
   store: FunnelSettingsReader;
   factory: FunnelConnectorFactory;
   profileChecker: ProfileChannelChecker;
@@ -311,7 +313,7 @@ declare class FunnelChannels {
   private readonly profileChecker;
   private readonly clock;
   private readonly idGenerator;
-  constructor(deps: Deps$14);
+  constructor(deps: Deps$15);
   list(): ChannelConfig[];
   get(name: string): ChannelConfig | null;
   getById(id: string): ChannelConfig | null;
@@ -320,8 +322,10 @@ declare class FunnelChannels {
     delivery?: ChannelDeliveryMode;
     options?: string[];
     env?: Record<string, string>;
+    resume?: boolean;
   }): ChannelConfig;
   setDelivery(name: string, delivery: ChannelDeliveryMode): void;
+  setResume(name: string, resume: boolean): void;
   setOptions(name: string, options: string[]): void;
   setEnv(name: string, env: Record<string, string>): void;
   remove(name: string): void;
@@ -373,7 +377,7 @@ type GatewayController = {
 //#region lib/engine/mcp/mcp.d.ts
 declare const FUNNEL_MCP_COMMAND = "funnel";
 declare const FUNNEL_MCP_NAME = "funnel";
-type Deps$13 = {
+type Deps$14 = {
   fs?: FunnelFileSystem;
 };
 /**
@@ -383,7 +387,7 @@ type Deps$13 = {
  */
 declare class FunnelMcp {
   private readonly fs;
-  constructor(deps?: Deps$13);
+  constructor(deps?: Deps$14);
   install(repoPath: string): void;
   uninstall(repoPath: string): void;
   findInstalledName(cwd: string): string | null;
@@ -392,6 +396,43 @@ declare class FunnelMcp {
   private writeConfig;
 }
 //#endregion
+//#region lib/engine/sessions/sessions.d.ts
+type Deps$13 = {
+  fs: FunnelFileSystem;
+  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 picks up the
+ * previous claude session via `--session-id <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.
+ *
+ * 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.
+ */
+declare class FunnelSessions {
+  private readonly fs;
+  private readonly idGenerator;
+  private readonly dir;
+  constructor(deps: Deps$13);
+  /** Returns the existing session id for (channelId, cwd) or generates and persists a new one. */
+  getOrCreate(channelId: string, cwd: string): string;
+  /** Returns the existing session id for (channelId, cwd) or null. */
+  get(channelId: string, cwd: string): string | null;
+  /** 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;
+}
+//#endregion
 //#region lib/engine/claude/claude.d.ts
 type LaunchOptions = {
   channel: string;
@@ -411,6 +452,7 @@ type Deps$12 = {
   channels: FunnelChannels;
   mcp: FunnelMcp;
   gateway: GatewayController;
+  sessions: FunnelSessions;
   process?: FunnelProcessRunner;
   fs?: FunnelFileSystem;
   logger?: FunnelLogger;
@@ -426,6 +468,7 @@ declare class FunnelClaude {
   private readonly channels;
   private readonly mcp;
   private readonly gateway;
+  private readonly sessions;
   private readonly process;
   private readonly fs;
   private readonly logger;
@@ -440,6 +483,12 @@ declare class FunnelClaude {
   private installCleanup;
   private isProcessAlive;
   private buildArgs;
+  /**
+   * Decides whether funnel should inject `--session-id`. We back off when
+   * the user already passed a session-shaping flag, since combining them
+   * would either confuse claude or override the explicit user intent.
+   */
+  private resolveSessionId;
   private buildEnv;
 }
 //#endregion
@@ -489,6 +538,7 @@ declare const channelSpecSchema: z.ZodObject<{
   name: z.ZodString;
   options: z.ZodOptional<z.ZodArray<z.ZodString>>;
   env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  resume: z.ZodOptional<z.ZodBoolean>;
   connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
     type: z.ZodLiteral<"slack">;
     name: z.ZodString;
@@ -521,6 +571,7 @@ declare const localConfigSchema: z.ZodObject<{
     name: z.ZodString;
     options: z.ZodOptional<z.ZodArray<z.ZodString>>;
     env: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+    resume: z.ZodOptional<z.ZodBoolean>;
     connectors: z.ZodOptional<z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
       type: z.ZodLiteral<"slack">;
       name: z.ZodString;
@@ -1326,6 +1377,8 @@ 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). */
@@ -4210,4 +4263,4 @@ ${string}`;
 //#region lib/tui/tui.d.ts
 declare function launchTui(funnel: Funnel): Promise<void>;
 //#endregion
-export { 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, 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, ProfileConfig, 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, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };
+export { 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, ProfileConfig, 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, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };

package/dist/index.js

@@ -2,7 +2,7 @@ import { i as FunnelDiscordAdapter, n as FunnelDiscordListener, t as discordConn
 import { n as FunnelLogger, r as FunnelConnectorListener, t as NodeFunnelLogger } from "./node-logger-DQz_BGOD.js";
 import { a as FunnelProcessRunner, i as NodeFunnelProcessRunner, n as FunnelGhListener, r as FunnelGhAdapter, t as ghConnectorSchema } from "./gh-connector-schema-CD5HIkrd.js";
 import { a as ScheduleStateStore, i as FunnelScheduleListener, n as scheduleConnectorSchema, o as NodeFunnelFileSystem, r as scheduleEntrySchema, s as FunnelFileSystem, t as scheduleCatchupPolicySchema } from "./schedule-connector-schema-FxP7LPlx.js";
-import { i as FunnelSlackAdapter, n as FunnelSlackListener, r as FunnelSlackEventProcessor, t as slackConnectorSchema } from "./slack-connector-schema-B4hsf3AY.js";
+import { i as FunnelSlackAdapter, n as FunnelSlackListener, r as FunnelSlackEventProcessor, t as slackConnectorSchema } from "./slack-connector-schema-BM9xshol.js";
 import { dirname, join, resolve } from "node:path";
 import { existsSync, mkdirSync, readFileSync } from "node:fs";
 import { z } from "zod";
@@ -54,6 +54,12 @@ const channelConfigSchema = z.object({
 	options: z.array(z.string()).default([]),
 	/** Env vars layered under the launched claude process. process.env wins on collision. */
 	env: z.record(z.string(), z.string()).default({}),
+	/**
+	* When true (the default), funnel injects `--session-id <uuid>` so that
+	* relaunching from the same cwd resumes the previous claude session.
+	* Set to false for channels that should always start a fresh session.
+	*/
+	resume: z.boolean().default(true),
 	connectors: z.array(connectorConfigSchema).default([])
 });
 const profileConfigSchema = z.object({
@@ -308,6 +314,7 @@ var FunnelChannels = class {
 			delivery: input.delivery ?? "fanout",
 			options: input.options ?? [],
 			env: input.env ?? {},
+			resume: input.resume ?? true,
 			connectors: []
 		};
 		settings.channels.push(channel);
@@ -320,6 +327,12 @@ var FunnelChannels = class {
 		channel.delivery = delivery;
 		this.store.write(settings);
 	}
+	setResume(name, resume) {
+		const settings = this.store.read();
+		const channel = this.requireChannel(settings, name);
+		channel.resume = resume;
+		this.store.write(settings);
+	}
 	setOptions(name, options) {
 		const settings = this.store.read();
 		const channel = this.requireChannel(settings, name);
@@ -551,6 +564,7 @@ var FunnelClaude = class {
 	channels;
 	mcp;
 	gateway;
+	sessions;
 	process;
 	fs;
 	logger;
@@ -559,6 +573,7 @@ var FunnelClaude = class {
 		this.channels = deps.channels;
 		this.mcp = deps.mcp;
 		this.gateway = deps.gateway;
+		this.sessions = deps.sessions;
 		this.process = deps.process ?? defaultProcess$2;
 		this.fs = deps.fs ?? defaultFs$3;
 		this.logger = deps.logger ?? defaultLogger$4;
@@ -582,7 +597,8 @@ var FunnelClaude = class {
 			this.writePidFile(options.profileName);
 			this.installCleanup(options.profileName);
 		}
-		const claudeArgs = this.buildArgs(channel.options, options.userArgs ?? [], cwd);
+		const sessionId = channel.resume ? this.resolveSessionId(channel.id, cwd, options.userArgs ?? []) : null;
+		const claudeArgs = this.buildArgs(channel.options, options.userArgs ?? [], cwd, sessionId);
 		const env = this.buildEnv(channel.id, channel.env);
 		this.logger.info(`claude launch`, {
 			channel: options.channel,
@@ -643,12 +659,26 @@ var FunnelClaude = class {
 		if (!state) return false;
 		return !state.startsWith("Z");
 	}
-	buildArgs(channelOptions, userArgs, cwd) {
+	buildArgs(channelOptions, userArgs, cwd, sessionId) {
 		const result = [...channelOptions, ...userArgs];
+		if (sessionId !== null) result.push("--session-id", sessionId);
 		const mcpName = this.mcp.findInstalledName(cwd);
 		if (mcpName && !result.includes("--dangerously-load-development-channels") && !result.includes("--channels")) result.push("--dangerously-load-development-channels", `server:${mcpName}`);
 		return result;
 	}
+	/**
+	* Decides whether funnel should inject `--session-id`. We back off when
+	* the user already passed a session-shaping flag, since combining them
+	* would either confuse claude or override the explicit user intent.
+	*/
+	resolveSessionId(channelId, cwd, userArgs) {
+		for (const arg of userArgs) {
+			if (arg === "-c" || arg === "--continue") return null;
+			if (arg === "--resume" || arg.startsWith("--resume=")) return null;
+			if (arg === "--session-id" || arg.startsWith("--session-id=")) return null;
+		}
+		return this.sessions.getOrCreate(channelId, cwd);
+	}
 	buildEnv(channelId, channelEnv) {
 		const env = {};
 		for (const [key, value] of Object.entries(channelEnv)) env[key] = value;
@@ -800,6 +830,13 @@ const channelSpecSchema = z.object({
 	options: z.array(z.string()).optional(),
 	/** Env vars layered under the launched claude process. process.env wins on collision. */
 	env: z.record(z.string(), z.string()).optional(),
+	/**
+	* When true (the default), funnel injects `--session-id <uuid>` so that
+	* relaunching from the same cwd resumes the previous claude session
+	* without bleeding into other channels or workspaces. Set to false for
+	* channels that should always start a fresh session.
+	*/
+	resume: z.boolean().optional(),
 	connectors: z.array(connectorSpecSchema).optional()
 });
 const localConfigSchema = z.object({
@@ -936,16 +973,19 @@ var FunnelLocalConfigSync = class {
 	}
 	async ensure(channel, cwd) {
 		const existing = this.channels.get(channel.name);
+		const nextResume = channel.resume ?? true;
 		if (!existing) this.channels.add({
 			name: channel.name,
 			options: channel.options ?? [],
-			env: channel.env ?? {}
+			env: channel.env ?? {},
+			resume: nextResume
 		});
 		else {
 			const nextOptions = channel.options ?? [];
 			const nextEnv = channel.env ?? {};
 			if (!arraysEqual(existing.options, nextOptions)) this.channels.setOptions(channel.name, nextOptions);
 			if (!recordsEqual(existing.env, nextEnv)) this.channels.setEnv(channel.name, nextEnv);
+			if (existing.resume !== nextResume) this.channels.setResume(channel.name, nextResume);
 		}
 		if (channel.connectors === void 0) return {
 			touched: [],
@@ -1429,6 +1469,81 @@ var FunnelProfiles = class {
 	}
 };
 //#endregion
+//#region lib/engine/sessions/sessions.ts
+const sessionsMapSchema = z.record(z.string(), z.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 picks up the
+* previous claude session via `--session-id <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.
+*
+* 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.
+*/
+var FunnelSessions = class {
+	fs;
+	idGenerator;
+	dir;
+	constructor(deps) {
+		this.fs = deps.fs;
+		this.idGenerator = deps.idGenerator;
+		this.dir = deps.dir;
+		Object.freeze(this);
+	}
+	/** Returns the existing session id for (channelId, cwd) or generates and persists a new one. */
+	getOrCreate(channelId, cwd) {
+		const map = this.readMap(channelId);
+		const existing = map[cwd];
+		if (existing) return existing;
+		const sessionId = this.idGenerator.generate();
+		map[cwd] = sessionId;
+		this.writeMap(channelId, map);
+		return sessionId;
+	}
+	/** Returns the existing session id for (channelId, cwd) or null. */
+	get(channelId, cwd) {
+		return this.readMap(channelId)[cwd] ?? null;
+	}
+	/** Drops the recorded session id for (channelId, cwd). No-op if absent. */
+	clear(channelId, cwd) {
+		const map = this.readMap(channelId);
+		if (!(cwd in map)) return;
+		delete map[cwd];
+		this.writeMap(channelId, map);
+	}
+	/** Drops the whole session map for the channel (e.g. when the channel is deleted). */
+	clearAll(channelId) {
+		const path = this.pathFor(channelId);
+		if (this.fs.existsSync(path)) this.fs.unlink(path);
+	}
+	readMap(channelId) {
+		const path = this.pathFor(channelId);
+		if (!this.fs.existsSync(path)) return {};
+		const raw = this.fs.readFileSync(path);
+		try {
+			const parsed = sessionsMapSchema.safeParse(JSON.parse(raw));
+			return parsed.success ? parsed.data : {};
+		} catch {
+			return {};
+		}
+	}
+	writeMap(channelId, map) {
+		const path = this.pathFor(channelId);
+		const channelDir = this.channelDir(channelId);
+		if (!this.fs.existsSync(channelDir)) this.fs.mkdirSync(channelDir, { recursive: true });
+		this.fs.writeFileSync(path, `${JSON.stringify(map, null, 2)}\n`);
+	}
+	channelDir(channelId) {
+		return join(this.dir, "channels", channelId);
+	}
+	pathFor(channelId) {
+		return join(this.channelDir(channelId), "sessions.json");
+	}
+};
+//#endregion
 //#region lib/engine/token-prompter/node-token-prompter.ts
 const STAR = "*";
 const CR = "\r";
@@ -3361,6 +3476,15 @@ var Funnel = class Funnel {
 		if (!this.memos.profiles) this.memos.profiles = new FunnelProfiles({ store: this.store });
 		return this.memos.profiles;
 	}
+	/** Per-(channel, cwd) claude session-id store. Backs `--session-id` injection on launch. */
+	get sessions() {
+		if (!this.memos.sessions) this.memos.sessions = new FunnelSessions({
+			fs: this.fs,
+			idGenerator: this.idGenerator,
+			dir: this.paths.dir
+		});
+		return this.memos.sessions;
+	}
 	/** Reads `funnel.json` from a cwd. `fnl claude` consults it before falling back to the default profile. */
 	get localConfig() {
 		if (!this.memos.localConfig) this.memos.localConfig = new FunnelLocalConfig({ fs: this.fs });
@@ -3396,6 +3520,7 @@ var Funnel = class Funnel {
 			channels: this.channels,
 			mcp: this.mcp,
 			gateway: this.gateway,
+			sessions: this.sessions,
 			fs: this.fs,
 			process: this.process,
 			logger: this.logger,
@@ -6930,4 +7055,4 @@ async function launchTui(funnel) {
 	});
 }
 //#endregion
-export { DEFAULT_GATEWAY_TOKEN_PATH, FUNNEL_DIR, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelDotenvReader, FunnelEventStore, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, LOCAL_ENV_FILENAME, MemoryFunnelClock, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, SETTINGS_PATH, SETTINGS_VERSION, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, app as cliApp, connectorConfigSchema, connectorSpecSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, launchTui, localConfigSchema, profileConfigSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };
+export { DEFAULT_GATEWAY_TOKEN_PATH, FUNNEL_DIR, FUNNEL_MCP_COMMAND, FUNNEL_MCP_NAME, Funnel, FunnelBroadcaster, FunnelChannelPublisher, FunnelChannels, FunnelClaude, FunnelClock, FunnelConnectorFactory, FunnelConnectorListener, FunnelDotenvReader, FunnelEventStore, FunnelFileSystem, FunnelGateway, FunnelGatewayServer, FunnelGatewayToken, FunnelIdGenerator, FunnelListenerSupervisor, FunnelListenersClient, FunnelLocalConfig, FunnelLocalConfigSync, FunnelLogger, FunnelMcp, FunnelProcessRunner, FunnelProfiles, FunnelSessions, FunnelSettingsReader, FunnelSettingsStore, FunnelSlackEventProcessor, FunnelTokenPrompter, LOCAL_CONFIG_FILENAME, LOCAL_ENV_FILENAME, MemoryFunnelClock, MemoryFunnelFileSystem, MemoryFunnelIdGenerator, MemoryFunnelLogger, MemoryFunnelProcessRunner, MemoryFunnelTokenPrompter, MockFunnelSettingsReader, NodeFunnelClock, NodeFunnelFileSystem, NodeFunnelIdGenerator, NodeFunnelLogger, NodeFunnelProcessRunner, NodeFunnelTokenPrompter, NoopFunnelLogger, SETTINGS_PATH, SETTINGS_VERSION, channelConfigSchema, channelDeliveryModeSchema, channelSpecSchema, app as cliApp, connectorConfigSchema, connectorSpecSchema, createCliApp, createSettings, discordConnectorSchema, factory, funnelEventSchema, funnelJsonSchema, ghConnectorSchema, launchTui, localConfigSchema, profileConfigSchema, publishRequestSchema, publishResponseSchema, queryToCliArgs, scheduleCatchupPolicySchema, scheduleConnectorSchema, scheduleEntrySchema, settingsSchema, slackConnectorSchema, startChannelServer, toRequest };

package/dist/{slack-connector-schema-B4hsf3AY.js → slack-connector-schema-BM9xshol.js}

@@ -9,6 +9,24 @@ const toRecord = (value) => {
 	for (const [key, val] of Object.entries(value)) result[key] = val;
 	return result;
 };
+/**
+* Recognises errors that @slack/web-api throws for Slack-side API failures
+* (e.g. `cant_delete_message`, `channel_not_found`, rate limits). Every such
+* error carries `code: "slack_webapi_*"` and a `data` field holding the raw
+* Slack response with `ok: false`. We unwrap to that response so the caller
+* receives a structured failure instead of having the gateway translate it
+* into an opaque HTTP 500.
+*/
+const slackErrorResponse = (error) => {
+	if (!error || typeof error !== "object") return null;
+	if (!("code" in error)) return null;
+	const code = error.code;
+	if (typeof code !== "string" || !code.startsWith("slack_webapi_")) return null;
+	if (!("data" in error)) return null;
+	const data = error.data;
+	if (!data || typeof data !== "object") return null;
+	return data;
+};
 var FunnelSlackAdapter = class extends FunnelConnectorAdapter {
 	client;
 	constructor(deps) {
@@ -18,7 +36,13 @@ var FunnelSlackAdapter = class extends FunnelConnectorAdapter {
 	}
 	async call(input) {
 		const body = input.body !== null && typeof input.body === "object" ? toRecord(input.body) : {};
-		return await this.client.apiCall(input.path, body);
+		try {
+			return await this.client.apiCall(input.path, body);
+		} catch (error) {
+			const slackResponse = slackErrorResponse(error);
+			if (slackResponse) return slackResponse;
+			throw error;
+		}
 	}
 };
 //#endregion

package/funnel.schema.json

@@ -29,6 +29,9 @@
               "type": "string"
             }
           },
+          "resume": {
+            "type": "boolean"
+          },
           "connectors": {
             "type": "array",
             "items": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@interactive-inc/claude-funnel",
-  "version": "0.19.0",
+  "version": "0.20.1",
   "description": "Hub CLI that routes external events (Slack / GitHub / Discord) to Claude Code agents through subscription channels over MCP.",
   "keywords": [
     "bun",