@0xmaxma/claude-gateway 1.8.14 → 2.0.1

package/mcp/capability-catalog.ts

@@ -0,0 +1,206 @@
+/** Metadata only. Never initialize channel receivers or call an MCP tool. */
+import { Client } from '@modelcontextprotocol/sdk/client/index.js';
+import { StdioClientTransport } from '@modelcontextprotocol/sdk/client/stdio.js';
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { gatewayModules } from './modules';
+import { AGENT_TASK_TOOLS, WORKER_REPORT_TOOLS } from './tools/tasks/module';
+
+type Entry = {
+  name: string;
+  description: string;
+  server: string;
+  status: string;
+  via: 'agent' | 'worker' | 'unavailable';
+};
+const entries: Entry[] = [];
+const servers: Array<{ name: string; status: string }> = [];
+const chunks: Buffer[] = [];
+let bytes = 0;
+for await (const chunk of process.stdin) {
+  bytes += chunk.length;
+  if (bytes > 4 * 1024 * 1024) throw Error('CATALOG_INPUT_TOO_LARGE');
+  chunks.push(Buffer.from(chunk));
+}
+const input = JSON.parse(Buffer.concat(chunks).toString());
+// Mirror the worker module gates for metadata, without issuing a usable ticket.
+const profileKeys = [
+  'GATEWAY_ORCHESTRATION_ROLE',
+  'GATEWAY_ORCHESTRATION_MEDIA',
+  'GATEWAY_ORCHESTRATION_TICKET_FILE',
+];
+const original = profileKeys.map((key) => process.env[key]);
+Object.assign(process.env, {
+  GATEWAY_ORCHESTRATION_ROLE: 'worker',
+  GATEWAY_ORCHESTRATION_MEDIA: 'true',
+  GATEWAY_ORCHESTRATION_TICKET_FILE: '/capability-discovery-no-execution',
+});
+const worker = new Set(
+  gatewayModules('worker', true).flatMap((m) =>
+    m.isEnabled() ? m.getTools().map((t) => t.name) : []
+  )
+);
+for (const module of gatewayModules()) {
+  let enabled = false;
+  try {
+    enabled = module.isEnabled();
+  } catch {
+    /* Unavailable, not absent. */
+  }
+  for (const tool of module.getTools())
+    entries.push({
+      name: `mcp__gateway__${tool.name}`,
+      description: tool.description,
+      server: 'gateway',
+      status: !enabled
+        ? 'not_configured'
+        : worker.has(tool.name)
+          ? tool.name.startsWith('memory_shared_')
+            ? 'requires_memory_permission'
+            : 'available'
+          : 'not_exposed_to_workers',
+      via:
+        enabled && ['memory_search', 'memory_get'].includes(tool.name)
+          ? 'agent'
+          : enabled && worker.has(tool.name)
+            ? 'worker'
+            : 'unavailable',
+    });
+}
+for (const tool of AGENT_TASK_TOOLS)
+  entries.push({
+    name: `mcp__gateway__${tool.name}`,
+    description: tool.description,
+    server: 'gateway',
+    status:
+      tool.name === 'conversation_intake'
+        ? 'requires_semantic_intake'
+        : 'available',
+    via: 'agent',
+  });
+for (const tool of WORKER_REPORT_TOOLS)
+  entries.push({
+    name: `mcp__gateway__${tool.name}`,
+    description: tool.description,
+    server: 'gateway',
+    status:
+      tool.name === 'task_memory_append'
+        ? 'requires_memory_permission'
+        : 'available',
+    via: 'worker',
+  });
+profileKeys.forEach((key, i) => {
+  if (original[i] === undefined) delete process.env[key];
+  else process.env[key] = original[i];
+});
+servers.push({ name: 'gateway', status: 'available' });
+for (const [name, value] of Object.entries(input.servers ?? {})) {
+  const config = value as {
+    type?: string;
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    url?: string;
+    headers?: Record<string, string>;
+  };
+  const client = new Client({
+    name: 'gateway-capability-discovery',
+    version: '1',
+  });
+  let transport:
+    | StdioClientTransport
+    | StreamableHTTPClientTransport
+    | SSEClientTransport
+    | undefined;
+  const timeout = setTimeout(() => {
+    void client.close();
+  }, 5000);
+  try {
+    if (config.command)
+      transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: {
+          ...Object.fromEntries(
+            Object.entries(process.env).filter(
+              (e): e is [string, string] => typeof e[1] === 'string'
+            )
+          ),
+          ...config.env,
+        },
+        stderr: 'ignore',
+      });
+    else if (config.url)
+      transport =
+        config.type === 'sse'
+          ? new SSEClientTransport(new URL(config.url), {
+              requestInit: { headers: config.headers },
+            })
+          : new StreamableHTTPClientTransport(new URL(config.url), {
+              requestInit: { headers: config.headers },
+            });
+    else throw Error('INVALID_MCP_CONFIG');
+    await client.connect(transport, { timeout: 5000 });
+    let cursor: string | undefined;
+    const seen = new Set<string>();
+    do {
+      const result = await client.listTools(cursor ? { cursor } : {}, {
+        timeout: 5000,
+      });
+      for (const tool of result.tools)
+        entries.push({
+          name: `mcp__${name.replace(/[^a-zA-Z0-9_-]/g, '_')}__${tool.name.replace(/[^a-zA-Z0-9_-]/g, '_')}`,
+          description: tool.description ?? '',
+          server: name,
+          status: 'available',
+          via: 'worker',
+        });
+      cursor = result.nextCursor;
+      if (cursor && seen.has(cursor)) throw Error('CATALOG_CURSOR_LOOP');
+      if (cursor) seen.add(cursor);
+      if (Buffer.byteLength(JSON.stringify(entries)) > 3 * 1024 * 1024)
+        throw Error('CATALOG_TOO_LARGE');
+    } while (cursor);
+    servers.push({ name, status: 'available' });
+  } catch {
+    // Do not publish connection errors: URLs/headers may include secrets.
+    for (const entry of entries)
+      if (entry.server === name) {
+        entry.status = 'discovery_incomplete';
+        entry.via = 'unavailable';
+      }
+    const observed = input.observed?.find(
+      (s: { name: string; status: string }) =>
+        s.name === name && s.status === 'connected'
+    );
+    if (observed) {
+      for (const tool of observed.tools ?? []) {
+        const fullName = `mcp__${name.replace(/[^a-zA-Z0-9_-]/g, '_')}__${String(tool.name).replace(/[^a-zA-Z0-9_-]/g, '_')}`;
+        if (!entries.some((e) => e.name === fullName))
+          entries.push({
+            name: fullName,
+            description:
+              tool.description ||
+              'Tool reported by the Claude Code MCP runtime; detailed metadata unavailable.',
+            server: name,
+            status: 'available',
+            via: 'worker',
+          });
+        else
+          for (const entry of entries)
+            if (entry.name === fullName) {
+              entry.status = 'available';
+              entry.via = 'worker';
+            }
+      }
+      servers.push({ name, status: 'available_names_only' });
+    } else servers.push({ name, status: 'discovery_unavailable' });
+  } finally {
+    clearTimeout(timeout);
+    await client.close().catch(() => {});
+    await transport?.close().catch(() => {});
+  }
+}
+process.stdout.write(
+  JSON.stringify({ entries, servers, observedAt: new Date().toISOString() })
+);

