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

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')
@@ -105,10 +130,10 @@ export class ApplicationChannel {
     const owner = await this.sharedBinding(bindingId)
     const controls = this.options.aiControls
     if (!controls) throw new Error('Application controls unavailable')
-    const value = input as {action?: unknown; expectedSession?: unknown; sessionId?: unknown; presetId?: unknown; cli?: unknown; model?: unknown; effort?: unknown}
+    const value = input as {action?: unknown; expectedSession?: unknown; sessionId?: unknown; presetId?: unknown; cli?: unknown; provider?: unknown; model?: unknown; effort?: unknown}
     if (!value || !['new','switch','select','model'].includes(String(value.action)) ||
       !(value.expectedSession === null || (typeof value.expectedSession === 'string' && /^[a-f0-9-]{36}$/.test(value.expectedSession)))) throw new Error('Invalid application control request')
-    const fields = {new:[],switch:['sessionId'],select:['presetId'],model:['cli','model','effort']}[value.action as 'new'|'switch'|'select'|'model']!
+    const fields = {new:[],switch:['sessionId'],select:['presetId'],model:['cli','provider','model','effort']}[value.action as 'new'|'switch'|'select'|'model']!
     if (Object.keys(value).some(key => !['action','expectedSession',...fields].includes(key))) throw new Error('Invalid application control fields')
     const control = new ControlStore(this.options.controlDir, 900000)
     const expected = value.expectedSession as string | null
@@ -131,7 +156,7 @@ export class ApplicationChannel {
       await controls.select(preset, expected, guard)
     }
     if (value.action === 'model') {
-      const model = (await controls.catalog()).find(item => item.cli === value.cli && item.model === value.model)
+      const model = (await controls.catalog()).find(item => item.cli === value.cli && item.provider === value.provider && item.model === value.model)
       if (!model || (value.effort !== undefined && (typeof value.effort !== 'string' || !model.efforts.includes(value.effort)))) throw new Error('Invalid application model selection')
       await this.sharedBinding(bindingId)
       const preset = await controls.saveSelection(model, value.effort as string | undefined, guard)
@@ -160,10 +185,10 @@ export class ApplicationChannel {
     const owner = await this.sharedBinding(bindingId, false)
     const controls = this.options.aiControls
     if (!controls) throw new Error('Application controls unavailable')
-    const value = input as {action?:unknown; expectedSession?:unknown; presetId?:unknown; cli?:unknown; model?:unknown; effort?:unknown}
+    const value = input as {action?:unknown; expectedSession?:unknown; presetId?:unknown; cli?:unknown; provider?:unknown; model?:unknown; effort?:unknown}
     if (!value || !['new','select','model'].includes(String(value.action)) ||
       !(value.expectedSession===null || (typeof value.expectedSession==='string' && /^[a-f0-9-]{36}$/.test(value.expectedSession)))) throw new Error('Invalid application control request')
-    const fields = {new:[],select:['presetId'],model:['cli','model','effort']}[value.action as 'new'|'select'|'model']!
+    const fields = {new:[],select:['presetId'],model:['cli','provider','model','effort']}[value.action as 'new'|'select'|'model']!
     if (Object.keys(value).some(key=>!['action','expectedSession',...fields].includes(key))) throw new Error('Invalid application control fields')
     const hashedScope = applicationScope(bindingId,scope)
     const guard:ControlGuard = {owner,applicationScope:hashedScope,expectedSession:value.expectedSession as string|null,
@@ -180,7 +205,7 @@ export class ApplicationChannel {
       await controls.validate(preset)
     }
     if (value.action==='model') {
-      const model = (await controls.catalog()).find(item=>item.cli===value.cli && item.model===value.model)
+      const model = (await controls.catalog()).find(item=>item.cli===value.cli && item.provider===value.provider && item.model===value.model)
       if (!model || model.cli==='agy' || (value.effort!==undefined && (typeof value.effort!=='string' || !model.efforts.includes(value.effort)))) throw new Error('Invalid application model selection')
       preset = await controls.saveSelection(model,value.effort as string|undefined,guard)
     }
@@ -195,7 +220,7 @@ export class ApplicationChannel {
         if ('followTelegram' in rest) throw new Error('Invalid application request: choose one conversation option')
         input = {...rest, followTelegram: followOwner}
       }
-      const value = input as { requestId?: unknown; scope?: unknown; text?: unknown; attachment?: { name?: unknown; data?: unknown }; context?: Record<string, unknown>; expectedNativeSessionId?: unknown; activateTelegram?: unknown; followTelegram?: unknown; ai?: { cli?: unknown; model?: unknown; effort?: unknown } }
+      const value = input as { requestId?: unknown; scope?: unknown; text?: unknown; attachment?: { name?: unknown; data?: unknown }; context?: Record<string, unknown>; expectedNativeSessionId?: unknown; activateTelegram?: unknown; followTelegram?: unknown; ai?: { cli?: unknown; provider?: unknown; model?: unknown; effort?: unknown } }
       if (!value || !applicationId(value.requestId) || !applicationId(value.scope) || typeof value.text !== 'string' || (!value.text.trim() && value.attachment === undefined) || value.text.length > 16000 || Object.keys(value).some(key => !['requestId','scope','text','attachment','context','expectedNativeSessionId','activateTelegram','followTelegram','ai'].includes(key))) throw new Error('Invalid application request')
       if (value.expectedNativeSessionId !== undefined && (typeof value.expectedNativeSessionId !== 'string' || !/^[a-zA-Z0-9_-]{1,160}$/.test(value.expectedNativeSessionId))) throw new Error('Invalid application native session assertion')
       if (value.activateTelegram !== undefined && typeof value.activateTelegram !== 'boolean') throw new Error('Invalid application Telegram activation')
@@ -204,7 +229,7 @@ export class ApplicationChannel {
       let requestedPreset: AiPreset | undefined
       if (value.ai !== undefined) {
         const candidate = { ...value.ai, id: 'application', name: 'Application selection' }
-        if (!value.ai || Object.keys(value.ai).some(key => !['cli', 'model', 'effort'].includes(key)) || !isPreset(candidate)) throw new Error('Invalid application AI selection')
+        if (!value.ai || Object.keys(value.ai).some(key => !['cli', 'provider', 'model', 'effort'].includes(key)) || !isPreset(candidate)) throw new Error('Invalid application AI selection')
         assertEffort(candidate.effort, candidate.model, candidate.cli)
         requestedPreset = candidate
       }
@@ -227,14 +252,14 @@ export class ApplicationChannel {
       const existing = await this.runs.get(id)
       if (existing) {
         await this.bindings.authorize(existing)
-        if (requestedPreset && (existing.execution?.preset.cli !== requestedPreset.cli || existing.execution?.preset.model !== requestedPreset.model || existing.execution?.preset.effort !== requestedPreset.effort)) throw new Error('Application request ID conflicts with prior AI selection')
+        if (requestedPreset && (existing.execution?.preset.cli !== requestedPreset.cli || existing.execution?.preset.provider !== requestedPreset.provider || existing.execution?.preset.model !== requestedPreset.model || existing.execution?.preset.effort !== requestedPreset.effort)) throw new Error('Application request ID conflicts with prior AI selection')
         if (Boolean(existing.application?.followTelegram) !== Boolean(value.followTelegram) || existing.application?.scope !== value.scope || (existing.application?.inputText ?? existing.texts[0]) !== value.text || existing.application?.attachmentHash !== attachmentHash) throw new Error('Application request ID conflicts with prior scope or text')
         return existing // Retried context never replaces already admitted capabilities.
       }
       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)
@@ -252,7 +277,7 @@ export class ApplicationChannel {
     await this.bindings.authorize(run)
     const state = await new ControlStore(this.options.controlDir, 900000).status()
     const session = state.activeSession?.sessionId === run.execution?.sessionId ? state.activeSession : state.sessions?.find(item => item.sessionId === run.execution?.sessionId)
-    return { ...(session ? { sessionId: session.sessionId, nativeSessionId: session.nativeSessionId, cli: session.cli } : {}), ...(run.scheduled?.originRunId ? {originRunId:run.scheduled.originRunId} : {}), id: run.id, scope: (run.application ?? run.delivery)!.scope, status: run.status, messages: await this.runs.applicationMessages(run.id), approvals:await this.runs.applicationApprovals(run.id), ...(run.status === 'failed' ? { error: 'Agent execution failed; inspect the core run' } : {}) }
+    return { ...(session ? { sessionId: session.sessionId, nativeSessionId: session.nativeSessionId, cli: session.cli } : {}), ...(run.execution?.preset ? {preset:run.execution.preset} : {}), ...(run.scheduled?.originRunId ? {originRunId:run.scheduled.originRunId} : {}), id: run.id, scope: (run.application ?? run.delivery)!.scope, status: run.status, messages: await this.runs.applicationMessages(run.id), approvals:await this.runs.applicationApprovals(run.id), ...(run.status === 'failed' ? { error: 'Agent execution failed; inspect the core run' } : {}) }
   }
   async deliver(run: RunRecord, item: OutboxItem): Promise<void> {
     await this.bindings.authorize(run)
@@ -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/codex-session.ts

@@ -3,9 +3,9 @@ import { spawn, type ChildProcess } from 'node:child_process'
 import { createInterface } from 'node:readline'
 import { fileURLToPath } from 'node:url'
 import path from 'node:path'
-import { terminateJob } from './executor.js'
+import { terminateJob, validateCodexProvider, type CodexProviderBinding } from './executor.js'
 
-type Options = {workspace:string;controlDir:string;toolsHome?:string;sharedWorkspace?:string;additionalWorkspaces?:string[];model?:string;effort?:string;prompt:string;codexSandbox?:'external'}
+type Options = {workspace:string;controlDir:string;toolsHome?:string;sharedWorkspace?:string;additionalWorkspaces?:string[];model?:string;effort?:string;prompt:string;codexSandbox?:'external';codexProvider?:CodexProviderBinding}
 type Message = {id?:number;method?:string;params?:any;result?:any;error?:{message:string;code?:number}}
 
 // Keep Codex's native session alive. Codex itself starts goal continuation turns;
@@ -13,6 +13,7 @@ type Message = {id?:number;method?:string;params?:any;result?:any;error?:{messag
 export async function runCodexSession(options:Options, io:{launch?:()=>ChildProcess;emit?:(line:string)=>void}={}):Promise<number> {
   options = executionDefaults('codex', options)
   if (options.codexSandbox !== undefined && options.codexSandbox !== 'external') throw new Error('Invalid Codex sandbox selection')
+  const provider = options.codexProvider ? validateCodexProvider(options.codexProvider) : undefined
   const child=io.launch?.() ?? spawn('codex',['app-server','--stdio','--disable','memories','--enable','skip_host_skill_discovery'],{cwd:options.workspace,env:process.env,stdio:['pipe','pipe','pipe']})
   const emit=io.emit ?? (line=>process.stdout.write(line+'\n'))
   let id=0,threadId:string|undefined,activeTurn:string|undefined,finished=false,sawTurn=false,hadGoal=false
@@ -73,7 +74,8 @@ export async function runCodexSession(options:Options, io:{launch?:()=>ChildProc
     const result=await request('thread/start',{
       cwd:options.workspace,approvalPolicy:'never',sandbox:options.codexSandbox === 'external' ? 'danger-full-access' : 'workspace-write',model:options.model,
       config:{project_root_markers:['AGENTS.md','.git'],'sandbox_workspace_write.writable_roots':[options.controlDir,...(options.toolsHome?[options.toolsHome]:[]),...(options.sharedWorkspace?[options.sharedWorkspace]:[]),...(options.additionalWorkspaces ?? [])],
-        'sandbox_workspace_write.network_access':Boolean(options.toolsHome),...(options.effort?{model_reasoning_effort:options.effort}:{})},
+        'sandbox_workspace_write.network_access':Boolean(options.toolsHome),...(options.effort?{model_reasoning_effort:options.effort}:{}),
+        ...(provider?{model_provider:provider.id,[`model_providers.${provider.id}`]:{name:provider.name,base_url:provider.baseUrl,env_key:provider.envKey,wire_api:'responses',supports_websockets:false}}:{})},
     })
     threadId=result.thread?.id
     if(!threadId)throw new Error('Codex did not return a native thread ID')

package/src/config.ts

@@ -1,5 +1,6 @@
 import { parseWebLauncher, type WebLauncher } from './web-launcher.js'
 import { repairEnabled } from './repair-policy.js'
+import { isolationTransport, resolveIsolation, type IsolationClass } from './isolation.js'
 import path from 'node:path'
 import { homedir } from 'node:os'
 
@@ -15,6 +16,7 @@ export type Config = ControlConfig & {
   telegramBotToken: string
   workspace: string
   executorTimeoutMs: number
+  isolation?: IsolationClass
   codexSandbox?: 'external'
   codexAutoCompactTokens?: number
   executorCli: string
@@ -24,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 => {
@@ -47,29 +45,28 @@ 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')
+  const isolation = resolveIsolation(env)
+  const transport = env.EZ_EXECUTOR_TRANSPORT?.trim() || isolationTransport(isolation)
   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 || env.EZ_EXECUTOR_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')
-  }
+  if (codexSandbox && (env.EZ_CHANNEL_BACKEND_URL || transport !== 'local')) throw new Error('External Codex sandbox requires native local execution')
   return {
     ...loadControlConfig(env),
     telegramEnabled,
@@ -78,6 +75,7 @@ export const loadConfig = (env: NodeJS.ProcessEnv = process.env): Config => {
     repairEnabled: repairEnabled(env.EZ_REPAIR_ENABLED),
     workspace: path.resolve(env.EZ_AGENT_WORKSPACE?.trim() || './agent'),
     executorTimeoutMs: 0,
+    isolation,
     codexSandbox: codexSandbox === 'external' ? 'external' : undefined,
     codexAutoCompactTokens: !env.EZ_CODEX_AUTO_COMPACT_TOKENS?.trim() ? undefined : positiveInteger(env.EZ_CODEX_AUTO_COMPACT_TOKENS, 'EZ_CODEX_AUTO_COMPACT_TOKENS'),
     executorCli: env.EZ_EXECUTOR_CLI?.trim() || 'agy',
@@ -87,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,
   }
 }