@friendlyrobot/discord-pi-agent 0.4.7 → 0.5.0

package/dist/agent-service.d.ts

@@ -1,3 +1,4 @@
+import { type AgentSession } from "@mariozechner/pi-coding-agent";
 import type { AgentStatus, ResolvedDiscordPiBridgeConfig, ThinkingLevel } from "./types";
 export declare class AgentService {
     private readonly config;
@@ -8,6 +9,9 @@ export declare class AgentService {
     private session;
     constructor(config: ResolvedDiscordPiBridgeConfig);
     initialize(): Promise<void>;
+    getSession(): AgentSession | null;
+    getAgentDir(): string;
+    createSession(sessionDir: string): Promise<AgentSession>;
     prompt(text: string): Promise<string>;
     reloadResources(): Promise<string>;
     compact(): Promise<string>;
@@ -16,8 +20,10 @@ export declare class AgentService {
     shutdown(): Promise<void>;
     private createOrResumeSession;
     private ensureConfiguredModel;
+    private ensureModelForSession;
     private requireSession;
     private applyConfiguredThinkingLevel;
+    private applyConfiguredThinkingLevelForSession;
     getThinkingLevel(): {
         current: ThinkingLevel;
         available: ThinkingLevel[];

package/dist/commands.d.ts

@@ -1,8 +1,15 @@
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
 import type { AgentService } from "./agent-service";
 import type { PromptQueue } from "./prompt-queue";
-type CommandResult = {
+export type CommandResult = {
     handled: boolean;
     response?: string;
+    /** Set to true when the command wants to archive the current thread. */
+    archive?: boolean;
 };
-export declare function handleCommand(input: string, agentService: AgentService, promptQueue: PromptQueue): Promise<CommandResult>;
-export {};
+export type CommandContext = {
+    agentService: AgentService;
+    promptQueue: PromptQueue;
+    session?: AgentSession;
+};
+export declare function handleCommand(input: string, ctx: CommandContext): Promise<CommandResult>;

package/dist/config.d.ts

@@ -1,3 +1,10 @@
-import type { DiscordPiBridgeConfig, ResolvedDiscordPiBridgeConfig } from "./types";
+import type { DiscordGatewayConfig, DiscordPiBridgeConfig, ResolvedDiscordGatewayConfig, ResolvedDiscordPiBridgeConfig } from "./types";
 export declare function resolveConfig(config: DiscordPiBridgeConfig): ResolvedDiscordPiBridgeConfig;
 export declare function loadDiscordPiBridgeConfigFromEnv(overrides?: Partial<DiscordPiBridgeConfig>): ResolvedDiscordPiBridgeConfig;
+/**
+ * Load gateway config from env vars + overrides.
+ * Preserves gateway-specific fields (forum channels, etc.) that
+ * loadDiscordPiBridgeConfigFromEnv would drop.
+ */
+export declare function loadDiscordGatewayConfigFromEnv(overrides?: Partial<DiscordGatewayConfig>): ResolvedDiscordGatewayConfig;
+export declare function resolveGatewayConfig(config: DiscordGatewayConfig): ResolvedDiscordGatewayConfig;

package/dist/discord-gateway-client.d.ts

@@ -0,0 +1,11 @@
+import { Client } from "discord.js";
+import type { AgentService } from "./agent-service";
+import type { SessionRegistry } from "./session-registry";
+import type { ResolvedDiscordPiBridgeConfig } from "./types";
+export type GatewayAuthConfig = {
+    discordAllowedUserId: string;
+    discordAllowedForumChannelIds: string[];
+    discordAllowedUserIds: string[];
+    startupMessage: string | false;
+};
+export declare function startGatewayClient(config: ResolvedDiscordPiBridgeConfig, agentService: AgentService, sessionRegistry: SessionRegistry, authConfig: GatewayAuthConfig): Promise<Client>;

package/dist/index.d.ts

@@ -1,5 +1,13 @@
-import type { DiscordPiBridge, DiscordPiBridgeConfig } from "./types";
+import type { DiscordGateway, DiscordGatewayConfig, DiscordPiBridge, DiscordPiBridgeConfig } from "./types";
 export { buildTimeContextPrompt, type TimeContextPromptOptions, } from "./prompt-context";
-export { loadDiscordPiBridgeConfigFromEnv, resolveConfig } from "./config";
-export type { AgentStatus, DiscordPiBridge, DiscordPiBridgeConfig, PromptTransform, ResolvedDiscordPiBridgeConfig, } from "./types";
+export { loadDiscordPiBridgeConfigFromEnv, loadDiscordGatewayConfigFromEnv, resolveConfig, } from "./config";
+export type { AgentStatus, DiscordGateway, DiscordGatewayConfig, DiscordPiBridge, DiscordPiBridgeConfig, PromptTransform, ResolvedDiscordPiBridgeConfig, } from "./types";
+/**
+ * Start the unified Discord gateway. Supports DM and forum thread sessions
+ * out of the box. Set discordAllowedForumChannelIds to enable forum support.
+ */
+export declare function startDiscordGateway(config: DiscordGatewayConfig): Promise<DiscordGateway>;
+/**
+ * Legacy DM-only entry point. Now a thin wrapper over startDiscordGateway.
+ */
 export declare function startDiscordPiBridge(config: DiscordPiBridgeConfig): Promise<DiscordPiBridge>;

package/dist/index.js

@@ -180,6 +180,32 @@ class AgentService {
     await this.createOrResumeSession();
     await this.ensureConfiguredModel();
   }
+  getSession() {
+    return this.session;
+  }
+  getAgentDir() {
+    return this.config.agentDir;
+  }
+  async createSession(sessionDir) {
+    await fs.mkdir(sessionDir, { recursive: true });
+    const { session } = await createAgentSession({
+      cwd: this.config.cwd,
+      agentDir: this.config.agentDir,
+      authStorage: this.authStorage,
+      modelRegistry: this.modelRegistry,
+      resourceLoader: this.resourceLoader,
+      settingsManager: this.settingsManager,
+      sessionManager: SessionManager.continueRecent(this.config.cwd, sessionDir),
+      thinkingLevel: this.config.thinkingLevel
+    });
+    console.log("[agent] scoped session created", {
+      sessionDir,
+      sessionId: session.sessionId,
+      sessionFile: session.sessionFile
+    });
+    await this.ensureModelForSession(session);
+    return session;
+  }
   async prompt(text) {
     const session = this.requireSession();
     const transformedPrompt = await this.config.promptTransform(text);
@@ -263,7 +289,9 @@ class AgentService {
     });
   }
   async ensureConfiguredModel() {
-    const session = this.requireSession();
+    await this.ensureModelForSession(this.requireSession());
+  }
+  async ensureModelForSession(session) {
     const desiredModel = this.modelRegistry.find(this.config.modelProvider, this.config.modelId);
     const availableModels = await this.modelRegistry.getAvailable();
     console.log("[agent] available models", {
@@ -286,7 +314,7 @@ class AgentService {
       to: `${desiredModel.provider}/${desiredModel.id}`
     });
     await session.setModel(desiredModel);
-    await this.applyConfiguredThinkingLevel();
+    await this.applyConfiguredThinkingLevelForSession(session);
   }
   requireSession() {
     if (!this.session) {
@@ -295,7 +323,9 @@ class AgentService {
     return this.session;
   }
   async applyConfiguredThinkingLevel() {
-    const session = this.requireSession();
+    await this.applyConfiguredThinkingLevelForSession(this.requireSession());
+  }
+  async applyConfiguredThinkingLevelForSession(session) {
     if (session.supportsThinking()) {
       const available = session.getAvailableThinkingLevels();
       if (available.includes(this.config.thinkingLevel)) {
@@ -377,6 +407,17 @@ function loadDiscordPiBridgeConfigFromEnv(overrides = {}) {
     shutdownOnSignals: overrides.shutdownOnSignals
   });
 }
+function loadDiscordGatewayConfigFromEnv(overrides = {}) {
+  const base = loadDiscordPiBridgeConfigFromEnv(overrides);
+  return {
+    ...base,
+    discordAllowedForumChannelIds: overrides.discordAllowedForumChannelIds ?? parseStringArrayFromEnv("DISCORD_FORUM_CHANNEL_IDS") ?? [],
+    discordAllowedUserIds: overrides.discordAllowedUserIds ?? parseStringArrayFromEnv("DISCORD_ALLOWED_USER_IDS") ?? [
+      base.discordAllowedUserId
+    ],
+    sessionIdleTimeoutMs: overrides.sessionIdleTimeoutMs ?? parseOptionalIntFromEnv("DISCORD_SESSION_IDLE_TIMEOUT_MS") ?? null
+  };
+}
 function readRequiredValue(name, value) {
   const trimmedValue = value.trim();
   if (!trimmedValue) {
@@ -395,6 +436,17 @@ function readStartupMessageFromEnv() {
   }
   return trimmedValue;
 }
+function resolveGatewayConfig(config) {
+  const base = resolveConfig(config);
+  return {
+    ...base,
+    discordAllowedForumChannelIds: config.discordAllowedForumChannelIds ?? [],
+    discordAllowedUserIds: config.discordAllowedUserIds ?? [
+      base.discordAllowedUserId
+    ],
+    sessionIdleTimeoutMs: config.sessionIdleTimeoutMs ?? null
+  };
+}
 function parseThinkingLevel(value) {
   if (!value) {
     return;
@@ -416,8 +468,23 @@ function parseThinkingLevel(value) {
 function identityPromptTransform(input) {
   return input;
 }
+function parseStringArrayFromEnv(key) {
+  const value = process.env[key];
+  if (!value) {
+    return;
+  }
+  return value.split(",").map((id) => id.trim()).filter(Boolean);
+}
+function parseOptionalIntFromEnv(key) {
+  const value = process.env[key];
+  if (!value) {
+    return;
+  }
+  const parsed = parseInt(value, 10);
+  return Number.isNaN(parsed) ? undefined : parsed;
+}
 
-// src/discord-client.ts
+// src/discord-gateway-client.ts
 import {
   ChannelType,
   Client,
@@ -427,12 +494,43 @@ import {
 } from "discord.js";
 
 // src/commands.ts
-async function handleCommand(input, agentService, promptQueue) {
+function getSessionStatusText(session, promptQueue) {
+  const model = session.model ? `${session.model.provider}/${session.model.id}` : "(no model selected)";
+  const contextUsage = session.getContextUsage();
+  const contextLine = contextUsage ? contextUsage.tokens === null || contextUsage.percent === null ? `context: ?/${contextUsage.contextWindow}` : `context: ${contextUsage.tokens}/${contextUsage.contextWindow} (${Math.round(contextUsage.percent)}%)` : "context: (unavailable)";
+  const thinkingInfo = session.supportsThinking() ? `thinking: ${session.thinkingLevel} (available: ${session.getAvailableThinkingLevels().join(", ")})` : "thinking: not supported";
+  const queueStatus = promptQueue.getSnapshot();
+  return [
+    `model: ${model}`,
+    `session-id: ${session.sessionId}`,
+    `session-file: ${session.sessionFile ?? "(none)"}`,
+    `streaming: ${session.isStreaming}`,
+    thinkingInfo,
+    contextLine,
+    `queue-pending: ${queueStatus.pending}`,
+    `queue-busy: ${queueStatus.busy}`
+  ].join(`
+`);
+}
+function getThinkingInfo(session) {
+  if (!session.supportsThinking()) {
+    return { current: "off", available: [], supported: false };
+  }
+  return {
+    current: session.thinkingLevel,
+    available: session.getAvailableThinkingLevels(),
+    supported: true
+  };
+}
+async function handleCommand(input, ctx) {
+  const { agentService, promptQueue, session } = ctx;
   const trimmed = input.trim();
   if (!trimmed.startsWith("!")) {
     return { handled: false };
   }
   if (trimmed === "!help") {
+    const extraCommands = session ? `
+!archive - archive this thread and end the session` : "";
     return {
       handled: true,
       response: [
@@ -443,35 +541,49 @@ async function handleCommand(input, agentService, promptQueue) {
         "!compact - compact the persistent session",
         "!reset-session - start a fresh persistent session",
         "!reload - reload resources (AGENTS.md, extensions, skills, etc.)",
-        "Any other DM text goes to the persistent agent session."
-      ].join(`
+        extraCommands,
+        "Any other text goes to the agent session."
+      ].filter(Boolean).join(`
 `)
     };
   }
+  if (trimmed === "!archive") {
+    if (!session) {
+      return {
+        handled: true,
+        response: "!archive is only available in forum threads."
+      };
+    }
+    return {
+      handled: true,
+      archive: true,
+      response: "Archiving thread and shutting down session."
+    };
+  }
   if (trimmed === "!status") {
-    const agentStatus = agentService.getStatus();
-    const queueStatus = promptQueue.getSnapshot();
-    const contextUsage = agentStatus.contextUsage;
-    const contextLine = contextUsage ? contextUsage.tokens === null || contextUsage.percent === null ? `context: ?/${contextUsage.contextWindow}` : `context: ${contextUsage.tokens}/${contextUsage.contextWindow} (${Math.round(contextUsage.percent)}%)` : "context: (unavailable)";
+    const effectiveSession = session ?? agentService.getSession();
+    if (!effectiveSession) {
+      return {
+        handled: true,
+        response: "No active session."
+      };
+    }
     return {
       handled: true,
-      response: [
-        `model: ${agentStatus.model}`,
-        `session-id: ${agentStatus.sessionId}`,
-        `session-file: ${agentStatus.sessionFile ?? "(none)"}`,
-        `streaming: ${agentStatus.streaming}`,
-        agentStatus.thinkingInfo,
-        contextLine,
-        `queue-pending: ${queueStatus.pending}`,
-        `queue-busy: ${queueStatus.busy}`
-      ].join(`
-`)
+      response: getSessionStatusText(effectiveSession, promptQueue)
     };
   }
   if (trimmed === "!thinking" || trimmed.startsWith("!thinking ")) {
+    const effectiveSession = session ?? agentService.getSession();
+    if (!effectiveSession) {
+      return {
+        handled: true,
+        response: "No active session."
+      };
+    }
     const parts = trimmed.split(" ");
     if (parts.length === 1) {
-      const info = agentService.getThinkingLevel();
+      const info = getThinkingInfo(effectiveSession);
       if (!info.supported) {
         return {
           handled: true,
@@ -489,17 +601,38 @@ async function handleCommand(input, agentService, promptQueue) {
       };
     }
     const requestedLevel = parts[1];
-    const result = agentService.setThinkingLevel(requestedLevel);
+    if (!effectiveSession.supportsThinking()) {
+      return {
+        handled: true,
+        response: "Current model does not support reasoning/thinking."
+      };
+    }
+    const available = effectiveSession.getAvailableThinkingLevels();
+    if (!available.includes(requestedLevel)) {
+      return {
+        handled: true,
+        response: `Invalid thinking level "${requestedLevel}" for current model. Available: ${available.join(", ")}`
+      };
+    }
+    effectiveSession.setThinkingLevel(requestedLevel);
     return {
       handled: true,
-      response: result
+      response: `Thinking level set to "${requestedLevel}".`
     };
   }
   if (trimmed === "!compact") {
+    const effectiveSession = session ?? agentService.getSession();
+    if (!effectiveSession) {
+      return {
+        handled: true,
+        response: "No active session."
+      };
+    }
     return {
       handled: true,
       response: await promptQueue.enqueue(async () => {
-        return agentService.compact();
+        await effectiveSession.compact();
+        return `Compaction finished for session ${effectiveSession.sessionId}.`;
       })
     };
   }
@@ -512,6 +645,17 @@ async function handleCommand(input, agentService, promptQueue) {
     };
   }
   if (trimmed === "!reset-session") {
+    if (session) {
+      return {
+        handled: true,
+        response: await promptQueue.enqueue(async () => {
+          const previousSession = session;
+          await previousSession.abort();
+          previousSession.dispose();
+          return `Session reset. Old session kept at ${previousSession.sessionFile ?? "(unknown path)"}. Use !archive to archive the thread and start fresh.`;
+        })
+      };
+    }
     return {
       handled: true,
       response: await promptQueue.enqueue(async () => {
@@ -556,77 +700,184 @@ function chunkMessage(text, maxChunkSize = SAFE_MESSAGE_LIMIT) {
   return chunks.map((chunk) => chunk.slice(0, DISCORD_MESSAGE_LIMIT));
 }
 
-// src/discord-client.ts
-async function startDiscordClient(config, agentService, promptQueue) {
+// src/discord-gateway-client.ts
+function resolveScope(message) {
+  if (message.channel.type === ChannelType.DM) {
+    return "dm";
+  }
+  if (message.channel.isThread()) {
+    return `thread:${message.channel.id}`;
+  }
+  return null;
+}
+function isAuthorized(message, scope, authConfig) {
+  if (scope === "dm") {
+    return message.author.id === authConfig.discordAllowedUserId;
+  }
+  if (scope.startsWith("thread:")) {
+    const channel = message.channel;
+    if (!channel.isThread()) {
+      return false;
+    }
+    const parentId = channel.parentId;
+    if (!parentId || !authConfig.discordAllowedForumChannelIds.includes(parentId)) {
+      return false;
+    }
+    return authConfig.discordAllowedUserIds.includes(message.author.id);
+  }
+  return false;
+}
+var TYPING_INTERVAL_MS = 8000;
+function startTypingInterval(channel) {
+  channel.sendTyping();
+  return setInterval(() => {
+    channel.sendTyping();
+  }, TYPING_INTERVAL_MS);
+}
+function stopTypingInterval(interval) {
+  if (interval) {
+    clearInterval(interval);
+  }
+}
+async function sendReply(message, text) {
+  const channel = message.channel;
+  if (!channel.isSendable()) {
+    console.log("[gateway] reply skipped, channel not sendable", {
+      messageId: message.id
+    });
+    return;
+  }
+  const chunks = chunkMessage(text);
+  console.log("[gateway] sending reply", {
+    messageId: message.id,
+    chunkCount: chunks.length,
+    textLength: text.length
+  });
+  const [firstChunk, ...remainingChunks] = chunks;
+  if (!firstChunk) {
+    return;
+  }
+  await message.reply(firstChunk);
+  for (const chunk of remainingChunks) {
+    await channel.send(chunk);
+  }
+}
+async function startGatewayClient(config, agentService, sessionRegistry, authConfig) {
   const client = new Client({
     intents: [
       GatewayIntentBits.DirectMessages,
+      GatewayIntentBits.Guilds,
+      GatewayIntentBits.GuildMessages,
       GatewayIntentBits.MessageContent
     ],
     partials: [Partials.Channel]
   });
   client.once(Events.ClientReady, async (readyClient) => {
-    console.log(`[discord] logged in as ${readyClient.user.tag}`);
-    if (!config.startupMessage) {
+    console.log(`[gateway] logged in as ${readyClient.user.tag}`);
+    if (!authConfig.startupMessage) {
       return;
     }
     try {
-      const user = await readyClient.users.fetch(config.discordAllowedUserId);
+      const user = await readyClient.users.fetch(authConfig.discordAllowedUserId);
       const dmChannel = await user.createDM();
-      await dmChannel.send(config.startupMessage);
-      console.log("[discord] sent startup dm", {
-        userId: config.discordAllowedUserId
+      await dmChannel.send(authConfig.startupMessage);
+      console.log("[gateway] sent startup dm", {
+        userId: authConfig.discordAllowedUserId
       });
     } catch (error) {
-      console.error("[discord] failed to send startup dm", error);
+      console.error("[gateway] failed to send startup dm", error);
     }
   });
   client.on(Events.MessageCreate, async (message) => {
-    console.log("[discord] message received", {
+    if (message.channel.isThread()) {
+      console.log("[gateway:debug] thread message raw", {
+        messageId: message.id,
+        authorId: message.author.id,
+        authorTag: message.author.tag,
+        channelId: message.channel.id,
+        channelType: message.channel.type,
+        parentId: message.channel.parentId,
+        parentType: message.channel.parent?.type,
+        guildId: message.guild?.id,
+        content: message.content.slice(0, 500)
+      });
+    }
+    console.log("[gateway] message received", {
       messageId: message.id,
       authorId: message.author.id,
       channelType: message.channel.type,
-      content: message.content
+      content: message.content.slice(0, 200)
     });
     try {
-      await onMessage(message, config, agentService, promptQueue);
+      await onMessage(message, config, agentService, sessionRegistry, authConfig);
     } catch (error) {
-      console.error("[discord] message handling failed", error);
+      console.error("[gateway] message handling failed", error);
       await sendReply(message, "The bot hit an error while handling that message.");
     }
   });
+  client.on(Events.ThreadDelete, async (thread) => {
+    const scope = `thread:${thread.id}`;
+    console.log("[gateway] thread deleted", { threadId: thread.id, scope });
+    await sessionRegistry.remove(scope);
+  });
   await client.login(config.discordBotToken);
   return client;
 }
-async function onMessage(message, config, agentService, promptQueue) {
+async function onMessage(message, config, agentService, sessionRegistry, authConfig) {
   if (message.author.bot) {
-    console.log("[discord] ignored bot message", { messageId: message.id });
+    console.log("[gateway] ignored bot message", { messageId: message.id });
     return;
   }
-  if (message.author.id !== config.discordAllowedUserId) {
-    console.log("[discord] ignored unauthorized user", {
+  const scope = resolveScope(message);
+  if (scope === null) {
+    console.log("[gateway] unsupported channel type, ignoring", {
       messageId: message.id,
-      authorId: message.author.id
+      channelType: message.channel.type
     });
     return;
   }
-  if (message.channel.type !== ChannelType.DM) {
-    console.log("[discord] ignored non-dm message", {
+  if (!isAuthorized(message, scope, authConfig)) {
+    console.log("[gateway] unauthorized", {
       messageId: message.id,
-      channelType: message.channel.type
+      authorId: message.author.id,
+      scope
     });
     return;
   }
   const content = message.content.trim();
   if (!content) {
-    console.log("[discord] ignored empty message", { messageId: message.id });
+    console.log("[gateway] ignored empty message", { messageId: message.id });
     return;
   }
-  const typingInterval = await startTypingInterval(message.channel);
-  const commandResult = await handleCommand(content, agentService, promptQueue);
+  const { session, promptQueue } = await sessionRegistry.getOrCreate(scope);
+  let typingInterval = null;
+  if (message.channel.isSendable()) {
+    typingInterval = startTypingInterval(message.channel);
+  }
+  const commandResult = await handleCommand(content, {
+    agentService,
+    promptQueue,
+    session
+  });
   if (commandResult.handled) {
     stopTypingInterval(typingInterval);
-    console.log("[discord] command handled", {
+    if (commandResult.archive && scope.startsWith("thread:")) {
+      console.log("[gateway] archiving thread", { scope });
+      const archiveChannel = message.channel;
+      if (archiveChannel.isSendable()) {
+        await archiveChannel.send(commandResult.response ?? "Archiving...");
+      }
+      try {
+        if (archiveChannel.isThread()) {
+          await archiveChannel.setArchived(true);
+        }
+      } catch (error) {
+        console.error("[gateway] failed to archive thread", error);
+      }
+      await sessionRegistry.remove(scope);
+      return;
+    }
+    console.log("[gateway] command handled", {
       messageId: message.id,
       command: content,
       hasResponse: Boolean(commandResult.response)
@@ -638,11 +889,12 @@ async function onMessage(message, config, agentService, promptQueue) {
   }
   if (!message.channel.isSendable()) {
     stopTypingInterval(typingInterval);
-    console.log("[discord] channel is not sendable", { messageId: message.id });
+    console.log("[gateway] channel not sendable", { messageId: message.id });
     return;
   }
   const queuePosition = promptQueue.getSnapshot().pending;
   console.log("[queue] enqueue request", {
+    scope,
     messageId: message.id,
     queuePosition
   });
@@ -650,49 +902,24 @@ async function onMessage(message, config, agentService, promptQueue) {
     await sendReply(message, `Queued. ${queuePosition} request(s) ahead of this one.`);
   }
   const response = await promptQueue.enqueue(async () => {
-    console.log(`[queue] processing message ${message.id}`);
-    return agentService.prompt(content);
+    console.log(`[queue] processing message ${message.id} in scope ${scope}`);
+    const transformedPrompt = await config.promptTransform(content);
+    return collectReply(session, transformedPrompt, {
+      logPrefix: `[agent:${session.sessionId}]`
+    });
   });
   stopTypingInterval(typingInterval);
-  console.log("[discord] response ready", {
+  console.log("[gateway] response ready", {
+    scope,
     messageId: message.id,
     responseLength: response.length,
     preview: response.slice(0, 200)
   });
   await sendReply(message, response);
 }
-async function sendReply(message, text) {
-  if (!message.channel.isSendable()) {
-    console.log("[discord] reply skipped, channel not sendable", {
-      messageId: message.id
-    });
-    return;
-  }
-  const chunks = chunkMessage(text);
-  console.log("[discord] sending reply", {
-    messageId: message.id,
-    chunkCount: chunks.length,
-    textLength: text.length
-  });
-  const [firstChunk, ...remainingChunks] = chunks;
-  if (!firstChunk) {
-    return;
-  }
-  await message.reply(firstChunk);
-  for (const chunk of remainingChunks) {
-    await message.channel.send(chunk);
-  }
-}
-var TYPING_INTERVAL_MS = 8000;
-function startTypingInterval(channel) {
-  channel.sendTyping();
-  return setInterval(() => {
-    channel.sendTyping();
-  }, TYPING_INTERVAL_MS);
-}
-function stopTypingInterval(interval) {
-  clearInterval(interval);
-}
+
+// src/session-registry.ts
+import path3 from "node:path";
 
 // src/prompt-queue.ts
 class PromptQueue {
@@ -732,6 +959,70 @@ class PromptQueue {
   }
 }
 
+// src/session-registry.ts
+function sessionDirForScope(agentDir, scope) {
+  if (scope === "dm") {
+    return path3.join(agentDir, "sessions");
+  }
+  if (scope.startsWith("thread:")) {
+    const threadId = scope.slice(7);
+    return path3.join(agentDir, "sessions", `thread-${threadId}`);
+  }
+  throw new Error(`Unknown session scope: ${scope}`);
+}
+
+class SessionRegistry {
+  scopes = new Map;
+  agentService;
+  constructor(agentService) {
+    this.agentService = agentService;
+  }
+  async getOrCreate(scope) {
+    const existing = this.scopes.get(scope);
+    if (existing) {
+      return existing;
+    }
+    const sessionDir = sessionDirForScope(this.agentService.getAgentDir(), scope);
+    const session = await this.agentService.createSession(sessionDir);
+    const promptQueue = new PromptQueue;
+    const entry = {
+      session,
+      promptQueue,
+      createdAt: new Date
+    };
+    this.scopes.set(scope, entry);
+    console.log("[session-registry] scope registered", {
+      scope,
+      sessionDir,
+      sessionId: session.sessionId
+    });
+    return entry;
+  }
+  async remove(scope) {
+    const entry = this.scopes.get(scope);
+    if (!entry) {
+      return;
+    }
+    console.log("[session-registry] removing scope", { scope });
+    await entry.session.abort();
+    entry.session.dispose();
+    this.scopes.delete(scope);
+  }
+  get(scope) {
+    return this.scopes.get(scope);
+  }
+  getScopes() {
+    return Array.from(this.scopes.keys());
+  }
+  async shutdownAll() {
+    console.log("[session-registry] shutting down all scopes", this.scopes.size);
+    const scopes = Array.from(this.scopes.keys());
+    for (const scope of scopes) {
+      await this.remove(scope);
+    }
+  }
+}
+
 // src/prompt-context.ts
 function buildTimeContextPrompt(userMessage, options = {}) {
   const timeZone = options.timeZone || "UTC";
@@ -753,15 +1044,21 @@ function buildTimeContextPrompt(userMessage, options = {}) {
 }
 
 // src/index.ts
-async function startDiscordPiBridge(config) {
-  const resolvedConfig = resolveConfig(config);
+async function startDiscordGateway(config) {
+  const resolvedConfig = resolveGatewayConfig(config);
   const agentService = new AgentService(resolvedConfig);
-  const promptQueue = new PromptQueue;
-  console.log("[boot] initializing persistent agent session");
+  console.log("[gateway] initializing agent service");
   await agentService.initialize();
-  console.log("[boot] agent ready", agentService.getStatus());
-  const client = await startDiscordClient(resolvedConfig, agentService, promptQueue);
-  const stop = createStopHandler(client, agentService, resolvedConfig);
+  console.log("[gateway] agent ready", agentService.getStatus());
+  const authConfig = {
+    discordAllowedUserId: resolvedConfig.discordAllowedUserId,
+    discordAllowedForumChannelIds: resolvedConfig.discordAllowedForumChannelIds,
+    discordAllowedUserIds: resolvedConfig.discordAllowedUserIds,
+    startupMessage: resolvedConfig.startupMessage
+  };
+  const sessionRegistry = new SessionRegistry(agentService);
+  const client = await startGatewayClient(resolvedConfig, agentService, sessionRegistry, authConfig);
+  const stop = createGatewayStopHandler(client, agentService, sessionRegistry, resolvedConfig);
   if (resolvedConfig.shutdownOnSignals) {
     registerSignalHandlers(stop);
   }
@@ -773,18 +1070,22 @@ async function startDiscordPiBridge(config) {
     }
   };
 }
-function createStopHandler(client, agentService, config) {
+async function startDiscordPiBridge(config) {
+  return startDiscordGateway(config);
+}
+function createGatewayStopHandler(client, agentService, sessionRegistry, config) {
   let stopped = false;
   return async () => {
     if (stopped) {
       return;
     }
     stopped = true;
-    console.log("[shutdown] stopping discord pi bridge", {
+    console.log("[shutdown] stopping discord gateway", {
       cwd: config.cwd,
       agentDir: config.agentDir
     });
     client.destroy();
+    await sessionRegistry.shutdownAll();
     await agentService.shutdown();
   };
 }
@@ -805,7 +1106,9 @@ function registerSignalHandlers(stop) {
 }
 export {
   startDiscordPiBridge,
+  startDiscordGateway,
   resolveConfig,
   loadDiscordPiBridgeConfigFromEnv,
+  loadDiscordGatewayConfigFromEnv,
   buildTimeContextPrompt
 };

package/dist/session-registry.d.ts

@@ -0,0 +1,26 @@
+import type { AgentSession } from "@mariozechner/pi-coding-agent";
+import type { AgentService } from "./agent-service";
+import { PromptQueue } from "./prompt-queue";
+export type SessionScope = string;
+export type ScopeEntry = {
+    session: AgentSession;
+    promptQueue: PromptQueue;
+    createdAt: Date;
+};
+/**
+ * Derive a deterministic session directory from a scope key.
+ *
+ *   "dm"              → <agentDir>/sessions
+ *   "thread:<id>"     → <agentDir>/sessions/thread-<id>
+ */
+export declare function sessionDirForScope(agentDir: string, scope: SessionScope): string;
+export declare class SessionRegistry {
+    private readonly scopes;
+    private readonly agentService;
+    constructor(agentService: AgentService);
+    getOrCreate(scope: SessionScope): Promise<ScopeEntry>;
+    remove(scope: SessionScope): Promise<void>;
+    get(scope: SessionScope): ScopeEntry | undefined;
+    getScopes(): SessionScope[];
+    shutdownAll(): Promise<void>;
+}

package/dist/types.d.ts

@@ -43,3 +43,21 @@ export type DiscordPiBridge = {
     stop: () => Promise<void>;
     getStatus: () => AgentStatus;
 };
+export type DiscordGatewayConfig = DiscordPiBridgeConfig & {
+    /** Which forum channels the bot responds in (absent = forum disabled). */
+    discordAllowedForumChannelIds?: string[];
+    /** Which users can interact in forum threads (defaults to [discordAllowedUserId]). */
+    discordAllowedUserIds?: string[];
+    /** Auto-shutdown idle thread sessions after this many ms. */
+    sessionIdleTimeoutMs?: number;
+};
+export type ResolvedDiscordGatewayConfig = ResolvedDiscordPiBridgeConfig & {
+    discordAllowedForumChannelIds: string[];
+    discordAllowedUserIds: string[];
+    sessionIdleTimeoutMs: number | null;
+};
+export type DiscordGateway = {
+    client: Client;
+    stop: () => Promise<void>;
+    getStatus: () => AgentStatus;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@friendlyrobot/discord-pi-agent",
-  "version": "0.4.7",
+  "version": "0.5.0",
   "description": "Reusable Discord gateway bridge for persistent pi agent sessions",
   "license": "MIT",
   "type": "module",
@@ -27,10 +27,13 @@
   "scripts": {
     "test:watch": "vitest",
     "test": "vitest run",
-    "update-deps": "bun add @mariozechner/pi-ai@latest @mariozechner/pi-coding-agent@latest marked@latest discord.js@latest dotenv@latest prettier@latest; bun add -d @types/node@latest typescript@latest vitest@latest @vitest/ui@latest",
+    "update-deps": "npx npm-check-updates",
     "format": "prettier --write .",
-    "build": "rm -rf dist && bun build ./src/index.ts --outdir ./dist --target node --format esm --packages external && tsc -p tsconfig.json --emitDeclarationOnly --declaration --declarationMap false",
-    "typecheck": "tsc --noEmit -p tsconfig.json"
+    "build:01-clean": "rm -rf dist",
+    "build:02-tsgo": "tsgo -p tsconfig.json --emitDeclarationOnly --declaration --declarationMap false",
+    "build:03-build": "bun build ./src/index.ts --outdir ./dist --target node --format esm --packages external",
+    "build": "bun run --sequential 'build:*'",
+    "typecheck": "tsgo --noEmit -p tsconfig.json"
   },
   "dependencies": {
     "@mariozechner/pi-ai": "^0.70.2",
@@ -42,8 +45,8 @@
   },
   "devDependencies": {
     "@types/node": "^25.6.0",
+    "@typescript/native-preview": "^7.0.0-dev.20260424.2",
     "@vitest/ui": "^4.1.5",
-    "typescript": "^6.0.3",
     "vitest": "^4.1.5"
   }
 }