package/mcp/modules.ts

@@ -0,0 +1,56 @@
+import { TelegramModule } from './tools/telegram/module';
+import { DiscordModule } from './tools/discord/module';
+import { LineModule } from './tools/line/module';
+import { SlackModule } from './tools/slack/module';
+import { WhatsAppModule } from './tools/whatsapp/module';
+import { WhatsAppCloudModule } from './tools/whatsapp-cloud/module';
+import { WeChatModule } from './tools/wechat/module';
+import { CronModule } from './tools/cron/module';
+import { SkillsModule } from './tools/skills/module';
+import { AgentModule } from './tools/agent/module';
+import { BrowserModule } from './tools/browser/module';
+import { ImageModule } from './tools/image/module';
+import { VideoModule } from './tools/video/module';
+import { ShareFileModule } from './tools/share-file/module';
+import { AppsModule } from './tools/apps/module';
+import { ApiModule } from './tools/api/module';
+import { MemoryModule } from './tools/memory/module';
+import type { ChannelModule, ToolModule } from './types';
+
+/** Shared registration for execution and read-only capability discovery. */
+export function gatewayModules(
+  role?: string,
+  media = false
+): Array<ChannelModule | ToolModule> {
+  return role
+    ? [
+        new MemoryModule(),
+        ...(role === 'worker' && media
+          ? [
+              new ImageModule(),
+              new VideoModule(),
+              new ShareFileModule(),
+              new BrowserModule(),
+            ]
+          : []),
+      ]
+    : [
+        new TelegramModule(),
+        new DiscordModule(),
+        new LineModule(),
+        new SlackModule(),
+        new WhatsAppModule(),
+        new WhatsAppCloudModule(),
+        new WeChatModule(),
+        new CronModule(),
+        new SkillsModule(),
+        new AgentModule(),
+        new BrowserModule(),
+        new ImageModule(),
+        new VideoModule(),
+        new ShareFileModule(),
+        new AppsModule(),
+        new ApiModule(),
+        new MemoryModule(),
+      ];
+}

