@jc_stack/ez-agents 0.1.0-beta.27 → 0.1.0-beta.29

package/src/identity.ts

@@ -1,5 +1,6 @@
 import type { Context } from 'grammy'
 import type { Owner } from './control-state.js'
+import { ownerId, ownerEpoch } from './control-state.js'
 
 export const isOwner = (ctx: Pick<Context, 'from' | 'chat'>, owner: Owner | null): boolean =>
   Boolean(
@@ -12,9 +13,16 @@ export const isOwner = (ctx: Pick<Context, 'from' | 'chat'>, owner: Owner | null
       ctx.chat?.id === owner.telegramChatId,
   )
 
-export const ownsRun = (owner: Owner | null, run: {telegramUserId: number; chatId: number}): boolean =>
-  Boolean(owner && Number.isSafeInteger(run.telegramUserId) && run.telegramUserId > 0 &&
-    run.chatId === owner.telegramChatId && (owner.kind === 'group' || run.telegramUserId === owner.telegramUserId))
+export const ownsRun = (owner: Owner | null, run: {application?: unknown; ownerId?: string; ownerEpoch?: string; telegramEpoch?: string; telegramUserId?: number; chatId?: number}): boolean =>
+  // Legacy app runs used the original Telegram owner IDs as bookkeeping. Their
+  // validated application binding remains the authority, not the current TG link.
+  Boolean(owner && (run.application && run.ownerId === undefined
+    ? ownerId(owner) === `telegram:${run.telegramUserId}:${run.chatId}`
+    : (run.chatId === undefined ||
+    (run.chatId === owner.telegramChatId && (run.telegramEpoch ?? owner.pairedAt) === (owner.telegramLinkedAt ?? owner.pairedAt))) && (run.ownerId !== undefined
+    ? run.ownerId === ownerId(owner) && run.ownerEpoch === ownerEpoch(owner)
+    : Number.isSafeInteger(run.telegramUserId) && run.telegramUserId! > 0 &&
+      run.chatId === owner.telegramChatId && (owner.kind === 'group' || run.telegramUserId === owner.telegramUserId))))
 
 export const assertId = (id: string): string => {
   if (!/^[a-zA-Z0-9_-]+$/.test(id)) throw new Error('Invalid record identifier')

package/src/index.ts

@@ -1,8 +1,10 @@
+import { ApplicationChannel } from './application-channel.js'
 import { failureEvidence } from './failure.js'
 import { TelegramSource } from './telegram-source.js'
 import { Tasks } from './tasks.js'
 import { taskRequests } from './task-rpc.js'
 import { executionBlockReason } from './execution-authority.js'
+import {authorizeDeliveryContext} from './delivery-context.mjs'
 import { dispatchChannel } from './channel-backend.js'
 import { randomUUID } from 'node:crypto'
 import { stat } from 'node:fs/promises'
@@ -20,7 +22,7 @@ import { isOwner, ownsRun } from './identity.js'
 import type { Update } from 'grammy/types'
 import { InboxStore, type IncomingItem } from './inbox.js'
 import { loadConfig, type Config } from './config.js'
-import { ControlStore } from './control-state.js'
+import { ControlStore, telegramOwner, ownerId, ownerEpoch } from './control-state.js'
 import { ApprovalStore } from './approval.js'
 import { startExecutorJob, terminateJob } from './executor.js'
 import { RunStore, type RunRecord } from './runs.js'
@@ -30,6 +32,7 @@ import { sanitizeFileName, stageIncomingFile, workspaceFile } from './files.js'
 import { transcribeAudio, synthesizeSpeech } from './audio.js'
 import { normalizeReactionEmoji } from './reaction.js'
 import { downloadTelegramFile } from './read-request.js'
+import { createConversationMenu } from './conversation-menu.js'
 import { createAiMenu, mainCommands, mainKeyboard } from './menu.js'
 import { chatPreset, initialPreset, persistedPreset, presetLabel, statusPreset } from './ai.js'
 import { discoverDefaults } from './client-defaults.js'
@@ -45,7 +48,9 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     }
     return message
   }
