@jc_stack/ez-agents 0.1.0-beta.34 → 0.1.0-beta.36

package/src/host-executor.ts

@@ -1,8 +1,8 @@
-import { installAgentGuidance } from './agent-guidance.js'
 import { redactFailure } from './failure.js'
-import { RunStore } from './runs.js'
 import { Tasks } from './tasks.js'
-import { requireOwnerExecution } from './execution-authority.js'
+import { ControlStore } from './control-state.js'
+import { authorizeRun, readRun } from './delivery-socket.js'
+import { runPromptSuffix } from './prompt-suffix.js'
 import { mkdir, readFile, writeFile, readdir, rename, rm, appendFile, realpath } from 'node:fs/promises'
 import path from 'node:path'
 import { isHostRunId } from './host-executor-protocol.js'
@@ -37,8 +37,14 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
   const catalog = async (agent: HostBinding) => {
     const discovered = await readModels(undefined, undefined, path.join(agent.controlDir, 'cli', 'codex'))
     const providers = (agent.codexProviders ?? []).map(validateCodexProvider)
-    const declared = providers.flatMap(provider => provider.models.map(model => ({cli:'codex',provider:provider.id,model,name:`${provider.name} · ${model}`.slice(0,80),efforts:[]})))
-    return [...discovered, ...declared]
+    const declared = providers.flatMap(provider => provider.models.map(model => {
+      const native = discovered.find(candidate => candidate.cli === 'codex' && !candidate.provider && candidate.model === model)
+      return {cli:'codex',provider:provider.id,model,name:`${provider.name} · ${model}`.slice(0,80),efforts:native?.efforts ?? []}
+    }))
+    const declaredModels = new Set(declared.map(model => model.model))
+    const isReplacedByProvider = (model: {cli:string; model?:string}) =>
+      model.model !== undefined && declaredModels.has(model.model) && model.cli === 'codex'
+    return [...discovered.filter(model => !isReplacedByProvider(model)), ...declared]
   }
   try {
     for (const agent of installation.agents) {
@@ -71,8 +77,10 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
       catch(error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }
       await writeFile(lock,JSON.stringify({pid:process.pid,started:await processStart(process.pid)}),{mode:0o600,flag:'wx'})
       locks.push(lock)
-      await installAgentGuidance(agent.workspace)
-      await writeFile(path.join(directory,'models.json'),JSON.stringify(await catalog(agent)),{mode:0o600})
+      const models = await catalog(agent)
+      await new ControlStore(agent.controlDir, 900000).normalizeProviderBindings(models)
+      const modelsFile=path.join(directory,'models.json')
+      await writeFile(modelsFile+'.tmp',JSON.stringify(models),{mode:0o600});await rename(modelsFile+'.tmp',modelsFile)
       // A host crash is terminal for a claimed job. Never replay an action.
       for (const file of await readdir(directory)) if (file.endsWith('.running.json')) {
         const base=path.join(directory,file.slice(0,-13))
@@ -88,27 +96,32 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
       if (agent.toolsHome) await (await import('./plugins/workspace-lease.mjs')).recoverNativeLease(agent.toolsHome)
     }
     let catalogAt=Date.now()
+    const catalogSeen=new Map<HostBinding,string>()
     while (!signal.aborted) {
       const parent=Number(process.env.EZ_HOST_SUPERVISOR_PID)
       if(parent) { try { process.kill(parent,0) } catch { break } }
       if(Date.now()-catalogAt>30000){
         for(const agent of installation.agents){
-          const models=JSON.stringify(await catalog(agent))
+          const catalogModels = await catalog(agent)
+          const models=JSON.stringify(catalogModels)
+          if(catalogSeen.get(agent)===models)continue
+          await new ControlStore(agent.controlDir, 900000).normalizeProviderBindings(catalogModels)
           const file=path.join(agent.controlDir,'host-executor/models.json')
           await writeFile(file+'.tmp',models,{mode:0o600});await rename(file+'.tmp',file)
+          catalogSeen.set(agent,models)
         }
         catalogAt=Date.now()
       }
       for (const agent of installation.agents) {
         const directory=path.join(agent.controlDir,'host-executor')
-        await writeFile(path.join(directory,'heartbeat.tmp'),JSON.stringify({at:Date.now(),pid:process.pid,version:packageVersion,plugins:await installedPluginVersions(agent.toolsHome)}),{mode:0o600})
+        await writeFile(path.join(directory,'heartbeat.tmp'),JSON.stringify({at:Date.now(),pid:process.pid,version:packageVersion,platform:process.platform,arch:process.arch,plugins:await installedPluginVersions(agent.toolsHome)}),{mode:0o600})
         await rename(path.join(directory,'heartbeat.tmp'),path.join(directory,'heartbeat.json'))
         for (const file of await readdir(directory)) {
           if (!file.endsWith('.request.json') || !isHostRunId(file.slice(0,-13))) continue
           const id=file.slice(0,-13)
           let run
           try {
-            run = await new RunStore(agent.controlDir).get(id)
+            run = await readRun(agent.controlDir, id)
             if(id.startsWith('r_schedule_') && !run?.scheduled) throw new Error('Missing scheduled run')
           } catch {
             await appendFile(path.join(directory,id+'.events'),JSON.stringify({stream:'exit',code:1})+'\n',{mode:0o600})
@@ -131,11 +144,11 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               try { await readFile(base+'.cancel'); throw new Error('Cancelled') } catch(error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }
               const request=JSON.parse(await readFile(base+'.running.json','utf8'))
               if (!Array.isArray(request.texts) || request.texts.some((text:unknown)=>typeof text!=='string')) throw new Error('Invalid job')
-              const run = await new RunStore(agent.controlDir).get(path.basename(base))
+              const run = await readRun(agent.controlDir, path.basename(base))
               if (run?.taskId) {
                 if (run.status !== 'running') throw new Error('No active task run')
                 await new Tasks(agent.controlDir).authorize(run, false)
-              } else await requireOwnerExecution(agent.controlDir, path.basename(base))
+              } else await authorizeRun(agent.controlDir, path.basename(base))
               const opts=request.options as ExecutorOptions
               const cli = opts.cli || installation.cli
               resolveExecutor(cli)
@@ -149,9 +162,10 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               if (!provider && model && (agent.codexProviders ?? []).some(binding=>binding.models.includes(model)))
                 throw new Error('Selected Codex provider is required for this model')
               if (cli !== installation.cli) await validateSelection({id:'selected',name:'Selected model',cli,provider:opts.provider,model,effort:opts.effort},await catalog(agent))
-              const options:ExecutorOptions={workspace:run?.scheduled ? await taskWorkspace(agent.workspace,id) : agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,sharedWorkspace,additionalWorkspaces:additionalWorkspaces.get(agent),cli,
+              const options:ExecutorOptions={workspace:run?.scheduled ? await taskWorkspace(agent.controlDir,id) : agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,sharedWorkspace,additionalWorkspaces:additionalWorkspaces.get(agent),cli,
                 runId:path.basename(base),timeoutMs:0,repairEnabled:opts.repairEnabled,
-                sessionId:opts.sessionId,isResume:opts.isResume,eventSource:opts.eventSource,model,effort:opts.effort,provider:opts.provider,codexAutoCompactTokens:opts.codexAutoCompactTokens,codexProvider:provider}
+                sessionId:opts.sessionId,isResume:opts.isResume,model,effort:opts.effort,provider:opts.provider,codexAutoCompactTokens:opts.codexAutoCompactTokens,codexProvider:provider,
+                promptSuffix:runPromptSuffix(run),taskRun:Boolean(run?.taskId),nativeSession:Boolean(run?.scheduled)}
               job=await launch(request.texts,options)
               active.set(base,job.child)
               await writeFile(base+'.process.json',JSON.stringify({pid:job.child.pid}),{mode:0o600})

package/src/inbox.ts

@@ -1,5 +1,3 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
 import type { Update } from 'grammy/types'
 import { isExecutionChoice, type ExecutionChoice } from './ai.js'
 import { isOwner } from './identity.js'
@@ -21,58 +19,26 @@ type Entry = { update: Update; receivedAt: number; execution?: ExecutionChoice }
 export type InboxBatch = { id: string; entries: Entry[]; status: 'pending' | 'failed' | 'cancelled' }
 type State = { version: 1; seen: number[]; waiting: Entry[]; batches: InboxBatch[] }
 
-// One relay writer. Serialize read/modify/rename, including commands arriving during STT.
+// Stateless pipe: process memory only. Intake dedup lives in the relay that
+// polls Telegram, so no other process reads this journal. A restart drops
+// unprocessed updates by design; Telegram redelivery is the replay mechanism.
+const statesByDirectory = new Map<string, State>()
+
+const stateFor = (directory: string): State => {
+  let state = statesByDirectory.get(directory)
+  if (!state) { state = { version: 1, seen: [], waiting: [], batches: [] }; statesByDirectory.set(directory, state) }
+  return state
+}
+
 export class InboxStore {
   private lock: Promise<unknown> = Promise.resolve()
-  private readonly file: string
   constructor(
     private readonly directory: string,
     private readonly now = Date.now,
-  ) {
-    this.file = join(directory, 'inbox.json')
-  }
-
-  private async read(): Promise<State> {
-    try {
-      const state = JSON.parse(await readFile(this.file, 'utf8')) as State
-      const entry = (e: Entry) =>
-        e && Number.isSafeInteger(e.update?.update_id) && Number.isFinite(e.receivedAt) &&
-        (e.execution === undefined || isExecutionChoice(e.execution))
-      if (
-        state.version !== 1 ||
-        !Array.isArray(state.seen) ||
-        !state.seen.every(Number.isSafeInteger) ||
-        !Array.isArray(state.waiting) ||
-        !state.waiting.every(entry) ||
-        !Array.isArray(state.batches) ||
-        !state.batches.every(
-          (b) =>
-            /^tg_\d+$/.test(b.id) &&
-            ['pending', 'failed', 'cancelled'].includes(b.status) &&
-            Array.isArray(b.entries) &&
-            b.entries.length > 0 &&
-            b.entries.every(entry),
-        )
-      )
-        throw new Error('Invalid inbox shape')
-      return state
-    } catch (error) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT')
-        return { version: 1, seen: [], waiting: [], batches: [] }
-      throw new Error('Inbox unreadable; restore the local journal before accepting messages')
-    }
-  }
+  ) {}
 
   private change<T>(work: (state: State) => T): Promise<T> {
-    const next = this.lock.then(async () => {
-      const state = await this.read()
-      const result = work(state)
-      await mkdir(this.directory, { recursive: true, mode: 0o700 })
-      const temporary = `${this.file}.${process.pid}.tmp`
-      await writeFile(temporary, JSON.stringify(state), { mode: 0o600 })
-      await rename(temporary, this.file)
-      return result
-    })
+    const next = this.lock.then(async () => work(stateFor(this.directory)))
     this.lock = next.catch(() => {})
     return next
   }
@@ -163,12 +129,12 @@ export class InboxStore {
 
   async pending(id: string): Promise<boolean> {
     await this.lock
-    return (await this.read()).batches.some((b) => b.id === id && b.status === 'pending')
+    return stateFor(this.directory).batches.some((b) => b.id === id && b.status === 'pending')
   }
 
   async status(): Promise<{ pending: number; failed: number }> {
     await this.lock
-    const state = await this.read()
+    const state = stateFor(this.directory)
     return {
       pending:
         state.waiting.length +

package/src/index.ts

@@ -4,14 +4,15 @@ import { TelegramSource } from './telegram-source.js'
 import { Tasks } from './tasks.js'
 import { taskRequests } from './task-rpc.js'
 import { executionBlockReason } from './execution-authority.js'
+import { serveDeliverySocket, createLedgerHandler, deliverySocketAlive, deliverySocketPath } from './delivery-socket.js'
+import { packageVersion } from './version.js'
 import {authorizeDeliveryContext} from './delivery-context.mjs'
 import { dispatchChannel } from './channel-backend.js'
 import { randomUUID } from 'node:crypto'
 import { stat } from 'node:fs/promises'
 import { Scheduler } from './scheduler.js'
-import { scheduledTasksText } from './scheduled-tasks.js'
+import { ownedScheduledTasks, scheduledTaskDetailText, scheduledTasksText } from './scheduled-tasks.js'
 import { taskWorkspace } from './task-workspace.js'
-import { queueUpdateAttention } from './update-attention.js'
 import { EventSources, eventRunId, batchReady, type SourceEvent } from './event-sources.js'
 import {removeTaskAttachments} from './task-attachments.js'
 import { dirname, join, basename } from 'node:path'
@@ -37,14 +38,13 @@ 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'
-import { initializeWorkspace } from './workspace.js'
+import { runPromptSuffix } from './prompt-suffix.js'
 import { softwareStatus } from './software-status.js'
-import { PagerDutyStocksMonitor } from './pagerduty.js'
 
 export const createRelay = (config: Config, launch = startExecutorJob) => {
   const safeError = (error: unknown): string => {
     let message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown error'
-    for (const secret of [config.channelBackendToken, config.telegramBotToken, config.geminiApiKey, config.openaiApiKey, config.pagerDutyRoutingKey]) {
+    for (const secret of [config.channelBackendToken, config.telegramBotToken, config.geminiApiKey, config.openaiApiKey]) {
       if (secret) message = message.replaceAll(secret, '[redacted]')
     }
     return message
@@ -70,19 +70,10 @@ 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 conversationMenu = createConversationMenu(control)
   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')
-  const pagerDuty = config.pagerDutyRoutingKey && config.pagerDutyStocksHealthUrl
-    ? new PagerDutyStocksMonitor({
-      routingKey: config.pagerDutyRoutingKey,
-      healthUrl: config.pagerDutyStocksHealthUrl,
-      pollMs: config.pagerDutyPollMs!,
-      failureThreshold: config.pagerDutyFailureThreshold!,
-      onError: (error) => console.error('PagerDuty Stocks health check failed', safeError(error)),
-    })
-    : undefined
 
   let activeTypingTimer: ReturnType<typeof setInterval> | null = null
   let activeBackend = false
@@ -112,6 +103,19 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     controlDir: config.controlDir, workspace: config.workspace, initial: aiMenu.initial,
     aiControls: aiMenu,
     wake: () => { void drainSources().catch(error => console.error('Application queue unavailable', safeError(error))) },
+    createTelegramPairing: async (bindingId, owner) => {
+      const username = bot?.botInfo?.username
+      if (!username || !/^[A-Za-z][A-Za-z0-9_]{4,31}$/.test(username))
+        throw new Error('Telegram connection is unavailable')
+      const pairing = await control.createApplicationTelegramPairing(bindingId, owner)
+      if (!pairing) return { connected: true } as const
+      return {
+        connected: false as const,
+        url: `https://t.me/${username}?start=${pairing.token}`,
+        expiresAt: pairing.expiresAt,
+      }
+    },
+    telegramAvailable: () => Boolean(bot?.botInfo?.username),
     cancel: id => withStartLock(async () => {
       const run = await runs.get(id)
       if (run?.status === 'queued') await runs.patch(id, {status:'cancelled',endedAt:new Date().toISOString()})
@@ -176,7 +180,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         catch { await runs.patch(run.id, { status: 'cancelled', endedAt: new Date().toISOString() }); await releaseExternal(run); return }
       }
       if (config.channelBackendUrl) {
-        if (run.external || run.taskId || run.scheduled || run.id.startsWith('r_update_')) { await runs.patch(run.id, { status: 'failed' }); await releaseExternal(run); return }
+        if (run.external || run.taskId || run.scheduled) { await runs.patch(run.id, { status: 'failed' }); await releaseExternal(run); return }
         activeBackend = true
         await runs.patch(run.id, { status: 'running', backendSubmitted: true })
         void dispatchChannel(config, run).then(async reply => {
@@ -224,14 +228,13 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         const launchStarted = performance.now()
         const started = await runs.patch(run.id, { status: 'running', startedAt: new Date().toISOString() })
         if (!started.execution && !run.taskId) throw new Error('Legacy queued work has no pinned AI. Resend the request after /new.')
-        const maintenanceWakeup = run.id.startsWith('r_update_')
-        const startsOwnSession = Boolean(run.external || run.taskId || run.scheduled || maintenanceWakeup)
+        const startsOwnSession = Boolean(run.external || run.taskId || run.scheduled)
         const session = startsOwnSession
           ? { sessionId: randomUUID(), hasStarted: false, nativeSessionId: undefined }
           : await control.executionSession(started.execution!)
         const selected = run.taskId ? (started.execution?.preset.cli === 'codex' ? started.execution.preset : initialPreset('codex')) : started.execution!.preset
         const { child, cleanup } = await launch(texts, {
-          workspace: run.scheduled ? await taskWorkspace(config.workspace,run.id) : config.workspace,
+          workspace: run.scheduled ? await taskWorkspace(config.controlDir,run.id) : config.workspace,
           timeoutMs: config.executorTimeoutMs,
           repairEnabled: config.repairEnabled,
           runId: started.id,
@@ -245,8 +248,10 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           codexSandbox: !run.taskId && selected.cli === 'codex' ? config.codexSandbox : undefined,
           sessionId: session.nativeSessionId || session.sessionId,
           isResume: session.hasStarted,
-          eventSource: run.external?.sourceId,
-          onSession: run.external || run.taskId || maintenanceWakeup ? undefined : async (id) => { await runs.patch(run.id,{nativeSessionId:id}); if (!run.scheduled) await control.saveNativeSession(session.sessionId,id) },
+          promptSuffix: runPromptSuffix(started),
+          taskRun: Boolean(run.taskId),
+          nativeSession: Boolean(run.scheduled),
+          onSession: run.external || run.taskId ? undefined : async (id) => { await runs.patch(run.id,{nativeSessionId:id}); if (!run.scheduled) await control.saveNativeSession(session.sessionId,id) },
         })
         const executionStarted = performance.now()
         // Attach before disk writes: a fast child can close while PID persistence
@@ -385,7 +390,6 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       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. */ }
       }
-      if (telegramOwner(owner)) await queueUpdateAttention(config.controlDir,owner,runs,await durableWorkerChoice())
       }
       for (const source of config.channelBackendUrl ? [] : await sources.available(owner)) {
         try {
@@ -449,10 +453,6 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     if (message?.media_group_id) item.text = `[Telegram album: ${message.media_group_id}]\n${item.text}`
     if (message && (message.chat.type === 'group' || message.chat.type === 'supergroup'))
       item.text = `[Telegram sender ${message.from?.id}, name ${JSON.stringify(message.from?.first_name)}]\n${item.text}`
-    if (message && !message.text && message.reply_to_message) {
-      const quoted = message.reply_to_message
-      item.text = `[Quoted message ${quoted.message_id}]: ${quoted.text || quoted.caption || '[media]'}\n\n${item.text}`
-    }
     collected.push(item)
   }
   const scheduleIntake = () => {
@@ -565,7 +565,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             ])
             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.controlDir,origin.id) : config.workspace, item.documentPath)
             await paceSend()
             await authorizeChannelDelivery()
             attemptedDelivery = true
@@ -623,11 +623,34 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     })().finally(() => { outboxWork = undefined }))
   }
 
+  // Delivery socket: cross-process producers (engine children, plugin
+  // children, host executor, CLIs) enqueue and query the memory ledger
+  // through the shared handler in delivery-socket.ts. The pump below stays
+  // the single delivery executor; the socket only admits work into it.
+  let deliveryServer: { socketPath: string; stop: () => Promise<void> } | null = null
+  const handleDeliveryOp = createLedgerHandler(config.controlDir, {
+    wake: () => { void drainOutbox() },
+    status: () => ({
+      polling: Boolean(bot?.isRunning()),
+      applicationOnly: !telegramEnabled,
+      telegramConfigured: config.telegramBotToken !== '',
+      version: packageVersion,
+    }),
+  })
+
   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 (!telegramOwner(state.owner)) {
       if (ctx.chat?.type !== 'private') return false
+      const applicationToken = ctx.message?.text?.trim().match(/^\/start(?:@[A-Za-z0-9_]+)?\s+([A-Za-z0-9_-]{43})$/)?.[1]
+      if (applicationToken) {
+        const linked = await applicationChannel.claimTelegramConnection(applicationToken, ctx.from.id, ctx.chat.id)
+        await ctx.reply(linked
+          ? 'Telegram is connected to your Ez agent. You can keep chatting here.'
+          : 'This Telegram connection link expired or is no longer valid. Create a new one in the connected application.', { link_preview_options: { is_disabled: true } })
+        return false
+      }
       const result = await control.requestPairing(ctx.from.id, ctx.chat.id)
       if (result === 'requested')
         await ctx.reply('Owner approval is pending. Confirm this request through the local setup assistant.')
@@ -654,18 +677,29 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   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 tasksCommand = (text?: string): number | undefined | null => {
+    const match = text?.trim().match(/^\/tasks(?:@[a-zA-Z0-9_]+)?(?:\s+([1-9]\d*))?$/)
+    return match ? (match[1] ? Number(match[1]) : undefined) : null
+  }
+  const isTasksCommand = (text?: string): boolean => /^\/tasks(?:@[a-zA-Z0-9_]+)?(?:\s|$)/.test(text?.trim() ?? '')
   const statusKeyboard = () => new InlineKeyboard()
     .text('Stop active work', 'menu:stop').text('Cancel queue', 'menu:cancel').row()
-    .text('Retry failed incoming message', 'menu:retry').row()
-    .text('Scheduled tasks', 'menu:scheduled-tasks')
+    .text('Retry failed incoming message', 'menu:retry')
   const scheduledTasks = async () => {
     const owner = (await control.status()).owner
     if (!owner) return 'Scheduled tasks\n\nNo paired owner.'
     // This intentionally uses the reader that does not create a schedules directory.
-    return scheduledTasksText(await scheduler.listActiveReadOnly(await runs.list()), owner)
+    const active = await scheduler.listActiveReadOnly(await runs.list())
+    return { owner, active, text: scheduledTasksText(active, owner) }
   }
-  const replyScheduledTasks = async (ctx: Context) => {
-    for (const part of splitTelegramText(await scheduledTasks())) await ctx.reply(part)
+  const replyScheduledTasks = async (ctx: Context, number?: number) => {
+    const result = await scheduledTasks()
+    const text = typeof result === 'string' ? result : number === undefined ? result.text : (() => {
+      const owned = ownedScheduledTasks(result.active, result.owner)
+      const schedule = owned[number - 1]
+      return schedule ? scheduledTaskDetailText(schedule, number, owned.length) : `Scheduled task ${number} was not found. Use /tasks to list active tasks.`
+    })()
+    for (const part of splitTelegramText(text)) await ctx.reply(part)
   }
   const statusText = async () => {
     const running = await runs.running(false)
@@ -694,7 +728,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       '🟢 Ez is online',
       '',
       'System',
-      ...await softwareStatus(config.controlDir),
+      ...await softwareStatus(config.controlDir, config.isolation),
       `AI: ${selected.name} (${presetLabel(displayedSelected)})`,
       '',
       'Work',
@@ -771,7 +805,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     }
     const message = ctx.message
     const command = controlCommand(message?.text)
-    if (command && [...commands, ...aliases].map((c) => `/${c.command}`).concat('/menu', ...retiredCommands).includes(command)) return next()
+    if ((command && [...commands, ...aliases].map((c) => `/${c.command}`).concat('/menu', ...retiredCommands).includes(command)) || tasksCommand(message?.text) !== null || isTasksCommand(message?.text)) return next()
     const ordinary = message && (message.text || message.photo || message.document || message.voice)
     const approval = ctx.callbackQuery?.data?.startsWith('approval:')
     if (!ordinary && !approval) return next()
@@ -815,6 +849,16 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       return
     }
 
+    const taskNumber = tasksCommand(ctx.message.text)
+    if (taskNumber !== null) {
+      await replyScheduledTasks(ctx, taskNumber)
+      return
+    }
+    if (isTasksCommand(ctx.message.text)) {
+      await ctx.reply('Usage: /tasks [number]. Use /tasks to list active tasks.')
+      return
+    }
+
     if (text === '/help') {
       await ctx.reply([...commands, ...aliases.filter((a) => !commands.some((c) => c.command === a.command))]
         .map((c) => `/${c.command} — ${c.description}`).join('\n'))
@@ -881,19 +925,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       return
     }
 
-    // Quoted reply context forwarding
-    let promptText = ctx.message.text
-    if (ctx.message.reply_to_message) {
-      const quoted = ctx.message.reply_to_message
-      const quotedText = ('text' in quoted && quoted.text) || ('caption' in quoted && quoted.caption) || ''
-      const quotedSender = quoted.from?.is_bot ? 'Agent' : 'Owner'
-      if (quotedText) {
-        promptText = `[Quoted message from ${quotedSender} (ID: ${quoted.message_id})]: "${quotedText}"\n\n${promptText}`
-      }
-    }
-
     collectItem({
-      text: promptText,
+      text: ctx.message.text,
       messageId: ctx.message.message_id,
       updateId: ctx.update.update_id,
       chatId: ctx.chat.id,
@@ -911,7 +944,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       const fileUrl = `https://api.telegram.org/file/bot${config.telegramBotToken}/${fileInfo.file_path}`
       const buffer = await downloadTelegramFile(fileUrl)
       const fileName = sanitizeFileName(basename(fileInfo.file_path) || 'photo.jpg')
-      const staged = await stageChatAttachment(config.workspace, fileName, buffer, ctx.message.caption ?? '')
+      const staged = await stageChatAttachment(config.controlDir, fileName, buffer, ctx.message.caption ?? '')
       collectItem({
         text: staged.text,
         attachment: staged.attachment,
@@ -938,7 +971,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       const fileUrl = `https://api.telegram.org/file/bot${config.telegramBotToken}/${fileInfo.file_path}`
       const buffer = await downloadTelegramFile(fileUrl)
       const fileName = sanitizeFileName(doc.file_name || basename(fileInfo.file_path) || 'document.bin')
-      const staged = await stageChatAttachment(config.workspace, fileName, buffer, ctx.message.caption ?? '')
+      const staged = await stageChatAttachment(config.controlDir, fileName, buffer, ctx.message.caption ?? '')
       collectItem({
         text: staged.text,
         attachment: staged.attachment,
@@ -1104,6 +1137,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     shuttingDown = true
     runtimeStarted = false
     pollingAbort.abort()
+    await deliveryServer?.stop().catch(() => {})
+    deliveryServer = null
     await applicationChannel.stop()
     wakePollRetry?.()
     if (intakeTimer) clearTimeout(intakeTimer)
@@ -1119,7 +1154,6 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     })
     await Promise.all(completions)
     await Promise.all([taskWork, outboxWork].map(work => work?.catch(() => {})))
-    pagerDuty?.stop()
     try {
       if (bot?.isRunning()) await bot.stop()
     } finally {
@@ -1130,10 +1164,19 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   const start = async () => {
     let failed = false
     try {
-      await initializeWorkspace(config.workspace)
+      // Workspace seeding and managed-block replacement happen at install or
+      // upgrade only; relay startup never writes the agent workspace.
+      // The delivery socket is the cross-process ledger transport and the
+      // single-relay guard (replacing relay.lock): a live sibling answers the
+      // ping and this relay refuses to split-brain the agent.
+      if (await deliverySocketAlive(deliverySocketPath(config.controlDir)).catch(() => false))
+        throw new Error(`Another relay owns ${config.controlDir}; stop it before starting a second one`)
+      const deliveryTcpPort = Number(process.env.EZ_DELIVERY_TCP_PORT ?? '')
+      deliveryServer = await serveDeliverySocket(config.controlDir, handleDeliveryOp, {
+        ...(Number.isSafeInteger(deliveryTcpPort) && deliveryTcpPort >= 1024 && deliveryTcpPort <= 65535 ? { tcpPort: deliveryTcpPort } : {}),
+      })
       if (config.applicationPort) await applicationChannel.listen(config.applicationPort, config.applicationHost)
       runtimeStarted = true
-      pagerDuty?.start()
       const owner = (await control.status()).owner
       if (telegramEnabled && telegramOwner(owner) && !config.channelBackendUrl) await telegramSource!.start(owner!)
       await scheduler.recover(runs)
@@ -1210,7 +1253,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       }
     }
   }
-  return { bot: bot!, isRunning: () => telegramEnabled ? Boolean(bot?.isRunning()) : runtimeStarted, start, stop, drainOutbox, drainInbox, drainSources, drainTaskRequests, applicationChannel }
+  return { bot: bot!, telegramEnabled, 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)) {