package/mcp/server.ts

@@ -12,27 +12,14 @@ import {
   ListToolsRequestSchema,
   CallToolRequestSchema,
 } from '@modelcontextprotocol/sdk/types.js';
-import { TelegramModule } from './tools/telegram/module';
-import { DiscordModule } from './tools/discord/module';
-import { LineModule } from './tools/line/module';
-import { SlackModule } from './tools/slack/module';
-import { WhatsAppModule } from './tools/whatsapp/module';
-import { WhatsAppCloudModule } from './tools/whatsapp-cloud/module';
-import { WeChatModule } from './tools/wechat/module';
-import { CronModule } from './tools/cron/module';
-import { SkillsModule } from './tools/skills/module';
-import { AgentModule } from './tools/agent/module';
-import { BrowserModule } from './tools/browser/module';
-import { ImageModule } from './tools/image/module';
-import { VideoModule } from './tools/video/module';
-import { ShareFileModule } from './tools/share-file/module';
-import { AppsModule } from './tools/apps/module';
-import { ApiModule } from './tools/api/module';
-import { MemoryModule } from './tools/memory/module';
+import { gatewayModules } from './modules';
+import { AGENT_TASK_TOOLS, WORKER_REPORT_TOOLS, callTaskBridge } from './tools/tasks/module';
 import { buildChannelInstructions } from './instructions';
 import type { ChannelModule, ToolModule, McpToolDefinition } from './types';
 
 const ORIGIN_CHANNEL = process.env.GATEWAY_ORIGIN_CHANNEL ?? '';
+const ORCHESTRATION_ROLE = process.env.GATEWAY_ORCHESTRATION_ROLE;
+if (ORCHESTRATION_ROLE && !['agent', 'worker'].includes(ORCHESTRATION_ROLE)) throw new Error('Invalid orchestration MCP role');
 
 type AnyModule = ChannelModule | ToolModule;
 
@@ -40,25 +27,7 @@ function isChannelModule(mod: AnyModule): mod is ChannelModule {
   return 'start' in mod && typeof (mod as ChannelModule).start === 'function';
 }
 
-const modules: AnyModule[] = [
-  new TelegramModule(),
-  new DiscordModule(),
-  new LineModule(),
-  new SlackModule(),
-  new WhatsAppModule(),
-  new WhatsAppCloudModule(),
-  new WeChatModule(),
-  new CronModule(),
-  new SkillsModule(),
-  new AgentModule(),
-  new BrowserModule(),
-  new ImageModule(),
-  new VideoModule(),
-  new ShareFileModule(),
-  new AppsModule(),
-  new ApiModule(),
-  new MemoryModule(),
-];
+const modules = gatewayModules(ORCHESTRATION_ROLE, process.env.GATEWAY_ORCHESTRATION_MEDIA === 'true');
 
 // Build tool-to-module mapping for enabled modules
 const toolMap = new Map<string, AnyModule>();