-  const bot = new Bot(config.telegramBotToken)
+  const telegramEnabled = config.telegramEnabled !== false
+  if (!telegramEnabled && (!config.applicationPort || config.channelBackendUrl)) throw new Error('Application-only execution requires the native application listener')
+  const bot = telegramEnabled ? new Bot(config.telegramBotToken) : null
   const control = new ControlStore(config.controlDir, config.pairingTtlMs)
   const approvals = new ApprovalStore(config.controlDir)
   const runs = new RunStore(config.controlDir)
@@ -64,6 +69,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   let taskTimer: ReturnType<typeof setInterval> | undefined
   let drainTimer: ReturnType<typeof setInterval> | undefined
   const codexHome = join(config.controlDir, 'cli', 'codex')
+  const conversationMenu = createConversationMenu(control, runs)
   const aiMenu = createAiMenu(control, config.executorCli, undefined, config.workspace, codexHome)
   const durableWorkerChoice = () => control.captureChoice(aiMenu.initial)
   const binDir = join(dirname(fileURLToPath(import.meta.url)), '..', 'bin')
@@ -81,6 +87,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   let activeBackend = false
   const ownerStopped = new WeakSet<ChildProcess>()
   let activeChild: ChildProcess | null = null
+  let runtimeStarted = false
   let shuttingDown = false
   let wakePollRetry: (() => void) | undefined
   const pollingAbort = new AbortController()
@@ -100,17 +107,36 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     return next
   }
 
