@0xmaxma/claude-gateway 1.8.13 → 2.0.0

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

@@ -25,6 +25,13 @@ import { z } from 'zod'
 import { Bot, GrammyError, InlineKeyboard, InputFile, type Context } from 'grammy'
 import type { ReactionTypeEmoji } from 'grammy/types'
 import { randomBytes } from 'crypto'
+import { confirmSelection, voiceModeConfirmation } from './selection-confirmation'
+import { LiveTaskBrowser, type TaskBrowserMessage } from './task-browser'
+import { ReceiverSpool } from '../receiver-spool'
+const orchestrationSpool = process.env.GATEWAY_ORCHESTRATION_INGRESS_DIR && process.env.CLAUDE_CHANNEL_CALLBACK
+  ? new ReceiverSpool(process.env.GATEWAY_ORCHESTRATION_INGRESS_DIR, process.env.CLAUDE_CHANNEL_CALLBACK, fetch, Math.max(250,Math.min(10000,Number(process.env.GATEWAY_MEDIA_GROUP_WAIT_MS)||2000))) : undefined
+const ORCHESTRATION_ENABLED = process.env.GATEWAY_ORCHESTRATION_ENABLED === 'true' || Boolean(orchestrationSpool)
+const INTERACTIVE_CLI_ENABLED = process.env.GATEWAY_INTERACTIVE_CLI_ENABLED === 'true' && !ORCHESTRATION_ENABLED
 import { readFileSync, writeFileSync, mkdirSync, readdirSync, rmSync, statSync, renameSync, realpathSync, chmodSync, existsSync } from 'fs'
 import { homedir } from 'os'
 import { join, extname, sep } from 'path'
@@ -35,6 +42,7 @@ import { extractRepliedAttachment, safeName } from './reply-attachment'
 // so a src/ import crashes this bun-run receiver on installed packages (the bug
 // that silenced every bot on systemd installs). Enforced by
 // tests/unit/mcp-no-src-imports.test.ts.
+import { formatTaskDetail, type TaskDetail } from './task-detail'
 import { formatTurnIncident, type TurnIncident } from '../../../dist/agent/turn-trace.js'
 import { createIncidentStore } from '../../../dist/agent/incident-store.js'
 import type { RecoveryOutcome } from '../../../dist/agent/incident.js'
@@ -214,6 +222,7 @@ const typingManager = createWorkingStateManager(
       )
     }
   },
+  ORCHESTRATION_ENABLED ? 'orchestration' : 'legacy',
 )
 
 // Stages whose recovery must run in the runner process (live session control):
@@ -863,17 +872,18 @@ const RECEIVER_MODE = process.env.TELEGRAM_RECEIVER_MODE === 'true'
 import { parseMenuFileContent } from './menu-parser'
 
 const BOT_COMMANDS = [
+  ...(ORCHESTRATION_ENABLED ? [{ command: 'tasks', description: 'View pending tasks in this chat' }, { command: 'voice', description: 'Turn automatic voice replies on or off' }, { command: 'voices', description: 'Choose the agent voice' }] : []),
   { command: 'session', description: 'Show current session info' },
   { command: 'sessions', description: 'Manage conversation sessions' },
   { command: 'new', description: 'Create a new session' },
   { command: 'rename', description: 'Rename current session' },
   { command: 'clear', description: 'Clear current session history' },
   { command: 'compact', description: 'Summarize and compress session history' },
-  { command: 'stop', description: 'Interrupt the agent and stop current work' },
+  { command: 'stop', description: ORCHESTRATION_ENABLED ? 'Stop the agent reply and choose a task to cancel' : 'Interrupt the agent and stop current work' },
   { command: 'restart', description: 'Graceful restart session' },
   { command: 'model', description: 'Show current AI model' },
   { command: 'models', description: 'Switch AI model' },
-  { command: 'cli', description: 'Open the live terminal viewer' },
+  ...(INTERACTIVE_CLI_ENABLED ? [{ command: 'cli', description: 'Open the live terminal viewer' }] : []),
   { command: 'start', description: 'Welcome and setup guide' },
   { command: 'status', description: 'Check your pairing status' },
   { command: 'help', description: 'What this bot can do' },
@@ -1023,7 +1033,7 @@ async function handleInbound(
   // Download photo from replied-to message if present
   const replyMsg = ctx.message?.reply_to_message
   let repliedImagePath: string | undefined
-  if (replyMsg?.photo) {
+  if (replyMsg?.photo && !orchestrationSpool) {
     try {
       const largest = replyMsg.photo[replyMsg.photo.length - 1]!
       const file = await bot.api.getFile(largest.file_id)
@@ -1054,7 +1064,9 @@ async function handleInbound(
     content: text,
     meta: {
       chat_id,
+      ...(ctx.message?.media_group_id ? {media_group_id:ctx.message.media_group_id,media_caption:ctx.message.caption??''} : {}),
       ...(msgId != null ? { message_id: String(msgId) } : {}),
+      ...(ctx.message?.message_thread_id != null ? { message_thread_id: String(ctx.message.message_thread_id) } : {}),
       user: from.username ?? String(from.id),
       user_id: String(from.id),
       // Human-readable name for the chat picker / history (first_name is always
@@ -1072,8 +1084,9 @@ async function handleInbound(
       ...(replyMsg ? {
         replied_message_id: String(replyMsg.message_id),
         replied_user: replyMsg.from?.username ?? String(replyMsg.from?.id ?? ''),
-        ...(replyMsg.text ? { replied_text: replyMsg.text } : {}),
+        ...((replyMsg.text || replyMsg.caption) ? { replied_text: replyMsg.text || replyMsg.caption } : {}),
         ...(repliedImagePath ? { replied_image_path: repliedImagePath } : {}),
+        ...(orchestrationSpool && replyMsg.photo ? {replied_attachment_file_id:replyMsg.photo[replyMsg.photo.length-1]!.file_id} : {}),
         ...(repliedAttachment ? {
           replied_attachment_kind: repliedAttachment.kind,
           replied_attachment_file_id: repliedAttachment.file_id,
@@ -1103,15 +1116,16 @@ async function handleInbound(
   // turns in --print --channels mode).
   const callbackUrl = process.env.CLAUDE_CHANNEL_CALLBACK
   if (callbackUrl) {
-    fetch(callbackUrl, {
+    if (orchestrationSpool) orchestrationSpool.enqueue(channelParams)
+    else fetch(callbackUrl, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(channelParams),
     }).catch(err => {
       process.stderr.write(`telegram channel: callback POST failed: ${err}\n`)
     })
-    // Start typing indicator loop — only in receiver mode with a real AgentRunner
-    if (RECEIVER_MODE) {
+    // Legacy turn watchdog only. Orchestration owns typing through durable task/decision state.
+    if (RECEIVER_MODE && !ORCHESTRATION_ENABLED) {
       typingManager.start(chat_id)
     }
   }
@@ -1157,12 +1171,13 @@ bot.command('help', async ctx => {
     `/rename <name> — rename current session\n` +
     `/clear — clear current session history\n` +
     `/compact — summarise and compress session history\n` +
-    `/stop — interrupt the running turn\n` +
+    (ORCHESTRATION_ENABLED ? `/stop — stop the reply and choose a task to cancel\n` : `/stop — interrupt the running turn\n`) +
     `/restart — graceful restart session\n\n` +
     `*Agent*\n` +
     `/model — show current AI model\n` +
     `/models — switch AI model\n` +
-    `/cli — open the live terminal viewer\n\n` +
+    (ORCHESTRATION_ENABLED ? `/tasks — view pending tasks in this chat\n/voice — turn automatic voice replies on/off (default off)\n/voices — choose the agent voice\n` : '') +
+    (INTERACTIVE_CLI_ENABLED ? `/cli — open the live terminal viewer\n\n` : '\n') +
     `*Account*\n` +
     `/start — pairing instructions\n` +
     `/status — check your pairing state`,
@@ -1295,6 +1310,7 @@ bot.command('models', async ctx => {
 // this bot's token), so nothing secret rides in the URL. Private chat + allowlist
 // only, matching every other command.
 bot.command('cli', async ctx => {
+  if (!INTERACTIVE_CLI_ENABLED) { await ctx.reply('Terminal viewer requires interactive mode (headless: false).'); return }
   if (ctx.chat?.type !== 'private') return
   const access = loadAccess()
   if (!access.allowFrom.includes(String(ctx.from!.id))) return
@@ -1360,6 +1376,144 @@ bot.command('restart', async ctx => {
   )
 })
 
+type VoicePicker = {menuId:string;provider:string;page:number;pages:number;gender?:string;groups:string[];selected:string;voices:Array<{name:string;gender?:string;index:number;selected:boolean}>}
+async function voicePickerRequest(chatId:string,userId:string,payload:Record<string,unknown>={}) {
+  if(!CALLBACK_URL_BASE)throw new Error('not_configured')
+  const response=await fetch(CALLBACK_URL_BASE+'/command',{method:'POST',headers:{'Content-Type':'application/json'},signal:AbortSignal.timeout(20000),body:JSON.stringify({command:'telegram_voices',chat_id:chatId,payload:{...payload,user_id:userId}})})
+  const result=await response.json() as VoicePicker & {success?:boolean;name?:string}
+  if(!response.ok||!result.success)throw new Error('unavailable')
+  return result
+}
+function voicePickerMenu(menu:VoicePicker) {
+  const keyboard=new InlineKeyboard()
+  const labels:Record<string,string>={male:'👨 Male',female:'👩 Female',neutral:'Neutral',unspecified:'Unspecified'}
+  if(!menu.gender){
+    for(const group of menu.groups)keyboard.text(labels[group],`voicegroup:${menu.menuId}:${group}`).row()
+  }else{
+    for(const v of menu.voices)keyboard.text(`${v.selected?'✅ ':''}${v.name.slice(0,60)}`,`voicepick:${menu.menuId}:${v.index}`).row()
+    if(menu.page>0)keyboard.text('Previous',`voicepage:${menu.menuId}:${menu.gender}:${menu.page-1}`)
+    if(menu.page+1<menu.pages)keyboard.text('Next',`voicepage:${menu.menuId}:${menu.gender}:${menu.page+1}`)
+    keyboard.row().text('Back',`voicegroup:${menu.menuId}:back`).row()
+  }
+  keyboard.text('Dismiss',`voicedismiss:${menu.menuId}`)
+  return {text:`Agent voice · ${menu.provider}\nSelected: ${menu.selected}\n${menu.gender?`${labels[menu.gender]} — choose a voice (${menu.page+1}/${menu.pages}):`:'Choose a voice category:'}`,reply_markup:keyboard}
+}
+bot.command('voices',async ctx=>{
+  if(ctx.chat?.type!=='private'||!isCallbackAuthorized(ctx))return
+  if(!ORCHESTRATION_ENABLED){await ctx.reply('Voice controls require orchestration mode.');return}
+  try{const menu=voicePickerMenu(await voicePickerRequest(String(ctx.chat.id),String(ctx.from!.id)));await ctx.reply(menu.text,{reply_markup:menu.reply_markup})}
+  catch{await ctx.reply('Voice list unavailable. Check the TTS provider configuration and try /voices again.')}
+})
+
+type TaskView = TaskDetail & {taskId:string;title:string;state:string;progress?:string;question?:string;updatedAt:number;startedAt?:number;finishedAt?:number;canStop:boolean}
+type TaskBrowser = {sessionId:string;task?:TaskView;tasks?:TaskView[];page?:number;pages?:number;total?:number}
+async function taskBrowserRequest(chatId:string,userId:string,payload:Record<string,unknown>={}) {
+  if(!CALLBACK_URL_BASE)throw Error('not_configured')
+  const response=await fetch(CALLBACK_URL_BASE+'/command',{method:'POST',headers:{'Content-Type':'application/json'},signal:AbortSignal.timeout(10000),body:JSON.stringify({command:'telegram_tasks',chat_id:chatId,payload:{...payload,user_id:userId}})})
+  const result=await response.json() as TaskBrowser & {success?:boolean}
+  if(!response.ok||!result.success)throw Error((result as {error?:string}).error==='TASK_SESSION_CHANGED'?'TASK_SESSION_CHANGED':'unavailable')
+  if(typeof result.sessionId!=='string'||!result.sessionId)throw Error('unavailable')
+  return result
+}
+function taskBrowserMenu(result:TaskBrowser) {
+  const keyboard=new InlineKeyboard()
+  const labels:Record<string,string>={queued:'⏳ Queued',starting:'⏳ Starting',running:'🔥 Running',waiting_input:'💬 Waiting for your input',interrupting:'⏸ Interrupting',cancel_requested:'⏹ Stopping',recovering:'🔄 Recovering',needs_reconciliation:'⚠️ Needs reconciliation',completed:'✅ Completed',failed:'❌ Failed',cancelled:'⏹ Cancelled'}
+  let text:string
+  if(result.task){
+    const task=result.task
+    text=formatTaskDetail(task,labels[task.state]??task.state)
+    if(task.canStop)keyboard.text(task.state==='needs_reconciliation'?'🔄 Retry cleanup':'🔴 Stop task',`taskcancel:${task.taskId}`).row()
+    keyboard.text('Back','tasklist:0').row()
+  }else{
+    text=result.total?`Tasks (${result.total}) · Page ${(result.page??0)+1}/${result.pages}\nChoose a task for details.`:'No pending tasks in this chat.'
+    for(const [i,task] of (result.tasks??[]).entries())keyboard.text(`${(result.page??0)*10+i+1}. ${task.title.replace(/\s+/g,' ').slice(0,45)} · ${labels[task.state]??task.state}`,`taskview:${task.taskId}`).row()
+    if((result.page??0)>0)keyboard.text('Previous',`tasklist:${result.page!-1}`)
+    if((result.page??0)+1<(result.pages??1))keyboard.text('Next',`tasklist:${result.page!+1}`)
+    keyboard.row()
+  }
+  keyboard.text('Dismiss','taskdismiss')
+  return {text,reply_markup:keyboard}
+}
+const TASK_BROWSER_FILE = join(STATE_DIR, 'task-browser.json')
+let restoredTaskBrowsers: TaskBrowserMessage[] = []
+try { const saved = JSON.parse(readFileSync(TASK_BROWSER_FILE, 'utf8')); if (Array.isArray(saved)) restoredTaskBrowsers = saved } catch {}
+const liveTaskBrowser = new LiveTaskBrowser({
+  read: taskBrowserRequest,
+  render: result => taskBrowserMenu(result as TaskBrowser),
+  send: async (chat, menu) => (await bot.api.sendMessage(chat, menu.text, {reply_markup: menu.reply_markup as InlineKeyboard})).message_id,
+  edit: (chat, id, menu) => bot.api.editMessageText(chat, id, menu.text, {reply_markup: menu.reply_markup as InlineKeyboard}),
+  remove: (chat, id) => bot.api.deleteMessage(chat, id),
+  close: (chat, id) => bot.api.editMessageText(chat, id, 'Task view closed.', {reply_markup: {inline_keyboard: []}}),
+  allowed: (chat, user) => ORCHESTRATION_ENABLED && chat === user && loadAccess().allowFrom.includes(user),
+  persist: entries => {
+    mkdirSync(STATE_DIR, {recursive:true,mode:0o700})
+    const temp = TASK_BROWSER_FILE + '.tmp'
+    writeFileSync(temp,JSON.stringify(entries),{mode:0o600});renameSync(temp,TASK_BROWSER_FILE)
+  },
+}, restoredTaskBrowsers)
+if (ORCHESTRATION_ENABLED) setInterval(() => { void liveTaskBrowser.tick().catch(() => {}) }, 3000).unref()
+bot.command('tasks',async ctx=>{
+  if(ctx.chat?.type!=='private'||!isCallbackAuthorized(ctx))return
+  if(!ORCHESTRATION_ENABLED){await ctx.reply('Task controls require orchestration mode.');return}
+  try{await liveTaskBrowser.open(String(ctx.chat.id),String(ctx.from!.id))}
+  catch{await ctx.reply('Could not load tasks. Please try /tasks again.')}
+})
+
+async function taskStopRequest(chatId: string, userId: string, menuId?: string, index?: number) {
+  if (!CALLBACK_URL_BASE) throw new Error('not_configured')
+  const response=await fetch(CALLBACK_URL_BASE+'/command', {
+    method:'POST',headers:{'Content-Type':'application/json'},signal:AbortSignal.timeout(10000),
+    body:JSON.stringify({command:'task_stop',chat_id:chatId,payload:{user_id:userId,menu_id:menuId,index}}),
+  })
+  const result=await response.json() as {success?:boolean;legacy?:boolean;text?:string;menuId?:string;tasks?:Array<{title:string;state:string}>}
+  if (!response.ok || !result.success) throw new Error('unavailable')
+  return result
+}
+bot.command('stop',async (ctx,next)=>{
+  if (!ORCHESTRATION_ENABLED || ctx.chat?.type!=='private') return next()
+  if (!isCallbackAuthorized(ctx)) return
+  try {
+    const result=await taskStopRequest(String(ctx.chat.id),String(ctx.from!.id))
+    if (result.legacy) return
+    const keyboard=new InlineKeyboard()
+    for (const [i,task] of (result.tasks??[]).entries()) keyboard.text(`${i+1}. ${task.title.slice(0,65)} (${task.state})`,`taskstop:${result.menuId}:${i+1}`).row()
+    if (result.tasks?.length) keyboard.text('Dismiss',`taskstop:${result.menuId}:0`)
+    await ctx.reply(result.text??'Nothing to stop.',result.tasks?.length?{reply_markup:keyboard}:{})
+  } catch { await ctx.reply('Could not load tasks. Please try /stop again.') }
+})
+
+// Voice settings are handled directly; no model call or TTS for this menu.
+type VoiceReplyMode = 'on' | 'auto' | 'off'
+async function telegramVoiceSetting(chatId: string, mode?: VoiceReplyMode): Promise<VoiceReplyMode> {
+  if (!CALLBACK_URL_BASE) throw new Error('not_configured')
+  const response = await fetch(CALLBACK_URL_BASE + '/command', {
+    method: 'POST', headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ command: 'telegram_voice', chat_id: chatId, payload: { mode } }),
+    signal: AbortSignal.timeout(10000),
+  })
+  const result = await response.json() as { success?: boolean; enabled?: boolean; mode?: VoiceReplyMode }
+  if (!response.ok || !result.success || typeof result.enabled !== 'boolean') throw new Error('unavailable')
+  return result.mode ?? (result.enabled ? 'on' : 'off')
+}
+function voiceMenu(mode: VoiceReplyMode) {
+  const labels = {on:'🔊 Always', auto:'🎙️ Only reply voice message', off:'🔇 Off'}
+  const keyboard = new InlineKeyboard()
+  for (const value of ['on','auto','off'] as const) keyboard.text(`${mode === value ? '✅ ' : ''}${labels[value]}`, `voice:${value}`).row()
+  return {text: `Voice replies: ${labels[mode]}\nAuto replies with audio to voice messages and their task results.`, reply_markup: keyboard.text('Dismiss','voice:dismiss')}
+}
+bot.command('voice', async ctx => {
+  if (!ORCHESTRATION_ENABLED) { await ctx.reply('Voice controls require orchestration mode.'); return }
+  if (ctx.chat?.type !== 'private' || !isCallbackAuthorized(ctx)) return
+  const choice = ctx.match.trim().toLowerCase()
+  if (choice && choice !== 'on' && choice !== 'off' && choice !== 'auto') {
+    await ctx.reply('Use /voice to open the menu, or /voice on, /voice auto and /voice off.'); return
+  }
+  try {
+    const menu = voiceMenu(await telegramVoiceSetting(String(ctx.chat.id), choice ? choice as VoiceReplyMode : undefined))
+    await ctx.reply(menu.text, choice ? {} : { reply_markup: menu.reply_markup })
+  } catch { await ctx.reply('Voice settings are unavailable. Check the agent TTS configuration.') }
+})
+
 // /session — show current session info (direct command, no typing manager)
 bot.command('session', async ctx => {
   if (ctx.chat?.type !== 'private') return
@@ -1481,6 +1635,69 @@ function validModelRows(value: unknown): Array<{ id: string; label: string }> {
 bot.on('callback_query:data', async ctx => {
   const data = ctx.callbackQuery.data
 
+  const voicePicker=/^(voicepick|voicepage|voicegroup|voicedismiss):([a-f0-9-]{36})(?::(male|female|neutral|unspecified|back))?(?::(\d+))?$/.exec(data)
+  if(voicePicker){
+    if(!ORCHESTRATION_ENABLED||ctx.callbackQuery.message?.chat.type!=='private'||!isCallbackAuthorized(ctx)){await ctx.answerCallbackQuery({text:'Not available or not authorized.'}).catch(()=>{});return}
+    try{
+      const action=voicePicker[1],id=voicePicker[2],n=Number(voicePicker[4]),chatId=String(ctx.callbackQuery.message.chat.id),userId=String(ctx.from.id)
+      if(action==='voicepage'||action==='voicegroup'){
+        const menu=voicePickerMenu(await voicePickerRequest(chatId,userId,{menu_id:id,page:action==='voicepage'?n:0,gender:voicePicker[3]==='back'?undefined:voicePicker[3]}))
+        await ctx.editMessageText(menu.text,{reply_markup:menu.reply_markup}).catch(()=>{});await ctx.answerCallbackQuery().catch(()=>{})
+      }else{
+        const result=await voicePickerRequest(chatId,userId,{action:action==='voicepick'?'choose':'dismiss',menu_id:id,index:n})
+        await ctx.answerCallbackQuery({text:action==='voicepick'?`Selected: ${result.name}`.slice(0,180):'Dismissed'}).catch(()=>{})
+        if(action==='voicepick') await confirmSelection(ctx,`✅ Agent voice: ${result.name} · ${result.provider}`)
+        else await ctx.deleteMessage().catch(()=>{})
+      }
+    }catch{await ctx.answerCallbackQuery({text:'Voice list changed or unavailable. Use /voices again.'}).catch(()=>{})}
+    return
+  }
+
+  const taskBrowser=/^(taskview|taskcancel):([a-f0-9-]{36})$|^(tasklist):(\d+)$|^(taskdismiss)$/.exec(data)
+  if(taskBrowser){
+    if(!ORCHESTRATION_ENABLED||ctx.callbackQuery.message?.chat.type!=='private'||!isCallbackAuthorized(ctx)){await ctx.answerCallbackQuery({text:'Not available or not authorized.'}).catch(()=>{});return}
+    try{
+      await ctx.answerCallbackQuery().catch(()=>{})
+      const payload=data==='taskdismiss'?{action:'dismiss'}:taskBrowser[1]?{action:taskBrowser[1]==='taskcancel'?'cancel':'detail',task_id:taskBrowser[2]}:{page:Number(taskBrowser[4])}
+      await liveTaskBrowser.navigate(String(ctx.callbackQuery.message.chat.id),String(ctx.from.id),ctx.callbackQuery.message.message_id,payload)
+    }catch{await ctx.answerCallbackQuery({text:'Task unavailable. Use /tasks to refresh.'}).catch(()=>{})}
+    return
+  }
+
+  const taskStop=/^taskstop:([a-f0-9-]{36}):(\d+)$/.exec(data)
+  if (taskStop) {
+    if (!ORCHESTRATION_ENABLED) { await ctx.answerCallbackQuery({text:'Task controls require orchestration mode.'}).catch(()=>{}); return }
+    if (ctx.callbackQuery.message?.chat.type!=='private' || !isCallbackAuthorized(ctx)) {
+      await ctx.answerCallbackQuery({text:'Not authorized.'}).catch(()=>{}); return
+    }
+    try {
+      const result=await taskStopRequest(String(ctx.callbackQuery.message.chat.id),String(ctx.from.id),taskStop[1],Number(taskStop[2]))
+      await ctx.answerCallbackQuery({text:Number(taskStop[2])===0?'Dismissed':'Stop requested.'}).catch(()=>{})
+      await ctx.deleteMessage().catch(()=>{})
+      if (Number(taskStop[2])!==0) await ctx.reply(result.text??'Stop requested.')
+    } catch { await ctx.answerCallbackQuery({text:'Selection unavailable. Use /stop to refresh.'}).catch(()=>{}) }
+    return
+  }
+
+  if (data === 'voice:on' || data === 'voice:auto' || data === 'voice:off' || data === 'voice:dismiss') {
+    if (!ORCHESTRATION_ENABLED) { await ctx.answerCallbackQuery({text:'Voice controls require orchestration mode.'}).catch(()=>{}); return }
+    if (ctx.callbackQuery.message?.chat.type !== 'private' || !isCallbackAuthorized(ctx)) {
+      await ctx.answerCallbackQuery({ text: 'Not authorized.' }).catch(() => {}); return
+    }
+    if (data === 'voice:dismiss') {
+      await ctx.answerCallbackQuery({ text: 'Dismissed' }).catch(() => {})
+      await ctx.deleteMessage().catch(() => {})
+      return
+    }
+    try {
+      await telegramVoiceSetting(String(ctx.callbackQuery.message.chat.id), data.slice(6) as VoiceReplyMode)
+      const confirmation=voiceModeConfirmation(data.slice(6))
+      await ctx.answerCallbackQuery({text:confirmation}).catch(()=>{})
+      await confirmSelection(ctx,confirmation)
+    } catch { await ctx.answerCallbackQuery({ text: 'Could not update voice settings. Please try again.' }).catch(() => {}) }
+    return
+  }
+
   // Handle interactive-menu choice: choice:<N>. A tap is routed back exactly like
   // the user typing "N" — same content + meta as the text path — so the session's
   // pending-menu handler injects the selection into the PTY. Security mirrors the
@@ -1514,7 +1731,7 @@ bot.on('callback_query:data', async ctx => {
       }).catch(err => {
         process.stderr.write(`telegram channel: choice callback POST failed: ${err}\n`)
       })
-      if (RECEIVER_MODE) typingManager.start(chat_id)
+      if (RECEIVER_MODE && !ORCHESTRATION_ENABLED) typingManager.start(chat_id)
     }
     return
   }
@@ -1732,7 +1949,7 @@ bot.on('callback_query:data', async ctx => {
       await ctx.answerCallbackQuery({ text: 'Compacting...' }).catch(() => {})
       await ctx.deleteMessage().catch(() => {})
       await ctx.reply('🧠 Session compacting, please wait...\nThis may take a moment.').catch(() => {})
-      if (RECEIVER_MODE) {
+      if (RECEIVER_MODE && !ORCHESTRATION_ENABLED) {
         typingManager.start(chatId)
       }
       await fetch(CALLBACK_URL_BASE + '/command', {
@@ -1978,6 +2195,10 @@ bot.on('message:text', async ctx => {
 
 bot.on('message:photo', async ctx => {
   const caption = ctx.message.caption ?? '(photo)'
+  if(orchestrationSpool){
+    const photo=ctx.message.photo[ctx.message.photo.length-1]!;
+    await handleInbound(ctx,caption,undefined,{kind:'photo',file_id:photo.file_id,size:photo.file_size,mime:'image/jpeg'});return;
+  }
   // Defer download until after the gate approves — any user can send photos,
   // and we don't want to burn API quota or fill the inbox for dropped messages.
   await handleInbound(ctx, caption, async () => {

package/mcp/tools/telegram/selection-confirmation.ts

@@ -0,0 +1,20 @@
+/** Keep a durable confirmation in chat, matching the /models menu behavior. */
+export async function confirmSelection(ctx: {
+  editMessageText(text: string, options: {reply_markup: {inline_keyboard: never[]}}): Promise<unknown>;
+  reply(text: string): Promise<unknown>;
+  deleteMessage(): Promise<unknown>;
+}, text: string): Promise<void> {
+  try { await ctx.editMessageText(text, {reply_markup: {inline_keyboard: []}}); }
+  catch (error) {
+    if (/message is not modified/i.test(String((error as any)?.description ?? (error as any)?.message))) return;
+    // If Telegram cannot edit an old menu, retain the confirmation as a new
+    // message before removing the old controls. Never lose both.
+    await ctx.reply(text);
+    await ctx.deleteMessage().catch(() => {});
+  }
+}
+export function voiceModeConfirmation(mode: string): string {
+  const labels: Record<string,string> = {on:'Always',auto:'Only reply voice message',off:'Off'};
+  if (!(mode in labels)) throw Error('INVALID_VOICE_MODE');
+  return `✅ Voice replies: ${labels[mode]}`;
+}

package/mcp/tools/telegram/task-browser.ts

@@ -0,0 +1,117 @@
+/** A single live task browser per private chat. All reads are session-bound and
+ * serialized with navigation, replacement, and explicit cancellation. */
+export interface TaskBrowserMessage {
+  chatId: string; userId: string; messageId: number; sessionId: string;
+  view: { page?: number; action?: 'detail'; task_id?: string };
+}
+export interface TaskBrowserResult {
+  sessionId: string;
+  task?: { taskId: string; state: string };
+  page?: number;
+}
+export interface TaskBrowserMenu { text: string; reply_markup: unknown }
+interface Entry extends TaskBrowserMessage { fingerprint?: string; retryAt?: number; finished?: boolean }
+interface Dependencies {
+  read(chat: string, user: string, payload: Record<string, unknown>): Promise<TaskBrowserResult>;
+  render(result: TaskBrowserResult): TaskBrowserMenu;
+  send(chat: string, menu: TaskBrowserMenu): Promise<number>;
+  edit(chat: string, id: number, menu: TaskBrowserMenu): Promise<unknown>;
+  remove(chat: string, id: number): Promise<unknown>;
+  close(chat: string, id: number): Promise<unknown>;
+  allowed(chat: string, user: string): boolean;
+  persist(entries: TaskBrowserMessage[]): void;
+  now?: () => number;
+}
+const description = (e: any) => String(e?.description ?? e?.message ?? '');
+const absent = (e: any) => /message to (?:edit|delete) not found|message_id_invalid/i.test(description(e));
+const unchanged = (e: any) => /message is not modified/i.test(description(e));
+export class LiveTaskBrowser {
+  private entries = new Map<string, Entry>();
+  private locks = new Map<string, Promise<unknown>>();
+  private nextEditAt = 0;
+  constructor(private io: Dependencies, restored: TaskBrowserMessage[] = []) {
+    for (const e of restored) {
+      if (e && typeof e === 'object' && /^\d+$/.test(e.chatId) && e.userId === e.chatId && Number.isSafeInteger(e.messageId) && e.messageId > 0 && typeof e.sessionId === 'string' && e.view &&
+        (e.view.action === 'detail' ? typeof e.view.task_id === 'string' : Number.isSafeInteger(e.view.page ?? 0))) this.entries.set(e.chatId, { ...e });
+    }
+  }
+  private now() { return this.io.now?.() ?? Date.now(); }
+  private persist() {
+    this.io.persist([...this.entries.values()].map(({chatId,userId,messageId,sessionId,view}) => ({chatId,userId,messageId,sessionId,view})));
+  }
+  private serial<T>(chat: string, work: () => Promise<T>): Promise<T> {
+    const previous = this.locks.get(chat) ?? Promise.resolve();
+    const job = previous.catch(() => {}).then(work);
+    this.locks.set(chat, job);
+    void job.finally(() => { if (this.locks.get(chat) === job) this.locks.delete(chat); }).catch(() => {});
+    return job;
+  }
+  private async retire(e: Entry) {
+    try { await this.io.remove(e.chatId, e.messageId); }
+    catch (error) {
+      if (!absent(error)) {
+        try { await this.io.close(e.chatId, e.messageId); }
+        catch (closed) { if (!absent(closed) && !unchanged(closed)) throw closed; }
+      }
+    }
+    this.entries.delete(e.chatId); this.persist();
+  }
+  open(chatId: string, userId: string) {
+    return this.serial(chatId, async () => {
+      if (!this.io.allowed(chatId, userId)) throw Error('TASK_BROWSER_UNAUTHORIZED');
+      const result = await this.io.read(chatId, userId, { page: 0 });
+      const menu = this.io.render(result);
+      const previous = this.entries.get(chatId);
+      if (previous) await this.retire(previous);
+      const messageId = await this.io.send(chatId, menu);
+      this.entries.set(chatId, {chatId,userId,messageId,sessionId:result.sessionId,view:{page:result.page ?? 0},fingerprint:JSON.stringify(menu)});
+      this.persist();
+    });
+  }
+  navigate(chatId: string, userId: string, messageId: number, payload: Record<string, unknown>) {
+    return this.serial(chatId, async () => {
+      const e = this.entries.get(chatId);
+      if (!e || e.messageId !== messageId || e.userId !== userId || !this.io.allowed(chatId,userId)) throw Error('TASK_BROWSER_EXPIRED');
+      if (payload.action === 'dismiss') { await this.retire(e); return; }
+      try {
+        const result = await this.io.read(chatId,userId,{...payload,session_id:e.sessionId});
+        // Never repeat a mutation during auto-refresh, even if Telegram edit fails.
+        e.view = result.task ? {action:'detail',task_id:result.task.taskId} : {page:result.page ?? 0};
+        this.persist();
+        await this.update(e,result);
+      } catch (error) { await this.failure(e,error); throw error; }
+    });
+  }
+  private async update(e: Entry, result: TaskBrowserResult) {
+    if (result.sessionId !== e.sessionId) throw Error('TASK_SESSION_CHANGED');
+    const view = result.task ? { action: 'detail' as const, task_id: result.task.taskId } : { page: result.page ?? 0 };
+    if (JSON.stringify(view) !== JSON.stringify(e.view)) { e.view = view; this.persist(); }
+    const finished = !!result.task && ['completed','failed','cancelled'].includes(result.task.state);
+    const menu = this.io.render(result), fingerprint = JSON.stringify(menu);
+    if (fingerprint === e.fingerprint) { e.finished = finished; return; }
+    try { await this.io.edit(e.chatId,e.messageId,menu); }
+    catch (error) { if (!unchanged(error)) throw error; }
+    e.fingerprint = fingerprint; e.retryAt = undefined; e.finished = finished;
+  }
+  private async failure(e: Entry, error: any) {
+    if (description(error).includes('TASK_SESSION_CHANGED')) { await this.retire(e); return; }
+    if (absent(error) || error?.error_code === 403) { this.entries.delete(e.chatId); this.persist(); return; }
+    const retry = Number(error?.parameters?.retry_after);
+    e.retryAt = this.now() + (Number.isFinite(retry) && retry > 0 ? retry * 1000 : 10000);
+    if (retry > 0) this.nextEditAt = Math.max(this.nextEditAt,e.retryAt);
+  }
+  async tick() {
+    // One tick cannot overlap a previous read/edit or user action for this chat.
+    for (const e of [...this.entries.values()]) {
+      if (e.finished || this.locks.has(e.chatId) || this.now() < Math.max(e.retryAt ?? 0,this.nextEditAt)) continue;
+      await this.serial(e.chatId, async () => {
+        if (this.entries.get(e.chatId) !== e) return;
+        if (!this.io.allowed(e.chatId,e.userId)) {
+          this.entries.delete(e.chatId); this.persist(); return;
+        }
+        try { await this.update(e,await this.io.read(e.chatId,e.userId,{...e.view,session_id:e.sessionId})); }
+        catch (error) { await this.failure(e,error).catch(() => {}); }
+      });
+    }
+  }
+}

package/mcp/tools/telegram/task-detail.ts

@@ -0,0 +1,36 @@
+import { formatTiming } from '../../../dist/orchestration/tasks/timing';
+import { formatTaskElapsed } from './task-elapsed';
+import type { ProcessSample } from '../../../src/orchestration/process-activity';
+import type { ToolOutcome } from '../../../src/orchestration/execution-observation';
+
+export interface TaskDetail {
+  title: string; state: string; startedAt?: number; finishedAt?: number;
+  timing?: Partial<Record<'working' | 'tool' | 'input' | 'queued' | 'other' | 'finished', number>>;
+  timingMeasuredFrom?: number;
+  progress?: string; progressText?: string; question?: string;
+  activityDetails?: { counters: string; status: string; age: number; activeTools: string[];
+    observationStatus?: string; process?: ProcessSample; lastTool?: ToolOutcome; quiet?: boolean };
+}
+function bytes(value: number): string {
+  const unit = value >= 1000000 ? 'MB' : value >= 1000 ? 'KB' : 'B';
+  return `${Number((value / (unit === 'MB' ? 1000000 : unit === 'KB' ? 1000 : 1)).toFixed(2))} ${unit}`;
+}
+export function formatTaskDetail(task: TaskDetail, label: string): string {
+  const activity = task.activityDetails;
+  const progress = task.progressText ?? task.progress;
+  const progressLines = [progress, activity?.activeTools.length ? `Active tools: ${activity.activeTools.join(', ')}` : '', activity ? `Last activity: ${activity.age}s ago.` : '', task.question ? `Waiting for your input:\n${task.question}` : ''].filter(Boolean);
+  const process = activity?.process;
+  const counters = process ? process.available ? [
+    `Processes: ${process.processCount}`,
+    process.cpuTicksDelta !== undefined ? `CPU: +${process.cpuTicksDelta} ticks · Children: ${process.childCpuTicksDelta === undefined ? 'unavailable' : `+${process.childCpuTicksDelta} ticks`}` : 'CPU: unavailable',
+    process.ioAvailable ? `I/O: Read ${process.readBytesDelta === undefined ? 'unavailable' : `+${bytes(process.readBytesDelta)}`} · Write ${process.writeBytesDelta === undefined ? 'unavailable' : `+${bytes(process.writeBytesDelta)}`}` : 'I/O: partially unavailable',
+  ].join('\n') : '' : activity?.counters;
+  const lastTool = activity?.lastTool;
+  const diagnostics = [counters, lastTool ? `Last tool: ${lastTool.name} · ${lastTool.status === 'error' ? 'Reported error' : 'Result received'}${lastTool.exitCode === undefined ? '' : ` · Exit code: ${lastTool.exitCode}`}\nReported at: ${new Date(lastTool.observedAt).toISOString().replace('T',' ').replace(/\.\d{3}Z$/, ' UTC')}` : '', activity?.observationStatus ?? activity?.status, activity?.quiet ? 'No recent tool/model progress; task retained for inspection or cancellation.' : ''].filter(Boolean);
+  return [
+    `${task.title}\n${label} · Elapsed: ${formatTaskElapsed(task.startedAt,task.finishedAt)}`,
+    formatTiming(task.timing) ? 'Time breakdown\n' + formatTiming(task.timing) + (task.timingMeasuredFrom && task.startedAt && task.timingMeasuredFrom > task.startedAt + 1000 ? '\nMeasured since ' + new Date(task.timingMeasuredFrom).toISOString() : '') : '',
+    progressLines.length ? `Progress\n${progressLines.join('\n')}` : '',
+    diagnostics.length ? `Diagnostics\n${diagnostics.join('\n')}` : '',
+  ].filter(Boolean).join('\n\n');
+}

package/mcp/tools/telegram/task-elapsed.ts

@@ -0,0 +1 @@
+export { formatTaskElapsed } from '../../../dist/shared/task-elapsed';