@@ -76,11 +45,16 @@ for (const mod of modules) {
   if (!visible) continue;
 
   for (const tool of mod.getTools()) {
+    if (ORCHESTRATION_ROLE && !['memory_search', 'memory_get'].includes(tool.name) && !(ORCHESTRATION_ROLE === 'worker' &&
+      ((mod.id === 'image' || mod.id === 'video' || mod.id === 'share-file' || mod.id === 'browser') || (mod.id === 'memory' && process.env.GATEWAY_ORCHESTRATION_WRITE_MEMORY === 'true')))) continue;
     toolMap.set(tool.name, mod);
     visibleTools.push(tool);
   }
 }
 
+const taskTools = ORCHESTRATION_ROLE === 'agent' ? AGENT_TASK_TOOLS.filter(tool => (tool.name !== 'conversation_intake' || process.env.GATEWAY_SEMANTIC_INTAKE === 'true') && (tool.name !== 'capabilities_list' || process.env.GATEWAY_CAPABILITY_CATALOG === 'true')) : ORCHESTRATION_ROLE === 'worker' ? WORKER_REPORT_TOOLS.filter(tool => tool.name !== 'task_memory_append' || process.env.GATEWAY_ORCHESTRATION_WRITE_MEMORY === 'true') : [];
+if (ORCHESTRATION_ROLE && process.env.GATEWAY_ORCHESTRATION_TICKET_FILE) visibleTools.push(...taskTools);
+
 // Initialize channel modules so their bot API clients are ready for tool calls.
 // initBot() returns immediately after creating the client — no blocking.
 for (const mod of modules) {
@@ -105,7 +79,7 @@ const mcp = new Server(
         'claude/channel/permission': {},
       },
     },
-    instructions: buildChannelInstructions(imageEnabled, videoEnabled),
+    instructions: ORCHESTRATION_ROLE ? 'Use scoped capability discovery, task tools and memory retrieval. The agent writes user-facing responses; workers return task results and orchestration handles delivery.' : buildChannelInstructions(imageEnabled, videoEnabled),
   },
 );
 