-  const sendChat = async (chatId: number, text: string, replyToMessageId?: number): Promise<number[]> => {
+  const applicationChannel = new ApplicationChannel({
+    controlDir: config.controlDir, initial: aiMenu.initial,
+    aiControls: aiMenu,
+    wake: () => { void drainSources().catch(error => console.error('Application queue unavailable', safeError(error))) },
+    cancel: id => withStartLock(async () => {
+      const run = await runs.get(id)
+      if (run?.status === 'queued') await runs.patch(id, {status:'cancelled',endedAt:new Date().toISOString()})
+      else if (run?.status === 'running') {
+        const child = background.get(id)
+        if (child) { await scheduler.cancel(id); terminateJob(child); return }
+        if (!activeChild || (await runs.running(false))?.id !== id) throw new Error('Application cancellation unavailable')
+        ownerStopped.add(activeChild)
+        terminateJob(activeChild)
+      }
+    }),
+  })
+
+  const sendChat = async (chatId: number, text: string, replyToMessageId?: number, authorize?:()=>Promise<void>): Promise<number[]> => {
+    if (!bot) throw new Error('Telegram delivery is disabled')
     const ids: number[] = []
     const parts = splitTelegramText(text)
     for (let i = 0; i < parts.length; i++) {
       await paceSend()
+      await authorize?.()
       const part = parts[i]
       const replyParams =
         i === 0 && replyToMessageId ? { reply_parameters: { message_id: replyToMessageId } } : {}
       try {
         const html = markdownToTelegramHtml(part)
-        const sent = await bot.api.sendMessage(chatId, html, { parse_mode: 'HTML', ...replyParams })
+        const sent = await bot!.api.sendMessage(chatId, html, { parse_mode: 'HTML', ...replyParams })
         ids.push(sent.message_id)
       } catch (error) {
         if (
@@ -120,14 +146,14 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         )
           throw error
         // Fallback to plain text if HTML parsing fails
-        const sent = await bot.api.sendMessage(chatId, part, { ...replyParams })
+        const sent = await bot!.api.sendMessage(chatId, part, { ...replyParams })
         ids.push(sent.message_id)
       }
     }
     return ids
   }
 
-  const telegramSource = new TelegramSource(config.controlDir, config.telegramBotToken.split(':')[0], sendChat)
+  const telegramSource = telegramEnabled ? new TelegramSource(config.controlDir, config.telegramBotToken.split(':')[0], sendChat) : null
 
   const startJob = async (run: RunRecord): Promise<void> => {
     await withStartLock(async () => {
@@ -135,12 +161,17 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       // stat uses the effective UID; access uses the relay's isolated real UID.
       if (await stat(join(config.controlDir,'upgrade-pause.json')).then(()=>true,e=>{if(e.code==='ENOENT')return false;throw e})) return
       if ((await runs.get(run.id))?.status !== 'queued') return
+      if (!telegramEnabled && !run.application && !run.delivery && !run.scheduled) return
       if (!run.scheduled && await runs.running(false)) return
       const owner = (await control.status()).owner
       if (!owner || !ownsRun(owner, run)) {
         await runs.patch(run.id, { status: 'failed', endedAt: new Date().toISOString() })
         return
       }
+      if (run.application || run.delivery) {
+        try { await applicationChannel.bindings.authorize(run) }
+        catch { await runs.patch(run.id, { status: 'cancelled', endedAt: new Date().toISOString() }); return }
+      }
       if (config.channelBackendUrl) {
         if (run.external || run.taskId || run.scheduled || run.id.startsWith('r_update_')) { await runs.patch(run.id, { status: 'failed' }); return }
         activeBackend = true
@@ -205,6 +236,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           model: selected.model,
           effort: selected.effort,
           codexAutoCompactTokens: config.codexAutoCompactTokens,
+          codexSandbox: !run.taskId && selected.cli === 'codex' ? config.codexSandbox : undefined,
           sessionId: session.nativeSessionId || session.sessionId,
           isResume: session.hasStarted,
           eventSource: run.external?.sourceId,
@@ -242,8 +274,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         })
 
         if (!run.scheduled && activeTypingTimer) clearInterval(activeTypingTimer)
-        if (!run.external && !run.taskId && !run.scheduled) activeTypingTimer = setInterval(() => {
-          if (performance.now() - executionStarted < 30000) void bot.api.sendChatAction(run.chatId, 'typing').catch(() => {})
+        if (bot && run.chatId !== undefined && !run.application && !run.external && !run.taskId && !run.scheduled) activeTypingTimer = setInterval(() => {
+          if (performance.now() - executionStarted < 30000) void bot.api.sendChatAction(run.chatId!, 'typing').catch(() => {})
         }, 4000)
 
         const completion = finished.then((code) => {
@@ -282,7 +314,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         }
         await runs.patch(run.id, { status: 'failed', failureReason: 'executor-start', failure: await failureEvidence(config.controlDir, safeError(error)), endedAt: new Date().toISOString() })
         console.error('run start failed', run.id, safeError(error))
-        await sendChat(run.chatId, `Run ${run.id} failed to start. Check the local relay log.`)
+        if (bot && !run.application && !run.delivery && run.chatId !== undefined) await sendChat(run.chatId, `Run ${run.id} failed to start. Check the local relay log.`)
         setImmediate(() => {
           void runs
             .nextQueued(false)
@@ -299,16 +331,32 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     if (sourceWork) return sourceWork
     sourceWork = (async () => {
       if (shuttingDown) return
+      const foreground = await runs.running(false)
       const owner = (await control.status()).owner
+      if (foreground && activeChild) {
+        try {
+          if (!ownsRun(owner, foreground)) throw new Error('Owner channel revoked')
+          if (foreground.application) await applicationChannel.bindings.authorize(foreground)
+        }
+        catch { ownerStopped.add(activeChild); terminateJob(activeChild) }
+      }
+      for (const [id, child] of background) {
+        const run = await runs.get(id)
+        try {
+          if (!run || !ownsRun(owner, run)) throw new Error('Owner revoked')
+          if (run.delivery) await applicationChannel.bindings.authorize(run)
+        } catch { ownerStopped.add(child); terminateJob(child); continue }
+        if (await scheduler.cancelled(id)) terminateJob(child)
+      }
       if (!owner) return
       if (!config.channelBackendUrl) {
       await drainTaskRequests()
       for (const task of await tasks.list()) if (task.state === 'pending' || task.state === 'active' || task.unwatchPending) {
         try { await tasks.decide(task.id) } catch { /* Failed or stale grants cannot launch. */ }
       }
-      await queueUpdateAttention(config.controlDir,owner,runs,await durableWorkerChoice())
+      if (telegramOwner(owner)) await queueUpdateAttention(config.controlDir,owner,runs,await durableWorkerChoice())
       }
-      for (const source of config.channelBackendUrl ? [] : await sources.available(owner)) {
+      for (const source of !telegramOwner(owner) || config.channelBackendUrl ? [] : await sources.available(owner)) {
         try {
           const batch = await sources.batch(source)
           unavailableSources.delete(source.id)
@@ -334,9 +382,6 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       }
       await runs.running(true)
       if (!config.channelBackendUrl) await scheduler.tick(owner,runs)
-      for (const [id,child] of background) {
-        if (await scheduler.cancelled(id)) terminateJob(child)
-      }
       for (const run of (await runs.list()).filter(r => r.status === 'queued')) {
         if (shuttingDown) break
         await startJob(run)
@@ -373,6 +418,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     }, 250)
   }
   const drainInbox = (force = false): Promise<void> => {
+    if (!telegramEnabled) return Promise.resolve()
     if (intakeWork) return intakeWork
     intakeWork = (async () => {
       if (shuttingDown) return
@@ -387,7 +433,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             normalizing = entry.update
             replay.add(entry.update)
             try {
-              await bot.handleUpdate(entry.update)
+              await bot!.handleUpdate(entry.update)
             } finally {
               replay.delete(entry.update)
               normalizing = undefined
@@ -396,9 +442,12 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           await withStartLock(async () => {
             if (shuttingDown || !(await inbox.pending(batch.id))) return
             const first = collected[0]
-            if (first)
+            const owner = telegramOwner((await control.status()).owner)
+            if (first && owner)
               run = await runs.create({
                 id: batch.id,
+                ownerId: ownerId(owner), ownerEpoch: ownerEpoch(owner),
+                telegramEpoch: owner.telegramLinkedAt ?? owner.pairedAt,
                 chatId: first.chatId,
                 telegramUserId: first.fromId,
                 messageId: first.messageId,
@@ -442,8 +491,12 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             ? { reply_parameters: { message_id: item.replyToMessageId } }
             : {}
           const owner = (await control.status()).owner
-          const origin = await runs.get(item.runId)
-          if (
+          const authorizeChannelDelivery=async()=>{if(item.deliveryContext)authorizeDeliveryContext(item.deliveryContext,(await control.status()).owner)}
+          const origin = item.runId ? await runs.get(item.runId) : null
+          if (item.deliveryContext) {
+            const context=authorizeDeliveryContext(item.deliveryContext,owner)
+            if(item.runId||item.chatId!==context.owner.telegramChatId||!['message','document','voice'].includes(item.type??''))throw new Error('Outbox delivery context mismatch')
+          } else if (
             !origin ||
             !owner ||
             !ownsRun(owner, origin) ||
@@ -451,35 +504,42 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             item.chatId !== origin.chatId
           )
             throw new Error('Outbox ownership mismatch')
+          if (origin?.application || origin?.delivery) {
+            await applicationChannel.deliver(origin, item)
+            continue
+          }
+          if (!telegramEnabled || item.chatId === undefined) throw new Error('Telegram delivery is disabled')
           const receiptIds: number[] = []
 
           if (item.type === 'reaction' && item.emoji && item.messageId) {
             const emoji = normalizeReactionEmoji(item.emoji)
             if (!emoji) throw new Error('Unsupported reaction')
             attemptedDelivery = true
-            await bot.api.setMessageReaction(item.chatId, item.messageId, [
+            await bot!.api.setMessageReaction(item.chatId, item.messageId, [
               { type: 'emoji', emoji: emoji as any },
             ])
             console.info('run reaction sent', { run_id: item.runId, emoji })
           } else if (item.type === 'document' && item.documentPath) {
-            const docPath = await workspaceFile(origin.scheduled ? await taskWorkspace(config.workspace,origin.id) : config.workspace, item.documentPath)
+            const docPath = await workspaceFile(origin?.scheduled ? await taskWorkspace(config.workspace,origin.id) : config.workspace, item.documentPath)
             await paceSend()
+            await authorizeChannelDelivery()
             attemptedDelivery = true
-            const sent = await bot.api.sendDocument(item.chatId, new InputFile(docPath), {
+            const sent = await bot!.api.sendDocument(item.chatId, new InputFile(docPath), {
               caption: item.text,
               ...replyParams,
             })
             console.info('run document sent', { run_id: item.runId, path: docPath })
             receiptIds.push(sent.message_id)
           } else if (item.type === 'voice' && item.voiceText) {
-            await bot.api.sendChatAction(item.chatId, 'record_voice')
+            await bot!.api.sendChatAction(item.chatId, 'record_voice')
             const { buffer } = await synthesizeSpeech(item.voiceText, {
               geminiApiKey: config.geminiApiKey,
               openaiApiKey: config.openaiApiKey,
             })
             await paceSend()
+            await authorizeChannelDelivery()
             attemptedDelivery = true
-            const sent = await bot.api.sendVoice(item.chatId, new InputFile(buffer, 'voice.ogg'), replyParams)
+            const sent = await bot!.api.sendVoice(item.chatId, new InputFile(buffer, 'voice.ogg'), replyParams)
             receiptIds.push(sent.message_id)
             console.info('run voice sent', { run_id: item.runId })
           } else if (item.type === 'approval' && item.approvalPrompt && item.approvalActionId) {
@@ -489,7 +549,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             const html = `⚠️ <b>Approval Required</b>\n\n${markdownToTelegramHtml(item.approvalPrompt)}`
             await paceSend()
             attemptedDelivery = true
-            const sent = await bot.api.sendMessage(item.chatId, html, {
+            const sent = await bot!.api.sendMessage(item.chatId, html, {
               parse_mode: 'HTML',
               reply_markup: keyboard,
               ...replyParams,
@@ -498,14 +558,14 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             receiptIds.push(sent.message_id)
           } else if (item.text) {
             attemptedDelivery = true
-            const ids = await sendChat(item.chatId, item.text, item.replyToMessageId)
+            const ids = await sendChat(item.chatId, item.text, item.replyToMessageId,authorizeChannelDelivery)
             receiptIds.push(...ids)
             console.info('run message sent', { run_id: item.runId, outbox_id: item.id, message_ids: ids })
           } else throw new Error('Outbox item has no supported payload')
           await runs.markOutboxSent(item.id, receiptIds)
           console.info('run timing', { run_id: item.runId, outbox_id: item.id, phase: 'delivery',
             delivery_processing_ms: Math.round(performance.now() - deliveryStarted),
-            run_to_delivery_ms: Math.max(0, Date.now() - Date.parse(origin.createdAt)) })
+            run_to_delivery_ms: Math.max(0, Date.now() - Date.parse(origin?.createdAt??item.createdAt)) })
         } catch (error) {
           console.error('outbox item processing failed', item.id, safeError(error))
           await runs.failOutbox(
@@ -521,7 +581,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   const checkOwner = async (ctx: Context): Promise<boolean> => {
     if (!ctx.from || ctx.from.is_bot || ctx.message?.sender_chat) return false
     const state = await control.status()
-    if (!state.owner) {
+    if (!telegramOwner(state.owner)) {
       if (ctx.chat?.type !== 'private') return false
       const result = await control.requestPairing(ctx.from.id, ctx.chat.id)
       if (result === 'requested')
@@ -545,8 +605,10 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   ]
   // Keep the retired command from becoming an agent prompt while old clients catch up.
   const retiredCommands = ['/settings']
-  const commands = mainCommands
-  const controlCommand = (text?: string) => text?.trim().replace(/@[a-zA-Z0-9_]+$/, '')
+  const launcher = config.webLauncher
+  const commands = [...mainCommands, ...(launcher ? [{ command: launcher.command, description: launcher.label }] : [])]
+  const controlCommand = (text?: string) => /^\/rename(?:@[a-zA-Z0-9_]+)?(?:\s|$)/.test(text?.trim() ?? '')
+    ? '/rename' : text?.trim().replace(/@[a-zA-Z0-9_]+$/, '')
   const statusKeyboard = () => new InlineKeyboard()
     .text('Stop active work', 'menu:stop').text('Cancel queue', 'menu:cancel').row()
     .text('Retry failed incoming message', 'menu:retry').row()
@@ -619,11 +681,12 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
 
   // Returning from the polling handler acknowledges intake, not execution. Only
   // return after the authorized update has reached the atomic local journal.
+  if (bot) {
   bot.use(async (ctx, next) => {
     if (ctx.callbackQuery && (await control.status()).owner?.kind === 'group') {
       if (!isOwner(ctx, (await control.status()).owner)) return
       try {
-        const member = await bot.api.getChatMember(ctx.chat!.id, ctx.from!.id)
+        const member = await bot!.api.getChatMember(ctx.chat!.id, ctx.from!.id)
         if (!['creator', 'administrator', 'member'].includes(member.status) &&
           !(member.status === 'restricted' && member.is_member)) return
       } catch { throw new Error('Group membership verification unavailable; retry the update') }
@@ -631,15 +694,15 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     if ((ctx.chat?.type === 'group' || ctx.chat?.type === 'supergroup') &&
       !isOwner(ctx, (await control.status()).owner)) {
       if (config.channelBackendUrl) return
-      const owner = (await control.status()).owner
+      const owner = telegramOwner((await control.status()).owner)
       const message = ctx.message
       if (!owner && message && !message.sender_chat && ctx.from && !ctx.from.is_bot) {
         await control.requestPairing(ctx.from.id, ctx.chat.id, ctx.chat.title)
         return
       }
       if (!owner || !message?.text || message.sender_chat || !ctx.from || ctx.from.is_bot) return
-      await telegramSource.start(owner)
-      if (await telegramSource.capture(ctx.update.update_id, message as import('grammy/types').Message.TextMessage, ctx.from)) return
+      await telegramSource!.start(owner)
+      if (await telegramSource!.capture(ctx.update.update_id, message as import('grammy/types').Message.TextMessage, ctx.from)) return
       if (owner.kind === 'group') return
       if (ctx.from.id !== owner.telegramUserId) return
       if (replay.has(ctx.update)) {
@@ -647,7 +710,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           updateId: ctx.update.update_id, chatId: owner.telegramChatId, fromId: owner.telegramUserId,
           text: JSON.stringify({event:'owner_message_in_unbound_group',chatId:ctx.chat.id,title:ctx.chat.title,messageId:message.message_id,text:message.text}),
         })
-      } else if (await inbox.accept(ctx.update, await control.captureChoice(aiMenu.initial))) scheduleIntake()
+      } else if (await inbox.accept(ctx.update, await control.captureChoice(aiMenu.initial, message?.text || message?.caption))) scheduleIntake()
       return
     }
     if (replay.has(ctx.update)) {
@@ -661,19 +724,36 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     const approval = ctx.callbackQuery?.data?.startsWith('approval:')
     if (!ordinary && !approval) return next()
     if (!(await checkOwner(ctx))) return
-    if (await inbox.accept(ctx.update, await control.captureChoice(aiMenu.initial))) scheduleIntake()
+    if (await inbox.accept(ctx.update, await control.captureChoice(aiMenu.initial, message?.text || message?.caption))) scheduleIntake()
   })
 
-  bot.on('message:text', async (ctx) => {
+  bot!.on('message:text', async (ctx) => {
     if (!(await checkOwner(ctx))) return
 
     const text = controlCommand(ctx.message.text)
 
-    if (config.channelBackendUrl && ['/new', '/ai', '/settings'].includes(text ?? '')) {
+    if (config.channelBackendUrl && ['/new', '/chats', '/rename', '/ai', '/settings'].includes(text ?? '')) {
       await ctx.reply('Conversation and model settings are managed in the connected application.')
       return
     }
 
+    if (launcher && text === `/${launcher.command}`) {
+      if (ctx.chat.type !== 'private' || (await control.status()).owner?.kind === 'group') return
+      await ctx.reply(launcher.label, { reply_markup: new InlineKeyboard().webApp(launcher.label, launcher.url) })
+      return
+    }
+
+    if (text === '/chats') {
+      await conversationMenu.list(ctx)
+      return
+    }
+    if (text === '/rename') {
+      try {
+        await control.renameSession(ctx.message.text.trim().replace(/^\/rename(?:@[a-zA-Z0-9_]+)?(?:\s+|$)/, ''))
+        await ctx.reply('Conversation renamed.')
+      } catch (error) { await ctx.reply(error instanceof Error ? error.message : 'Rename failed.') }
+      return
+    }
     if (text === '/ai') {
       await aiMenu.list(ctx)
       return
@@ -741,6 +821,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
 
     if (text === '/menu') {
       const menuKeyboard = mainKeyboard()
+      if (launcher && ctx.chat.type === 'private' && (await control.status()).owner?.kind !== 'group') menuKeyboard.row().webApp(launcher.label, launcher.url)
       await ctx.reply('⚡ <b>Ezenciel Agent Menu</b>\nSelect an action below:', {
         parse_mode: 'HTML',
         reply_markup: menuKeyboard,
@@ -768,7 +849,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     })
   })
 
-  bot.on('message:photo', async (ctx) => {
+  bot!.on('message:photo', async (ctx) => {
     if (!(await checkOwner(ctx))) return
     try {
       const photos = ctx.message.photo
@@ -798,7 +879,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     }
   })
 
-  bot.on('message:document', async (ctx) => {
+  bot!.on('message:document', async (ctx) => {
     if (!(await checkOwner(ctx))) return
     try {
       const doc = ctx.message.document
@@ -829,10 +910,10 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     }
   })
 
-  bot.on('message:voice', async (ctx) => {
+  bot!.on('message:voice', async (ctx) => {
     if (!(await checkOwner(ctx))) return
     try {
-      await bot.api.sendChatAction(ctx.chat.id, 'typing').catch(() => {})
+      await bot!.api.sendChatAction(ctx.chat.id, 'typing').catch(() => {})
       const voice = ctx.message.voice
       const fileInfo = await ctx.api.getFile(voice.file_id)
       if (!fileInfo.file_path) throw new Error('Telegram attachment path unavailable')
@@ -861,7 +942,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     }
   })
 
-  bot.on('callback_query:data', async (ctx) => {
+  bot!.on('callback_query:data', async (ctx) => {
     if (!isOwner(ctx, (await control.status()).owner)) {
       await ctx.answerCallbackQuery()
       return
@@ -898,19 +979,24 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           text: JSON.stringify({ event: 'approval_decision', actionId, decision, prompt: request?.prompt }),
           messageId: ctx.callbackQuery.message?.message_id,
           updateId: ctx.update.update_id,
-          chatId: run.chatId,
+          chatId: run.chatId!,
           fromId: ctx.from.id,
         })
         console.info('Approval decision recorded', { actionId, decision: isApproved ? 'approved' : 'denied' })
       }
-    } else if (config.channelBackendUrl && (['menu:new', 'menu:ai', 'menu:settings'].includes(data) || data.startsWith('ai:'))) {
+    } else if (config.channelBackendUrl && (['menu:new', 'menu:chats', 'menu:ai', 'menu:settings'].includes(data) || data.startsWith('ai:') || data.startsWith('chat:'))) {
       await ctx.answerCallbackQuery()
       await ctx.reply('Conversation and model settings are managed in the connected application.')
+    } else if (await conversationMenu.handle(ctx)) {
+      return
     } else if (await aiMenu.handle(ctx)) {
       return
     } else if (data.startsWith('menu:')) {
       const action = data.slice(5)
-      if (action === 'ai') {
+      if (action === 'chats') {
+        await ctx.answerCallbackQuery()
+        await conversationMenu.list(ctx)
+      } else if (action === 'ai') {
         await ctx.answerCallbackQuery()
         await aiMenu.list(ctx)
       } else if (action === 'settings') {
@@ -958,16 +1044,19 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     }
   })
 
-  bot.catch((error) => {
+  bot!.catch((error) => {
     console.error('Telegram update failure', safeError(error.error))
     // Do not let polling acknowledge an update whose journal write failed.
     throw error
   })
+  }
 
   let stopWork: Promise<void> | undefined
   const stop = (): Promise<void> => stopWork ?? (stopWork = (async () => {
     shuttingDown = true
+    runtimeStarted = false
     pollingAbort.abort()
+    await applicationChannel.stop()
     wakePollRetry?.()
     if (intakeTimer) clearTimeout(intakeTimer)
     if (sourceTimer) clearInterval(sourceTimer)
@@ -984,9 +1073,9 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     await Promise.all([taskWork, outboxWork].map(work => work?.catch(() => {})))
     pagerDuty?.stop()
     try {
-      if (bot.isRunning()) await bot.stop()
+      if (bot?.isRunning()) await bot.stop()
     } finally {
-      await telegramSource.stop()
+      await telegramSource?.stop()
     }
   })())
 
@@ -994,9 +1083,11 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     let failed = false
     try {
       await initializeWorkspace(config.workspace)
+      if (config.applicationPort) await applicationChannel.listen(config.applicationPort, config.applicationHost)
+      runtimeStarted = true
       pagerDuty?.start()
       const owner = (await control.status()).owner
-      if (owner && !config.channelBackendUrl) await telegramSource.start(owner)
+      if (telegramEnabled && telegramOwner(owner) && !config.channelBackendUrl) await telegramSource!.start(owner!)
       await scheduler.recover(runs)
       sourceTimer = setInterval(() => {
         void drainSources().catch(error => console.error('Event-source drain failed', safeError(error)))
@@ -1024,18 +1115,22 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         }
       }
 
+      if (!telegramEnabled) {
+        await new Promise<void>(resolve => { wakePollRetry = resolve; if (shuttingDown) resolve() })
+        return
+      }
       scheduleIntake()
       // Telegram polling is a delivery surface, not the scheduler or executor.
       // grammY owns in-poll reconnects. Escaped permanent faults wait for
       // intervention without restarting setup or terminating authorized work.
       while (!shuttingDown) {
         try {
-          await bot.api.setMyCommands(commands)
-          await bot.api.setMyCommands(commands, { scope: { type: 'all_private_chats' } })
+          await bot!.api.setMyCommands(commands)
+          await bot!.api.setMyCommands(commands, { scope: { type: 'all_private_chats' } })
           // grammY types its Node signal with the older abort-controller shim.
-          await bot.init(pollingAbort.signal as unknown as Parameters<typeof bot.init>[0])
+          await bot!.init(pollingAbort.signal as unknown as Parameters<typeof Bot.prototype.init>[0])
           if (shuttingDown) break
-          await bot.start({
+          await bot!.start({
             drop_pending_updates: false,
             onStart: (botInfo) => console.log(`✓ Bot @${botInfo.username} polling for messages...`),
           })
@@ -1067,7 +1162,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       }
     }
   }
-  return { bot, start, stop, drainOutbox, drainInbox, drainSources, drainTaskRequests }
+  return { bot: bot!, isRunning: () => telegramEnabled ? Boolean(bot?.isRunning()) : runtimeStarted, start, stop, drainOutbox, drainInbox, drainSources, drainTaskRequests, applicationChannel }
 }
 
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {