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

package/src/ai.ts

@@ -1,20 +1,25 @@
 import { assertEffort, allowedEffort } from './model-policy.js'
 import { access, readFile } from 'node:fs/promises'
 import { constants } from 'node:fs'
+import { execFile } from 'node:child_process'
+import { promisify } from 'node:util'
 import { homedir } from 'node:os'
 import { join, delimiter } from 'node:path'
-import { executorKey, resolveExecutor } from './executor.js'
+import { executorEnvironment, executorKey, resolveExecutor } from './executor.js'
 import { desktopCodexPath } from './desktop-bridge.js'
 
 export type AiPreset = { id: string; name: string; cli: string; provider?: string; model?: string; effort?: string }
 export type ExecutionChoice = { sessionId: string; preset: AiPreset }
 export type ModelChoice = { cli: string; provider?: string; model?: string; name: string; efforts: string[] }
 const safe = (s: unknown): s is string => typeof s === 'string' && /^[a-zA-Z0-9_./:-]{1,160}$/.test(s)
+const knownClis = ['grok', 'codex', 'codex-gui', 'claude', 'opencode', 'agy', 'pi']
+const nativeEffort = (cli: string, effort: string) =>
+  cli === 'pi' ? ['off', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'].includes(effort) : true
 export const isPreset = (p: unknown): p is AiPreset => {
   if (!p || typeof p !== 'object') return false
   const v = p as AiPreset
   return safe(v.id) && typeof v.name === 'string' && v.name.length > 0 && v.name.length <= 80 &&
-    ['grok', 'codex', 'codex-gui', 'claude', 'opencode', 'agy'].includes(v.cli) &&
+    knownClis.includes(v.cli) &&
     (v.provider === undefined || safe(v.provider)) && (v.model === undefined || safe(v.model)) && (v.effort === undefined || safe(v.effort))
 }
 export const isExecutionChoice = (v: unknown): v is ExecutionChoice => {
@@ -45,7 +50,81 @@ export const installed = async (cli: string): Promise<boolean> => {
 
 // Read only metadata from native client catalogs. Never import prompts, credentials,
 // provider configuration, or model instructions into relay context.
-export const readModels = async (home = homedir(), available = installed, codexHome = join(home, '.codex')): Promise<ModelChoice[]> => {
+// The optional runner injects `opencode models` output in tests; production
+// spawns the installed CLI with the whitelisted executor environment.
+export const readOpencodeModels = async (run?: (args: string[]) => Promise<string>, dataHome?: string): Promise<ModelChoice[]> => {
+  const exec = run ?? (async (args: string[]) =>
+    (await promisify(execFile)('opencode', args, { env: { ...executorEnvironment(), ...(dataHome ? { XDG_DATA_HOME: dataHome } : {}) }, timeout: 8000, maxBuffer: 4 * 1024 * 1024 })).stdout)
+  const record = (value: unknown): Record<string, unknown> =>
+    value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {}
+  try {
+    const stdout = await exec(['models', '--verbose'])
+    // Verbose output alternates a `provider/model` identifier line with its
+    // pretty-printed JSON metadata (name, variants). Split on identifier lines
+    // so variant keys can be projected as selectable efforts.
+    const segments = stdout.split(/^([A-Za-z0-9_.\-]+\/[A-Za-z0-9_./:~\-]+)$/m)
+    const entries: ModelChoice[] = []
+    for (let index = 1; index + 1 < segments.length; index += 2) {
+      const id = segments[index].trim()
+      if (!safe(id)) continue
+      let meta: Record<string, unknown>
+      try { meta = record(JSON.parse(segments[index + 1])) } catch { continue }
+      const friendly = typeof meta.name === 'string' ? meta.name.trim() : ''
+      const efforts = Object.keys(record(meta.variants))
+        .filter((effort) => safe(effort) && allowedEffort(effort, id, 'opencode'))
+      entries.push({ cli: 'opencode', model: id,
+        name: (friendly ? `${friendly} · ${id}` : id).slice(0, 80), efforts })
+    }
+    if (entries.length) return entries
+  } catch { /* fall through to the plain list, then the client default */ }
+  try {
+    const stdout = await exec(['models'])
+    const entries: ModelChoice[] = []
+    for (const line of stdout.split(/\r?\n/)) {
+      const id = line.trim()
+      if (!id || !safe(id)) continue
+      entries.push({ cli: 'opencode', model: id, name: id.slice(0, 80), efforts: [] })
+    }
+    if (entries.length) return entries
+  } catch { /* unavailable metadata stays client default */ }
+  return []
+}
+
+// User-curated entries live in the agent's own setup (control/ai-models.json),
+// never in the repo. They pin models the native catalogs may not currently
+// serve (e.g. paid tiers) and merge ahead of discovered entries, so selection
+// validation accepts them.
+export const readCuratedModels = async (controlDir?: string): Promise<ModelChoice[]> => {
+  if (!controlDir) return []
+  const curated: ModelChoice[] = []
+  const seen = new Set<string>()
+  try {
+    const raw = JSON.parse(await readFile(join(controlDir, 'ai-models.json'), 'utf8'))
+    if (!Array.isArray(raw)) return []
+    for (const candidate of raw) {
+      if (!candidate || typeof candidate !== 'object' || Array.isArray(candidate)) continue
+      const entry = candidate as Record<string, unknown>
+      if (typeof entry.cli !== 'string' || !knownClis.includes(entry.cli)) continue
+      if (entry.provider !== undefined && !safe(entry.provider)) continue
+      if (entry.model !== undefined && !safe(entry.model)) continue
+      const key = `${entry.cli}‖${entry.provider ?? ''}‖${entry.model ?? ''}`
+      if (seen.has(key)) continue
+      seen.add(key)
+      curated.push({
+        cli: entry.cli,
+        ...(entry.provider !== undefined ? { provider: entry.provider as string } : {}),
+        ...(entry.model !== undefined ? { model: entry.model as string } : {}),
+        name: (typeof entry.name === 'string' && entry.name ? entry.name : String(entry.model ?? entry.cli)).slice(0, 80),
+        efforts: (Array.isArray(entry.efforts) ? entry.efforts : [])
+          .filter((effort): effort is string => safe(effort))
+          .filter((effort) => allowedEffort(effort, typeof entry.model === 'string' ? entry.model : undefined, entry.cli as string) && nativeEffort(entry.cli as string, effort)),
+      })
+    }
+  } catch { return [] }
+  return curated
+}
+
+export const readModels = async (home = homedir(), available = installed, codexHome = join(home, '.codex'), opencodeRunner?: (args: string[]) => Promise<string>, opencodeDataHome?: string, opencodeAllowlist?: string[], curationDir?: string): Promise<ModelChoice[]> => {
   const models: ModelChoice[] = []
   const record = (value: unknown): Record<string, unknown> =>
     value && typeof value === 'object' && !Array.isArray(value) ? value as Record<string, unknown> : {}
@@ -79,9 +158,56 @@ export const readModels = async (home = homedir(), available = installed, codexH
     models.push(...(desktop.length ? desktop : [{ cli: 'codex-gui', name: 'codex-gui · desktop', efforts: [] }]))
   }
   // Other adapters expose the authenticated client's default, not a guessed catalog.
-  for (const cli of ['claude', 'opencode', 'agy'])
+  for (const cli of ['claude', 'agy'])
     if (await available(cli)) models.push({ cli, name: `${cli} · client default`, efforts: [] })
-  return models
+  const allow = opencodeAllowlist ?? opencodeProviderAllowlist()
+  if (await available('opencode')) models.push(...await opencodeCatalogModels(opencodeRunner, opencodeDataHome, allow))
+  // Pi has separate provider configuration. OpenCode's catalog cannot
+  // establish which models Pi can execute.
+  if (!allow && await available('pi')) models.push({ cli: 'pi', name: 'Pi · client default', efforts: [] })
+  const curated = await readCuratedModels(curationDir)
+  if (!curated.length) return models
+  const scoped: ModelChoice[] = []
+  for (const entry of curated) {
+    if (!(await available(entry.cli))) continue
+    if (['opencode', 'pi'].includes(entry.cli) && allow &&
+        (entry.model === undefined || !allow.includes(entry.model.split('/')[0]))) continue
+    scoped.push(entry)
+  }
+  const key = (m: { cli: string; provider?: string; model?: string }) => `${m.cli}‖${m.provider ?? ''}‖${m.model ?? ''}`
+  const curatedKeys = new Set(scoped.map(key))
+  return [...scoped, ...models.filter((m) => !curatedKeys.has(key(m)))]
+}
+export const opencodeCatalogModels = async (
+  opencodeRunner?: (args: string[]) => Promise<string>,
+  opencodeDataHome?: string,
+  opencodeAllowlist?: string[],
+): Promise<ModelChoice[]> => {
+  const discovered = await readOpencodeModels(opencodeRunner, opencodeDataHome)
+  const allow = opencodeAllowlist ?? opencodeProviderAllowlist()
+  const scoped = allow ? discovered.filter((m) => m.model && allow.includes(m.model.split('/')[0])) : discovered
+  if (scoped.length) return scoped
+  // A set allowlist that matches nothing offers no choice rather than falling
+  // back outside the allowed providers.
+  if (allow) return []
+  return [{ cli: 'opencode', name: 'opencode · client default', efforts: [] as string[] }]
+}
+
+// Optional deployment-scoped restriction of the OpenCode catalog to named
+// providers (e.g. EZ_OPENCODE_PROVIDERS=opencode-go). Unset means unfiltered.
+// Reads process env directly like OPENCODE_MODEL; malformed values fail fast
+// so /ai reports the misconfiguration instead of a silently wrong list.
+const providerId = (p: unknown): p is string => typeof p === 'string' && /^[a-z][a-z0-9_-]{0,31}$/.test(p)
+export const validateOpencodeProviders = (value: unknown): string[] | undefined => {
+  if (value === undefined) return undefined
+  if (!Array.isArray(value) || !value.length || value.length > 16 || new Set(value).size !== value.length || value.some((p) => !providerId(p)))
+    throw new Error('opencode provider allowlist must be one to sixteen unique provider IDs')
+  return value as string[]
+}
+export const opencodeProviderAllowlist = (env: NodeJS.ProcessEnv = process.env): string[] | undefined => {
+  const raw = env.EZ_OPENCODE_PROVIDERS?.trim()
+  if (!raw) return undefined
+  return validateOpencodeProviders([...new Set(raw.split(',').map((p) => p.trim()).filter(Boolean))])
 }
 
 export const validateSelection = async (p: AiPreset, catalog: ModelChoice[], available = installed): Promise<void> => {

package/src/application-channel.ts

@@ -2,7 +2,7 @@ import { createServer, type Server, type IncomingMessage, type ServerResponse }
 import { createHash, randomUUID, timingSafeEqual } from 'node:crypto'
 import { mkdir, readFile, writeFile, rename, open, unlink } from 'node:fs/promises'
 import { join } from 'node:path'
-import { ControlStore, sessionTitle, type ControlGuard, type Owner, sameOwner, validOwner, ownerId, ownerEpoch } from './control-state.js'
+import { ControlStore, sessionTitle, telegramOwner, type ControlGuard, type Owner, sameOwner, validOwner, ownerId, ownerEpoch } from './control-state.js'
 import { RunStore, type RunRecord, type OutboxItem } from './runs.js'
 import { ownsRun } from './identity.js'
 import { applicationId, validApplicationOrigin } from './application-origin.js'
@@ -74,6 +74,8 @@ export class ApplicationChannel {
     controlDir: string; workspace?: string; initial: AiPreset
     wake: () => void
     cancel: (id: string) => Promise<void>
+    createTelegramPairing?: (bindingId: string, owner: Owner) => Promise<{ connected: true } | { connected: false; url: string; expiresAt: string }>
+    telegramAvailable?: () => boolean
     aiControls?: {
       catalog: () => Promise<ModelChoice[]>
       select: (preset: AiPreset, expectedSession: string | null, guard?: ControlGuard) => Promise<unknown>
@@ -88,6 +90,29 @@ export class ApplicationChannel {
     if (!binding || (shared && !binding.shareTelegram) || !sameOwner(binding.owner, state.owner)) throw new Error('Application authority does not permit controls')
     return binding.owner
   }
+  private async telegramConnection(bindingId: string) {
+    await this.sharedBinding(bindingId)
+    const owner = (await new ControlStore(this.options.controlDir, 900000).status()).owner
+    const connected = Boolean(telegramOwner(owner))
+    return this.options.telegramAvailable
+      ? { connected, ready: this.options.telegramAvailable() }
+      : { connected }
+  }
+  private async createTelegramConnection(bindingId: string) {
+    const owner = await this.sharedBinding(bindingId)
+    const current = (await new ControlStore(this.options.controlDir, 900000).status()).owner
+    if (telegramOwner(current)) return { connected: true } as const
+    if (!this.options.createTelegramPairing) throw new Error('Telegram connection is unavailable')
+    return this.options.createTelegramPairing(bindingId, owner)
+  }
+  async claimTelegramConnection(token: string, telegramUserId: number, telegramChatId: number): Promise<boolean> {
+    const control = new ControlStore(this.options.controlDir, 900000)
+    const owner = await control.claimApplicationTelegramPairing(token, telegramUserId, telegramChatId, async (bindingId, expectedOwner) => {
+      const binding = (await this.bindings.list()).find(item => item.bindingId === bindingId)
+      return Boolean(binding?.shareTelegram && sameOwner(binding.owner, expectedOwner))
+    })
+    return Boolean(owner)
+  }
   async controls(bindingId: string) {
     await this.sharedBinding(bindingId)
     if (!this.options.aiControls) throw new Error('Application controls unavailable')
@@ -233,8 +258,8 @@ export class ApplicationChannel {
       }
       const control = new ControlStore(this.options.controlDir, 900000)
       if (!sameOwner(binding.owner, (await control.status()).owner)) throw new Error('Application authority revoked')
-      if (bytes && !this.options.workspace) throw new Error('Invalid application attachment: workspace unavailable')
-      const staged = bytes ? await stageChatAttachment(this.options.workspace!, value.attachment!.name as string, bytes, value.text) : undefined
+      if (bytes && !this.options.controlDir) throw new Error('Invalid application attachment: control unavailable')
+      const staged = bytes ? await stageChatAttachment(this.options.controlDir, value.attachment!.name as string, bytes, value.text) : undefined
       let run: RunRecord
       try {
       const execution = value.followTelegram ? await control.captureChoice(this.options.initial) : await control.captureApplicationChoice(this.options.initial, applicationScope(bindingId, value.scope), binding.shareTelegram === true && value.activateTelegram === true, requestedPreset, value.expectedNativeSessionId as string | undefined)
@@ -270,13 +295,33 @@ export class ApplicationChannel {
       if (request.method === 'GET' && path === '/v1/registration') {
         send(200, {ownerId: ownerId(binding.owner), bindingId: binding.bindingId, channel: binding.id}); return
       }
+      if (path === '/v1/telegram' && request.method === 'GET') {
+        if ([...url.searchParams.keys()].length) throw new Error('Invalid application Telegram request')
+        if (!binding.shareTelegram) { send(403, { error: 'Application authority does not permit Telegram connection' }); return }
+        send(200, await this.telegramConnection(binding.bindingId)); return
+      }
+      if (path === '/v1/telegram/link' && request.method === 'POST') {
+        const chunks: Buffer[] = []; let size = 0
+        for await (const chunk of request) { size += chunk.length; if (size > 1024) throw new Error('Invalid application Telegram request'); chunks.push(chunk) }
+        if (Buffer.concat(chunks).toString('utf8').trim()) throw new Error('Invalid application Telegram request')
+        if (!binding.shareTelegram) { send(403, { error: 'Application authority does not permit Telegram connection' }); return }
+        send(200, await this.createTelegramConnection(binding.bindingId)); return
+      }
       if (request.method === 'GET' && path === '/v1/runs') {
-        const all = (await this.runs.list()).filter(run => (run.application ?? run.delivery)?.bindingId === binding.bindingId)
+        const owned = await this.runs.list()
+        const all = owned.filter(run => (run.application ?? run.delivery)?.bindingId === binding.bindingId)
+        const currentOwner = binding.shareTelegram ? telegramOwner((await new ControlStore(this.options.controlDir, 900000).status()).owner) : null
+        const telegram = currentOwner
+          ? owned.filter(run => run.application === undefined && run.delivery === undefined && run.taskId === undefined && run.external === undefined && run.scheduled === undefined && run.telegramUserId === currentOwner.telegramUserId && run.ownerId === ownerId(currentOwner) && run.ownerEpoch === ownerEpoch(currentOwner) && (run.telegramApplication === undefined || run.telegramApplication.bindingId === binding.bindingId) && !all.some(item => item.id === run.id))
+          : []
+        const visible = [...all, ...telegram]
         const before = url.searchParams.get('before')
-        const end = before ? all.findIndex(run => run.id === before) : all.length
+        const end = before ? visible.findIndex(run => run.id === before) : visible.length
         if (end < 0) throw new Error('Invalid application inbox cursor')
-        const records = all.slice(Math.max(0,end-100),end)
-        send(200, {runs: await Promise.all(records.map(run => this.snapshot(binding.bindingId, run.id))), nextCursor:end>100?records[0].id:null}); return
+        const records = visible.slice(Math.max(0,end-100),end)
+        send(200, {runs: await Promise.all(records.map(run => (run.application ?? run.delivery)
+          ? this.snapshot(binding.bindingId, run.id)
+          : Promise.resolve({id: run.id, scope: 'telegram', status: run.status, texts: run.texts, telegramUserId: run.telegramUserId, createdAt: run.createdAt}))), nextCursor:end>100?records[0].id:null}); return
       }
       if (path==='/v1/scope-control' && ['GET','POST'].includes(request.method ?? '')) {
         const scope = url.searchParams.get('scope')
@@ -314,6 +359,32 @@ export class ApplicationChannel {
         if(!await new Tasks(this.options.controlDir).decide(approvalMatch[1]))throw new Error('Unknown application approval')
         send(200,{id:approvalMatch[1],decision:input.decision});return
       }
+      const attachMatch = path.match(/^\/v1\/runs\/([A-Za-z0-9_-]{1,160})\/application$/)
+      if (attachMatch && request.method === 'POST') {
+        if (!binding.shareTelegram) { send(403, { error: 'Application authority does not permit Telegram admission' }); return }
+        const chunks: Buffer[] = []; let size = 0
+        for await (const chunk of request) { size += chunk.length; if (size > 65536) throw new Error('Invalid application admission size'); chunks.push(chunk) }
+        const input = JSON.parse(Buffer.concat(chunks).toString('utf8')) as { context?: unknown; scope?: unknown }
+        if (!input || typeof input !== 'object' || Array.isArray(input) || Object.keys(input).some(key => key !== 'context' && key !== 'scope')) throw new Error('Invalid application admission')
+        const scope = input.scope === undefined ? 'telegram' : input.scope
+        if (typeof scope !== 'string') throw new Error('Invalid application admission')
+        const target = await this.runs.get(attachMatch[1])
+        if (target?.telegramApplication?.bindingId === binding.bindingId) {
+          const same = target.telegramApplication.scope === scope &&
+            JSON.stringify(target.telegramApplication.context ?? null) === JSON.stringify(input.context ?? null)
+          if (same) { send(200, { id: target.id, scope: target.telegramApplication.scope, status: target.status }); return }
+          throw new Error('Application admission conflicts with prior context')
+        }
+        if (!target || target.application || target.telegramApplication || target.taskId || target.external || target.scheduled || target.telegramUserId === undefined) throw new Error('Unknown application run')
+        const state = await new ControlStore(this.options.controlDir, 900000).status()
+        const linked = telegramOwner(state.owner)
+        if (!linked || target.telegramUserId !== linked.telegramUserId || !sameOwner(binding.owner, state.owner)) throw new Error('Application authority does not permit Telegram admission')
+        if (target.status !== 'queued' && target.status !== 'running') throw new Error('Application admission conflicts with finished run')
+        const application = { bindingId: binding.bindingId, scope, requestId: target.id, context: input.context as Record<string, unknown> }
+        if (!validApplicationOrigin(application)) throw new Error('Invalid application admission')
+        const admitted = await this.runs.attachTelegramApplication(target.id, application)
+        send(200, { id: admitted.id, scope, status: admitted.status }); return
+      }
       const match = path.match(/^\/v1\/runs\/(r_(?:app|schedule)_[a-f0-9]{64})(\/cancel)?$/)
       if (match && ((!match[2] && request.method === 'GET') || (match[2] && request.method === 'POST'))) {
         await this.snapshot(binding.bindingId, match[1])

package/src/application-cli.ts

@@ -1,6 +1,6 @@
 import { parseArgs } from 'node:util'
 import { readFile } from 'node:fs/promises'
-import { loadControlConfig } from './config.js'
+import { loadControlConfig, telegramToken } from './config.js'
 import { ControlStore, sameOwner, ownerId } from './control-state.js'
 import { ApplicationBindings, applicationScope, validateApplicationRegistration } from './application-channel.js'
 import { initialPreset } from './ai.js'
@@ -17,7 +17,7 @@ async function main() {
   const config = loadControlConfig(), control = new ControlStore(config.controlDir, config.pairingTtlMs)
   if (values.owner && values['owner-id']) throw new Error('Choose one owner registration form')
   if (values['owner-id'] && (!values.id || !values['token-file'] || values.revoke || values.list || values['import-scope'])) throw new Error('--owner-id requires channel registration')
-  if (values.owner && (process.env.EZ_TELEGRAM_ENABLED !== 'false' || !values.id || !values['token-file'] || values.revoke || values.list || values['import-scope'])) throw new Error('--owner bootstrap requires explicit application-only registration')
+  if (values.owner && (telegramToken(process.env) || !values.id || !values['token-file'] || values.revoke || values.list || values['import-scope'])) throw new Error('--owner bootstrap requires an agent without a Telegram bot')
   const registrationToken = values['token-file'] ? (await readFile(values['token-file'], 'utf8')).trim() : null
   if (values.owner || values['owner-id']) validateApplicationRegistration(values.id!, registrationToken)
   const owner = values['owner-id'] ? await control.registerOwner(values['owner-id']) : values.owner ? await control.bootstrapApplicationOwner(Number(values.owner)) : (await control.status()).owner

package/src/approval-cli.ts

@@ -1,6 +1,5 @@
 import { loadControlConfig } from './config.js'
-import { ApprovalStore } from './approval.js'
-import { RunStore } from './runs.js'
+import { callDeliverySocket, socketPathFor } from './delivery-socket.js'
 
 const args = process.argv.slice(2).filter((arg) => arg !== '--')
 if (args.includes('--help') || args.includes('-h')) {
@@ -27,10 +26,12 @@ for (let i = 0; i < args.length; i++) {
 }
 
 const config = loadControlConfig()
-const approvalStore = new ApprovalStore(config.controlDir)
+const socketPath = socketPathFor(config.controlDir)
 
 if (checkId) {
-  const record = await approvalStore.getDecision(checkId)
+  const record = await callDeliverySocket(socketPath, { op: 'approvalCheck', payload: { actionId: checkId } }) as {
+    actionId: string; decision: string; decidedAt?: string; decidedBy?: number
+  }
   console.log(JSON.stringify({
     ok: true,
     actionId: checkId,
@@ -53,7 +54,13 @@ if (!runId) {
   process.exit(1)
 }
 
-const runStore = new RunStore(config.controlDir)
-await approvalStore.requestApproval(actionId, prompt, runId)
-const item = await runStore.enqueueApproval(runId, prompt, actionId, { replyToMessageId: replyTo })
+// The relay records the approval request and delivers its card; the decision
+// arrives later through Telegram and is read back with --check.
+const item = await callDeliverySocket(socketPath, {
+  op: 'enqueue',
+  payload: {
+    kind: 'approval', runId, approvalPrompt: prompt, approvalActionId: actionId,
+    ...(replyTo !== undefined ? { replyToMessageId: replyTo } : {}),
+  },
+}) as { outbox_id: string; id: string }
 console.log(JSON.stringify({ ok: true, run: runId, actionId, outbox_id: item.id, status: 'requested' }))

package/src/approval.ts

@@ -1,5 +1,3 @@
-import { mkdir, readFile, rename, writeFile } from 'node:fs/promises'
-import path from 'node:path'
 import { assertId } from './identity.js'
 import { ownerEpoch, ownerId, type Owner } from './control-state.js'
 
@@ -34,28 +32,32 @@ const isApprovalRecord = (value: unknown): value is ApprovalRecord => {
   )
 }
 
-export class ApprovalStore {
-  private readonly approvalsDir: string
+// Stateless pipe: approvals live in relay memory. Engine children request
+// decisions through the delivery socket (folded into the approval send);
+// callbacks and task arbitration record them in-relay. A restart drops
+// pending approvals by design.
+const approvalsByControl = new Map<string, Map<string, ApprovalRecord>>()
 
-  constructor(controlDir: string) {
-    this.approvalsDir = path.join(controlDir, 'approvals')
-  }
+const approvalsFor = (controlDir: string): Map<string, ApprovalRecord> => {
+  let map = approvalsByControl.get(controlDir)
+  if (!map) { map = new Map(); approvalsByControl.set(controlDir, map) }
+  return map
+}
 
-  private async ensure(): Promise<void> {
-    await mkdir(this.approvalsDir, { recursive: true, mode: 0o700 })
-  }
+export class ApprovalStore {
+  constructor(private readonly controlDir: string) {}
 
-  private filePath(actionId: string): string {
+  private key(actionId: string): string {
     const safe = assertId(actionId)
     if (safe.length > 40) throw new Error('Approval identifier must be at most 40 characters')
-    return path.join(this.approvalsDir, `${safe}.json`)
+    return safe
   }
 
   async requestApproval(actionId: string, prompt: string, runId?: string): Promise<ApprovalRecord> {
     if (!prompt.trim()) throw new Error('Approval prompt is empty')
     if (runId) assertId(runId)
-    await this.ensure()
-    const existing = await this.getDecision(actionId)
+    const store = approvalsFor(this.controlDir)
+    const existing = store.get(this.key(actionId)) ?? null
     if (existing) {
       if (existing.runId !== runId || existing.prompt !== prompt)
         throw new Error('Approval ID already belongs to another request')
@@ -70,10 +72,7 @@ export class ApprovalStore {
       decision: 'pending',
       createdAt: new Date().toISOString(),
     }
-    const file = this.filePath(actionId)
-    const temporary = `${file}.${process.pid}.tmp`
-    await writeFile(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 })
-    await rename(temporary, file)
+    store.set(this.key(actionId), record)
     return record
   }
 
@@ -83,8 +82,8 @@ export class ApprovalStore {
     decidedBy: number,
     decisionUpdateId?: number,
   ): Promise<ApprovalRecord> {
-    await this.ensure()
-    const existing = await this.getDecision(actionId)
+    const store = approvalsFor(this.controlDir)
+    const existing = store.get(this.key(actionId)) ?? null
     if (!existing) throw new Error('Unknown approval request')
     if (
       decisionUpdateId !== undefined &&
@@ -102,34 +101,25 @@ export class ApprovalStore {
       decidedBy,
       decisionUpdateId,
     }
-    const file = this.filePath(actionId)
-    const temporary = `${file}.${process.pid}.tmp`
-    await writeFile(temporary, `${JSON.stringify(record, null, 2)}\n`, { mode: 0o600 })
-    await rename(temporary, file)
+    store.set(this.key(actionId), record)
     return record
   }
 
   async recordOwnerDecision(actionId: string, decision: 'approved' | 'denied', owner: Owner): Promise<ApprovalRecord> {
-    await this.ensure()
-    const existing = await this.getDecision(actionId)
+    const store = approvalsFor(this.controlDir)
+    const existing = store.get(this.key(actionId)) ?? null
     if (!existing) throw new Error('Unknown approval request')
     if (existing.decision !== 'pending') throw new Error('Approval already decided')
     if (Date.now() - Date.parse(existing.createdAt) > 900_000) throw new Error('Approval expired')
     const record: ApprovalRecord = {...existing,version:2,decision,decidedAt:new Date().toISOString(),decidedOwnerId:ownerId(owner),decidedOwnerEpoch:ownerEpoch(owner)}
-    const file=this.filePath(actionId),temporary=`${file}.${process.pid}.tmp`
-    await writeFile(temporary,`${JSON.stringify(record,null,2)}\n`,{mode:0o600});await rename(temporary,file)
+    store.set(this.key(actionId), record)
     return record
   }
 
   async getDecision(actionId: string): Promise<ApprovalRecord | null> {
-    try {
-      const parsed: unknown = JSON.parse(await readFile(this.filePath(actionId), 'utf8'))
-      if (!isApprovalRecord(parsed) || parsed.actionId !== actionId)
-        throw new Error('Invalid approval record shape')
-      return parsed
-    } catch (error: unknown) {
-      if ((error as NodeJS.ErrnoException).code === 'ENOENT') return null
-      throw error
-    }
+    const record = approvalsFor(this.controlDir).get(this.key(actionId)) ?? null
+    if (record && (!isApprovalRecord(record) || record.actionId !== actionId))
+      throw new Error('Invalid approval record shape')
+    return record
   }
 }

package/src/channel-backend.ts

@@ -1,7 +1,6 @@
-import { readFile } from 'node:fs/promises'
 import type { Config } from './config.js'
 import type { RunRecord } from './runs.js'
-import { workspaceFile } from './files.js'
+import { readStagedAttachment } from './files.js'
 
 // Application-owned jobs; no CLI state, provider credentials or business routing here.
 export async function dispatchChannel(config: Config, run: RunRecord): Promise<string | null> {
@@ -14,7 +13,7 @@ export async function dispatchChannel(config: Config, run: RunRecord): Promise<s
   for (const item of run.items ?? []) {
     let attachment
     if (item.attachment) {
-      const bytes = await readFile(await workspaceFile(config.workspace, item.attachment.path))
+      const bytes = await readStagedAttachment([config.controlDir, config.workspace], item.attachment.path)
       if (bytes.length > 12 * 1024 * 1024) throw new Error('Channel attachment exceeds 12 MB')
       attachment = { type: item.attachment.type, data: bytes.toString('base64') }
     }

package/src/config.ts

@@ -26,10 +26,6 @@ export type Config = ControlConfig & {
   applicationHost?: string
   geminiApiKey?: string
   openaiApiKey?: string
-  pagerDutyRoutingKey?: string
-  pagerDutyStocksHealthUrl?: string
-  pagerDutyPollMs?: number
-  pagerDutyFailureThreshold?: number
 }
 
 const positiveInteger = (value: string | undefined, name: string, fallback?: number): number => {
@@ -49,12 +45,20 @@ export const loadControlConfig = (env: NodeJS.ProcessEnv = process.env): Control
   }
 }
 
+export const telegramToken = (env: NodeJS.ProcessEnv = process.env): string => {
+  const token = env.TELEGRAM_BOT_TOKEN?.trim() || ''
+  if (token && !/^\d{5,}:[A-Za-z0-9_-]{20,}$/.test(token)) throw new Error('TELEGRAM_BOT_TOKEN is malformed; refusing to start Telegram transport')
+  return token
+}
+
 export const loadConfig = (env: NodeJS.ProcessEnv = process.env): Config => {
-  if (env.EZ_TELEGRAM_ENABLED !== undefined && !['true', 'false'].includes(env.EZ_TELEGRAM_ENABLED)) throw new Error('EZ_TELEGRAM_ENABLED must be true or false')
-  const telegramEnabled = env.EZ_TELEGRAM_ENABLED !== 'false'
-  const telegramBotToken = telegramEnabled ? env.TELEGRAM_BOT_TOKEN?.trim() || '' : ''
+  const legacy = env.EZ_TELEGRAM_ENABLED
+  if (legacy !== undefined && legacy !== 'true' && legacy !== 'false') throw new Error('EZ_TELEGRAM_ENABLED must be true or false')
+  const telegramBotToken = telegramToken(env)
+  const telegramEnabled = Boolean(telegramBotToken)
+  if (legacy !== undefined && (legacy === 'false') === telegramEnabled)
+    throw new Error('EZ_TELEGRAM_ENABLED was removed; it contradicts the inferred Telegram transport (a token means enabled). Unset EZ_TELEGRAM_ENABLED, and remove any stale TELEGRAM_BOT_TOKEN to stay application-only.')
   if (!telegramEnabled && !env.EZ_APPLICATION_PORT) throw new Error('Application-only execution requires EZ_APPLICATION_PORT')
-  if (telegramEnabled && !telegramBotToken) throw new Error('TELEGRAM_BOT_TOKEN is required')
 
   if (env.EZ_CHANNEL_BACKEND_URL && !env.EZ_CHANNEL_BACKEND_TOKEN?.trim()) throw new Error('EZ_CHANNEL_BACKEND_TOKEN is required')
   if (env.EZ_APPLICATION_PORT && env.EZ_CHANNEL_BACKEND_URL) throw new Error('Application input requires the native Ez executor, not a channel backend')
@@ -63,17 +67,6 @@ export const loadConfig = (env: NodeJS.ProcessEnv = process.env): Config => {
   const codexSandbox = env.EZ_CODEX_SANDBOX?.trim()
   if (codexSandbox && codexSandbox !== 'external') throw new Error('EZ_CODEX_SANDBOX must be external or unset')
   if (codexSandbox && (env.EZ_CHANNEL_BACKEND_URL || transport !== 'local')) throw new Error('External Codex sandbox requires native local execution')
-  const pagerDutyRoutingKey = env.PAGERDUTY_ROUTING_KEY?.trim()
-  const pagerDutyStocksHealthUrl = env.EZ_PAGERDUTY_STOCKS_HEALTH_URL?.trim()
-  if (pagerDutyStocksHealthUrl && !pagerDutyRoutingKey)
-    throw new Error('PAGERDUTY_ROUTING_KEY is required when EZ_PAGERDUTY_STOCKS_HEALTH_URL is set')
-  if (pagerDutyStocksHealthUrl) {
-    let url: URL
-    try { url = new URL(pagerDutyStocksHealthUrl) }
-    catch { throw new Error('EZ_PAGERDUTY_STOCKS_HEALTH_URL must be an absolute HTTP(S) URL') }
-    if (!['http:', 'https:'].includes(url.protocol) || url.username || url.password || url.hash)
-      throw new Error('EZ_PAGERDUTY_STOCKS_HEALTH_URL must be an absolute HTTP(S) URL without credentials or a fragment')
-  }
   return {
     ...loadControlConfig(env),
     telegramEnabled,
@@ -92,13 +85,5 @@ export const loadConfig = (env: NodeJS.ProcessEnv = process.env): Config => {
     channelBackendToken: env.EZ_CHANNEL_BACKEND_TOKEN?.trim(),
     geminiApiKey: env.GEMINI_API_KEY?.trim(),
     openaiApiKey: env.OPENAI_API_KEY?.trim(),
-    pagerDutyRoutingKey,
-    pagerDutyStocksHealthUrl,
-    pagerDutyPollMs: pagerDutyRoutingKey && pagerDutyStocksHealthUrl
-      ? positiveInteger(env.EZ_PAGERDUTY_POLL_SECONDS, 'EZ_PAGERDUTY_POLL_SECONDS', 30) * 1_000
-      : undefined,
-    pagerDutyFailureThreshold: pagerDutyRoutingKey && pagerDutyStocksHealthUrl
-      ? positiveInteger(env.EZ_PAGERDUTY_FAILURE_THRESHOLD, 'EZ_PAGERDUTY_FAILURE_THRESHOLD', 3)
-      : undefined,
   }
 }