@@ -116,6 +90,9 @@ mcp.setRequestHandler(ListToolsRequestSchema, async () => ({
 mcp.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
   const toolName = req.params.name;
   const args = (req.params.arguments ?? {}) as Record<string, unknown>;
+  if (ORCHESTRATION_ROLE && process.env.GATEWAY_ORCHESTRATION_TICKET_FILE && taskTools.some(tool => tool.name === toolName)) {
+    return callTaskBridge(toolName, args, String(extra.requestId), AbortSignal.any([extra.signal, shutdownController.signal]));
+  }
 
   const mod = toolMap.get(toolName);
   if (!mod) {
@@ -124,6 +101,10 @@ mcp.setRequestHandler(CallToolRequestSchema, async (req, extra) => {
       isError: true,
     };
   }
+  if (ORCHESTRATION_ROLE === 'worker' && process.env.GATEWAY_ORCHESTRATION_MEDIA === 'true') {
+    const validation = await callTaskBridge('task_validate', {}, String(extra.requestId), AbortSignal.any([extra.signal, shutdownController.signal]));
+    if (validation.isError) return validation;
+  }
 
   // extra.signal fires on notifications/cancelled for THIS call (the SDK matches
   // it by requestId) — the CLI sends that when a user Stop/Ctrl-C interrupts an

package/mcp/tools/browser/module.ts

@@ -159,7 +159,7 @@ async function callGetpodBrowser(
 const browserToolDefs: McpToolDefinition[] = [
   {
     name: 'browser_create_session',
-    description: 'Create or resume a browser session. Returns session status.',
+    description: 'Create or resume GetPod Cloud Browser, NOT the user Chrome or Remote Browser connector. Use only when Cloud Browser is selected, or no Remote Browser is connected for a generic browser request. Returns session status.',
     inputSchema: {
       type: 'object',
       properties: {

package/mcp/tools/browser/skills/open-browser/SKILL.md

@@ -1,16 +1,18 @@
 ---
 name: open-browser
-description: "ALWAYS invoke this skill when user says 'browser [site]', 'open [site]', or asks to navigate to a website. Never call MCP browser tools directly."
+description: "Open a website in GetPod Cloud Browser after that environment is selected. Does not control the user Chrome or Remote Browser connector."
 user-invocable: true
 ---
 
 # open-browser
 
-When user says "open X in browser", "navigate to X", "open chrome", "browser to X", "switch to tab X", etc.
+Use this skill only for GetPod Cloud Browser. Remote Browser is a separate connector controlling the user's approved device tabs.
+
+If a Remote Browser connector is enabled and the user has not selected an environment, ask whether to use Remote Browser (recommended) or GetPod Cloud Browser before taking browser actions. An explicit remote/device request must use that connector instead of this skill. Reuse the selection for related follow-ups. With no Remote Browser connector, ordinary browser requests may use Cloud Browser. Never fall back from Remote Browser to Cloud Browser without user approval.
 
 ## Rules
 
-- Use ONLY `mcp__gateway__browser_*` tools — never Python, never CDP direct, never filesystem
+- For the selected Cloud Browser workflow, use ONLY `mcp__gateway__browser_*` tools — never Python, never CDP direct, never filesystem
 - NEVER use `wait: "networkidle"` — it hangs on SPAs. Omit `wait` entirely (fire-and-forget)
 - Always check tab state before navigating — tab IDs change between sessions
 - Do NOT pass `session_id` — it is injected automatically from agent context

package/mcp/tools/discord/commands.ts

@@ -24,15 +24,31 @@ export const SLASH_COMMANDS: SlashCommandDef[] = [
   },
 ];
 
+export function commandDefinitions(orchestration:boolean,interactive:boolean):SlashCommandDef[]{
+  return [...SLASH_COMMANDS,
+    ...(orchestration ? [
+      {name:'voice',description:'Turn automatic voice replies on or off',options:[{name:'mode',description:'on or off (omit to show buttons)',required:false,type:'STRING' as const}]},
+      {name:'voices',description:'Choose the agent voice'},
+      {name:'tasks',description:'View pending tasks in this conversation'},
+      {name:'help',description:'Show available orchestration controls'},
+    ] : []),
+    {name:'stop',description:orchestration?'Stop a response or choose a task to stop':'Stop the agent response'},
+    ...(interactive && !orchestration ? [{name:'cli',description:'Open the live terminal viewer'}] : []),
+  ];
+}
+
 export async function registerCommands(
   client: any,
   token: string,
+  orchestration = false,
+  interactive = false,
 ): Promise<void> {
   // @ts-ignore — discord.js in mcp/node_modules
   const { REST, Routes, SlashCommandBuilder } = await import('discord.js');
   const rest = new REST().setToken(token);
 
-  const bodies = SLASH_COMMANDS.map(cmd => {
+  const commands=commandDefinitions(orchestration,interactive);
+  const bodies = commands.map(cmd => {
     const builder = new SlashCommandBuilder()
       .setName(cmd.name)
       .setDescription(cmd.description);

package/mcp/tools/discord/inbound.ts

@@ -45,9 +45,20 @@ export function createMessageHandler(
       messageId: message.id,
       threadId: isThread ? message.channelId : undefined,
       attachmentFileId: message.attachments.first()?.url,
+      attachmentKind: (message.attachments.first()?.contentType?.startsWith('audio/') || (typeof message.flags==='number' ? !!(message.flags&8192) : message.flags?.has(8192))) ? 'voice' : 'file',
       ts: message.createdTimestamp,
     };
 
+    const attachments = (msg: DiscordMessage, quoted=false) => (msg.attachments.values ? [...msg.attachments.values()] : [msg.attachments.first()].filter(Boolean)).slice(0,10).map(a=>({url:a!.url,name:a!.name,kind:a!.contentType?.startsWith('image/')?'image':a!.contentType?.startsWith('audio/')?'audio':'file',quoted}));
+    inbound.attachments = attachments(message);
+    if (message.reference?.messageId && (!message.reference.channelId || message.reference.channelId === message.channelId)) {
+      inbound.replyToMessageId = message.reference.messageId;
+      let timer: ReturnType<typeof setTimeout> | undefined;
+      try {
+        const replied = await Promise.race([message.fetchReference?.(), new Promise<undefined>(resolve=>{timer=setTimeout(()=>resolve(undefined),3000);})]);
+        if (replied && replied.channelId === message.channelId) { inbound.repliedText=replied.content; inbound.repliedSender=replied.author.username; inbound.attachments.push(...attachments(replied,true)); }
+      } catch { /* ID still resolves from scoped local history when available. */ } finally { if(timer)clearTimeout(timer); }
+    }
     await handler(inbound);
   };
 }

package/mcp/tools/discord/module.ts

@@ -190,6 +190,10 @@ export class DiscordModule implements ChannelModule {
     const { createDiscordClient } = await import('./client');
     this.client = await createDiscordClient(token);
     this.running = true;
+    if(process.env.CLAUDE_CHANNEL_CALLBACK){
+      const {registerCommands}=await import('./commands');
+      await registerCommands(this.client,token,process.env.GATEWAY_ORCHESTRATION_ENABLED==='true',process.env.GATEWAY_INTERACTIVE_CLI_ENABLED==='true').catch(err=>process.stderr.write(`discord: command registration failed: ${err}\n`));
+    }
   }
 
   async start(handler: InboundMessageHandler, signal: AbortSignal): Promise<void> {
@@ -296,7 +300,12 @@ export class DiscordModule implements ChannelModule {
       // button) instead of forwarding the text to the agent. Only reached after
       // gate() authorized this user, so it inherits the channel's access control.
       const cliText = (msg.content ?? '').replace(/<@!?\d+>/g, '').trim().toLowerCase();
+      if(/^\/(voice|voices|tasks|stop|help|orch)(?:\s|$)/.test(cliText)){
+        await handler({channel:'discord',accountId:this.client.user?.id??'discord',senderId:context.userId,chatId:context.channelId,chatType:isDM?'direct':'group',text:(msg.content??'').replace(/<@!?\d+>/g,'').trim(),messageId:msg.id,ts:Date.now()});
+        return;
+      }
       if (cliText === '/cli') {
+        if(process.env.GATEWAY_INTERACTIVE_CLI_ENABLED!=='true'){await msg.channel.send('The terminal viewer requires interactive mode.');return;}
         const base = cliCallbackBase();
         try {
           const res = await fetch(base + '/command', {
@@ -336,7 +345,7 @@ export class DiscordModule implements ChannelModule {
       const typingFileDir = path.join(this.stateDir, 'typing');
       try {
         fs.mkdirSync(typingFileDir, { recursive: true });
-        fs.writeFileSync(path.join(typingFileDir, channelId), '');
+        if (process.env.GATEWAY_ORCHESTRATION_ENABLED !== 'true') fs.writeFileSync(path.join(typingFileDir, channelId), '');
         await fetch(`https://discord.com/api/v10/channels/${channelId}/typing`, {
           method: 'POST',
           headers: { Authorization: `Bot ${this.getToken()!}`, 'Content-Length': '0' },
@@ -388,7 +397,14 @@ export class DiscordModule implements ChannelModule {
     // Security mirrors the message path: the access gate must return 'deliver'.
     // discord.js client is typed as `any` (dynamic import) so we narrow locally.
     interface ButtonInteraction {
+      id?: string;
       isButton?: () => boolean;
+      isChatInputCommand?: () => boolean;
+      commandName?: string;
+      options?: {getString(name:string):string|null};
+      deferUpdate?: () => Promise<unknown>;
+      deferReply?: (options: {ephemeral:boolean}) => Promise<unknown>;
+      deleteReply?: () => Promise<unknown>;
       customId?: string;
       guildId?: string | null;
       channelId: string;
@@ -401,6 +417,28 @@ export class DiscordModule implements ChannelModule {
     }
     this.client.on('interactionCreate', async (interaction: ButtonInteraction) => {
       try {
+        const orchButton=interaction.isButton?.()&&/^orch:(?:[a-f0-9-]{36}|q:[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}:(?:snooze|mute))$/.test(interaction.customId??'');
+        const slash=interaction.isChatInputCommand?.();
+        if(orchButton||slash){
+          const isDM=!interaction.guildId,isThread=interaction.channel?.isThread?.()??false;
+          const context:DiscordMessageContext={guildId:interaction.guildId??null,channelId:interaction.channelId,threadId:isThread?interaction.channelId:null,userId:interaction.user.id,username:interaction.user.username,messageId:interaction.message?.id??'',isDM,isThread,mentionsBot:true};
+          const access=gate(loadAccessFn(),context,saveAccessFn,()=>randomBytes(3).toString('hex'));
+          if(access.action!=='deliver'){await interaction.reply({content:'Not authorized.',ephemeral:true});return;}
+          if(orchButton)await interaction.deferUpdate?.();else await interaction.deferReply?.({ephemeral:true});
+          let text=orchButton?`/orch ${interaction.customId!.slice(5)}`:`/${interaction.commandName}`;
+          if(slash){
+            const name=interaction.commandName;
+            const arg=interaction.options?.getString(name==='voice'?'mode':name==='ask'?'question':'name');
+            if(name==='ask')text=arg??'';else if(arg)text+=' '+arg;
+            if(name==='cli'){
+              const channel=await this.client.channels.fetch(interaction.channelId);
+              await handleDiscordMessage({id:randomBytes(12).toString('hex'),content:'/cli',author:{id:interaction.user.id,username:interaction.user.username,bot:false},guild:interaction.guildId?{id:interaction.guildId}:null,guildId:interaction.guildId,channelId:interaction.channelId,channel,mentions:{has:()=>true}} as any);
+              await interaction.deleteReply?.();return;
+            }
+          }
+          await handler({channel:'discord',accountId:interaction.client.user?.id??'discord',senderId:interaction.user.id,chatId:interaction.channelId,chatType:isDM?'direct':'group',text,messageId:interaction.id??randomBytes(12).toString('hex'),controlMessageId:orchButton?interaction.message?.id:undefined,ts:Date.now()});
+          if(slash)await interaction.deleteReply?.();return;
+        }
         if (!interaction.isButton?.()) return;
 
         // `/cli` approve/deny — unlock (or reject) a pending terminal-viewer
@@ -518,7 +556,7 @@ export class DiscordModule implements ChannelModule {
         const typingFileDir = path.join(this.stateDir, 'typing');
         try {
           fs.mkdirSync(typingFileDir, { recursive: true });
-          fs.writeFileSync(path.join(typingFileDir, channelId), '');
+          if (process.env.GATEWAY_ORCHESTRATION_ENABLED !== 'true') fs.writeFileSync(path.join(typingFileDir, channelId), '');
         } catch {}
 
         const inbound: InboundMessage = {
@@ -621,6 +659,8 @@ export class DiscordModule implements ChannelModule {
   }
 
   private async processTypingSignals(typingDir: string, token: string): Promise<void> {
+    // Managed activity is derived from durable Agent/Worker state; stale legacy files are not work.
+    if (process.env.GATEWAY_ORCHESTRATION_ENABLED === 'true') return;
     let files: string[];
     try { files = fs.readdirSync(typingDir); } catch { return; }
 

package/mcp/tools/discord/receiver-server.ts

@@ -7,8 +7,10 @@
 
 import { DiscordModule } from './module';
 import type { InboundMessage } from '../../types';
+import { ReceiverSpool } from '../receiver-spool';
 
 const CALLBACK_URL = process.env.CLAUDE_CHANNEL_CALLBACK;
+const spool = process.env.GATEWAY_ORCHESTRATION_INGRESS_DIR && CALLBACK_URL ? new ReceiverSpool(process.env.GATEWAY_ORCHESTRATION_INGRESS_DIR, CALLBACK_URL) : undefined;
 if (!CALLBACK_URL) {
   process.stderr.write('discord receiver: CLAUDE_CHANNEL_CALLBACK required\n');
   process.exit(1);
@@ -30,6 +32,14 @@ async function postCallback(inbound: InboundMessage): Promise<void> {
   if (inbound.attachmentFileId) {
     meta['attachment_file_id'] = inbound.attachmentFileId;
   }
+  if(inbound.attachments?.length)meta.attachments_json=JSON.stringify(inbound.attachments.map(a=>({ref:a.url,name:a.name,kind:a.kind,quoted:a.quoted})));
+  if(inbound.replyToMessageId)meta.replied_message_id=inbound.replyToMessageId;
+  if(inbound.repliedText)meta.replied_text=inbound.repliedText;
+  if(inbound.repliedSender)meta.replied_user=inbound.repliedSender;
+  if(inbound.threadId)meta.thread_ts=inbound.threadId;
+  if(inbound.attachmentKind)meta.attachment_kind=inbound.attachmentKind;
+  if(inbound.controlMessageId)meta.control_message_id=inbound.controlMessageId;
+  if (spool && !/^\/(voice|voices|tasks|stop|orch)(?:\s|$)/.test(inbound.text??'')) { spool.enqueue({ content: inbound.text ?? '', meta }); return; }
 
   try {
     await fetch(CALLBACK_URL!, {

package/mcp/tools/discord/types.ts

@@ -108,7 +108,10 @@ export interface DiscordMessage {
     parentId?: string | null;
   };
   createdTimestamp: number;
-  attachments: { first(): { url: string } | undefined };
+  reference?: {messageId?:string;channelId?:string};
+  fetchReference?(): Promise<DiscordMessage>;
+  flags?: number | {has(bit:number):boolean};
+  attachments: { first(): { url: string; contentType?: string | null; name?: string } | undefined; values?(): IterableIterator<{url:string;contentType?:string|null;name?:string}> };
   client: { user: { id: string } | null };
   startThread(options: { name: string; autoArchiveDuration: number }): Promise<{ id: string }>;
 }

package/mcp/tools/image/module.ts

@@ -735,7 +735,9 @@ export class ImageModule implements ToolModule {
           files,
           ...(artifacts ? { artifacts } : {}),
           ...(droppedImages > 0 ? { dropped_images: droppedImages } : {}),
-          note: 'Image saved. Deliver it to the user with your channel delivery tool — api_reply/reply (files: [...]), or line_image on LINE. Do NOT open/Read the file to inspect it first; attach it and answer briefly.'
+          note: (process.env.GATEWAY_ORCHESTRATION_ROLE === 'worker'
+            ? 'Image saved. Call task_stage_file for each output path, then finish this task. The agent orchestration engine owns user-facing delivery.'
+            : 'Image saved. Deliver it to the user with your channel delivery tool — api_reply/reply (files: [...]), or line_image on LINE. Do NOT open/Read the file to inspect it first; attach it and answer briefly.')
             + (model ? ` Mention which model made it (${model}).` : '')
             + (artifacts ? ' To edit this image later, reference it via its artifact_ref (e.g. image: "artifact:...").' : '')
             + (droppedImages > 0 ? ` (${droppedImages} extra image(s) beyond the cap were not saved)` : ''),

package/mcp/tools/receiver-spool.test.ts

@@ -0,0 +1,28 @@
+import { test, expect } from 'bun:test';
+import { mkdtempSync, readdirSync, rmSync, readFileSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join } from 'node:path';
+import { ReceiverSpool } from './receiver-spool';
+
+test('receiver restart retains unacknowledged input and removes it only after gateway acceptance', async () => {
+  const root = mkdtempSync(join(tmpdir(), 'receiver-spool-'));
+  let fail = true;
+  const delivered: unknown[] = [];
+  const request = (async (_url: string | URL | Request, options?: RequestInit) => {
+    delivered.push(JSON.parse(String(options?.body)));
+    return new Response('', { status: fail ? 503 : 200 });
+  }) as typeof fetch;
+  let spool = new ReceiverSpool(root, 'http://fixture.invalid/channel', request);
+  try {
+    const input = { content: 'hello', meta: { chat_id: 'original', message_id: '1' } };
+    spool.enqueue(input);
+    await new Promise(resolve => setTimeout(resolve, 10));
+    const file = readdirSync(root).find(file => file.endsWith('.json'))!;
+    expect(JSON.parse(readFileSync(join(root, file), 'utf8'))).toEqual(input);
+    spool.close(); fail = false;
+    spool = new ReceiverSpool(root, 'http://fixture.invalid/channel', request);
+    await new Promise(resolve => setTimeout(resolve, 10));
+    expect(readdirSync(root)).toEqual([]);
+    expect(delivered.at(-1)).toEqual(input);
+  } finally { spool.close(); rmSync(root, { recursive: true, force: true }); }
+});