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

package/test/ai.test.ts

@@ -4,7 +4,7 @@ import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { ControlStore } from '../src/control-state.js'
-import { initialPreset, chatPreset, readModels, isPreset } from '../src/ai.js'
+import { initialPreset, chatPreset, readModels, isPreset, readOpencodeModels, readCuratedModels, validateSelection, opencodeProviderAllowlist } from '../src/ai.js'
 import { createAiMenu } from '../src/menu.js'
 import { EXECUTOR_REGISTRY, nativeSessionId } from '../src/executor.js'
 import { InboxStore } from '../src/inbox.js'
@@ -242,6 +242,42 @@ test('model catalog can read an agent-bound Codex home', async () => {
   }
 })
 
+test('Choose AI lists the agent-bound Codex home instead of only the desktop fallback', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-ai-menu-codex-home-'))
+  const codexHome = await mkdtemp(join(tmpdir(), 'ez-ai-menu-cache-'))
+  try {
+    await writeFile(join(codexHome, 'models_cache.json'), JSON.stringify({ models: [
+      { slug: 'fixture-bound-model', display_name: 'Bound Fixture', visibility: 'list',
+        supported_reasoning_levels: [{ effort: 'medium' }] },
+    ] }))
+    const store = new ControlStore(dir, 1000)
+    await store.aiState(initialPreset('codex'))
+    // Default catalog (no explicit override): the menu must bind it to codexHome,
+    // otherwise an empty process-home cache drops codex and only codex-gui lists.
+    const menu = createAiMenu(store, 'codex', undefined, dir, codexHome,
+      async (cli) => cli === 'codex' || cli === 'codex-gui')
+    const replies: Array<{ text: string; buttons: Array<{ text: string; callback_data: string }> }> = []
+    const context = (data?: string) => ({
+      callbackQuery: data ? { data } : undefined,
+      answerCallbackQuery: async () => ({}),
+      reply: async (text: string, options?: { reply_markup?: { inline_keyboard?: Array<Array<{ text: string; callback_data: string }>> } }) => {
+        replies.push({ text, buttons: options?.reply_markup?.inline_keyboard?.flat() ?? [] })
+        return {} as never
+      },
+    })
+    await menu.list(context() as never)
+    assert.deepEqual(replies.at(-1)!.buttons.map((button) => button.text), [
+      'codex', 'codex-gui (desktop)', 'Refresh available AIs',
+    ])
+    const client = replies.at(-1)!.buttons.find((button) => button.text === 'codex')!
+    await menu.handle(context(client.callback_data) as never)
+    assert.deepEqual(replies.at(-1)!.buttons.map((button) => button.text), ['Bound Fixture', 'Back to clients'])
+  } finally {
+    await rm(dir, { recursive: true, force: true })
+    await rm(codexHome, { recursive: true, force: true })
+  }
+})
+
 test('native executor flags carry the exact model and effort; only structured metadata binds sessions', () => {
   const opts = { workspace: '/tmp/fixture', sessionId: crypto.randomUUID(), isResume: true,
     model: 'fixture-model', effort: 'medium' }
@@ -251,6 +287,12 @@ test('native executor flags carry the exact model and effort; only structured me
   const codex = EXECUTOR_REGISTRY.codex.buildArgs(opts, '', 'fixture')
   assert.ok(codex.includes('model_reasoning_effort="medium"'))
   assert.deepEqual(codex.slice(-3), ['resume', opts.sessionId, '-'])
+  // Opencode variants pass through verbatim on every platform; there is no
+  // OS-specific effort mapping between the catalog and `run --variant`.
+  const opencode = EXECUTOR_REGISTRY.opencode.buildArgs(
+    { workspace: '/tmp/fixture', model: 'opencode/muse-spark-1.3-contributor-free', effort: 'xhigh' }, '', 'fixture')
+  assert.equal(opencode[opencode.indexOf('-m') + 1], 'opencode/muse-spark-1.3-contributor-free')
+  assert.equal(opencode[opencode.indexOf('--variant') + 1], 'xhigh')
   assert.equal(nativeSessionId('codex', JSON.stringify({ type: 'thread.started', thread_id: opts.sessionId })), opts.sessionId)
   assert.equal(nativeSessionId('opencode', JSON.stringify({ type: 'step_start', sessionID: 'ses_fixture' })), 'ses_fixture')
   assert.equal(nativeSessionId('codex', JSON.stringify({ type: 'text', thread_id: opts.sessionId })), undefined)
@@ -317,3 +359,180 @@ test('upgrades expose responsive chat without replacing an existing default or q
     assert.ok(state.presets.some(p => p.id === 'chat-default'))
   } finally { await rm(dir, { recursive: true, force: true }) }
 })
+
+test('opencode catalog projects installed models with variants as efforts', async () => {
+  const verbose = [
+    'opencode/big-pickle',
+    JSON.stringify({ id: 'big-pickle', providerID: 'opencode', name: 'Big Pickle', variants: {} }),
+    'opencode/ling-free',
+    JSON.stringify({ id: 'ling-free', providerID: 'opencode', name: 'Ling Free',
+      variants: { low: { reasoningEffort: 'low' }, medium: { reasoningEffort: 'medium' }, 'bad option': {} } }),
+    'openrouter/~aliased/model',
+    JSON.stringify({ id: 'model', providerID: 'openrouter', name: 'Aliased', variants: {} }),
+  ].join('\n')
+  const catalog = await readOpencodeModels(async (args) => {
+    assert.deepEqual(args, ['models', '--verbose'])
+    return verbose
+  })
+  assert.deepEqual(catalog, [
+    { cli: 'opencode', model: 'opencode/big-pickle', name: 'Big Pickle · opencode/big-pickle', efforts: [] },
+    { cli: 'opencode', model: 'opencode/ling-free', name: 'Ling Free · opencode/ling-free', efforts: ['low', 'medium'] },
+  ])
+})
+
+test('opencode catalog falls back to the plain list, then to the client default', async () => {
+  const plain = await readOpencodeModels(async (args) => {
+    if (args.includes('--verbose')) throw new Error('no verbose metadata')
+    return 'opencode/alpha\nopenrouter/~aliased/model\nnot a model line\n'
+  })
+  assert.deepEqual(plain, [{ cli: 'opencode', model: 'opencode/alpha', name: 'opencode/alpha', efforts: [] }])
+  assert.deepEqual(await readOpencodeModels(async () => { throw new Error('opencode unavailable') }), [])
+  const fallback = await readModels(undefined, async (cli) => cli === 'opencode', undefined as never,
+    async () => { throw new Error('opencode unavailable') })
+  assert.deepEqual(fallback, [{ cli: 'opencode', name: 'opencode · client default', efforts: [] }])
+  const listed = await readModels(undefined, async (cli) => cli === 'opencode', undefined as never,
+    async () => 'opencode/alpha\n')
+  assert.deepEqual(listed, [{ cli: 'opencode', model: 'opencode/alpha', name: 'opencode/alpha', efforts: [] }])
+})
+
+test('opencode provider allowlist scopes the catalog to Go and never falls back outside it', async () => {
+  assert.equal(opencodeProviderAllowlist({}), undefined)
+  assert.equal(opencodeProviderAllowlist({ EZ_OPENCODE_PROVIDERS: '  ' }), undefined)
+  assert.deepEqual(opencodeProviderAllowlist({ EZ_OPENCODE_PROVIDERS: 'opencode-go' }), ['opencode-go'])
+  assert.deepEqual(opencodeProviderAllowlist({ EZ_OPENCODE_PROVIDERS: ' opencode-go ,openrouter,opencode-go ' }), ['opencode-go', 'openrouter'])
+  for (const bad of ['Bad Name!', 'has space', 'UPPER', 'a'.repeat(33), ',,,', 'ok,,bad name'])
+    assert.throws(() => opencodeProviderAllowlist({ EZ_OPENCODE_PROVIDERS: bad }), /one to sixteen unique provider IDs/)
+  const verbose = [
+    'opencode/mimo-free',
+    JSON.stringify({ id: 'mimo-free', providerID: 'opencode', name: 'Mimo Free', variants: {} }),
+    'opencode-go/muse-spark-1.3-contributor',
+    JSON.stringify({ id: 'muse-spark-1.3-contributor', providerID: 'opencode-go', name: 'Muse Spark 1.3 Contributor',
+      variants: { high: {}, xhigh: {} } }),
+    'openrouter/some/model',
+    JSON.stringify({ id: 'some/model', providerID: 'openrouter', name: 'Some', variants: {} }),
+  ].join('\n')
+  const runner = async () => verbose
+  const prior = process.env.EZ_OPENCODE_PROVIDERS
+  try {
+    process.env.EZ_OPENCODE_PROVIDERS = 'opencode-go'
+    const scoped = await readModels(undefined, async (cli) => cli === 'opencode', undefined as never, runner)
+    assert.deepEqual(scoped.map((m) => m.model), ['opencode-go/muse-spark-1.3-contributor'])
+    await assert.rejects(
+      validateSelection({ id: 'free', name: 'Free', cli: 'opencode', model: 'opencode/mimo-free' }, scoped, async () => true),
+      /installed client catalog/)
+    process.env.EZ_OPENCODE_PROVIDERS = 'missing-provider'
+    assert.deepEqual(await readModels(undefined, async (cli) => cli === 'opencode', undefined as never, runner), [])
+    delete process.env.EZ_OPENCODE_PROVIDERS
+    assert.equal((await readModels(undefined, async (cli) => cli === 'opencode', undefined as never, runner)).length, 3)
+  } finally {
+    if (prior === undefined) delete process.env.EZ_OPENCODE_PROVIDERS
+    else process.env.EZ_OPENCODE_PROVIDERS = prior
+  }
+})
+test('explicit host binding allowlist overrides the process environment', async () => {
+  const runner = async () => 'opencode/a\nopencode-go/b\n'
+  const only = (models: { cli: string; model?: string }[]) => models.filter((m) => m.cli === 'opencode').map((m) => m.model)
+  const prior = process.env.EZ_OPENCODE_PROVIDERS
+  try {
+    process.env.EZ_OPENCODE_PROVIDERS = 'opencode'
+    assert.deepEqual(only(await readModels(undefined, async () => true, undefined as never, runner)), ['opencode/a'])
+    assert.deepEqual(only(await readModels(undefined, async () => true, undefined as never, runner, undefined, ['opencode-go'])), ['opencode-go/b'])
+    assert.deepEqual(only(await readModels(undefined, async () => true, undefined as never, runner, undefined, undefined)), ['opencode/a'])
+  } finally {
+    if (prior === undefined) delete process.env.EZ_OPENCODE_PROVIDERS
+    else process.env.EZ_OPENCODE_PROVIDERS = prior
+  }
+})
+
+test('opencode model and variant selections validate against the installed catalog', async () => {
+  const catalog = [
+    { cli: 'opencode', model: 'opencode/ling-free', name: 'Ling Free · opencode/ling-free', efforts: ['low', 'medium'] },
+    { cli: 'opencode', model: 'opencode/big-pickle', name: 'Big Pickle · opencode/big-pickle', efforts: [] },
+  ]
+  const available = async (cli: string) => cli === 'opencode'
+  await validateSelection({ id: 'choice', name: 'Ling', cli: 'opencode', model: 'opencode/ling-free', effort: 'low' }, catalog, available)
+  await validateSelection({ id: 'default', name: 'Default', cli: 'opencode', model: 'opencode/big-pickle' }, catalog, available)
+  await assert.rejects(
+    validateSelection({ id: 'bad', name: 'Bad', cli: 'opencode', model: 'opencode/ling-free', effort: 'max' }, catalog, available),
+    /installed client catalog/)
+  await assert.rejects(
+    validateSelection({ id: 'missing', name: 'Missing', cli: 'opencode', model: 'opencode/unknown' }, catalog, available),
+    /installed client catalog/)
+})
+
+test('pi does not borrow an unrelated OpenCode catalog', async () => {
+  const runner = async () => [
+    'opencode-go/muse-spark-1.3-contributor',
+    JSON.stringify({ id: 'muse-spark-1.3-contributor', providerID: 'opencode-go', name: 'Muse Spark 1.3 Contributor', variants: { high: {}, xhigh: {} } }),
+  ].join('\n')
+  const catalog = await readModels(undefined, async (cli) => cli === 'pi', undefined as never, runner)
+  assert.deepEqual(catalog, [{ cli: 'pi', name: 'Pi · client default', efforts: [] }])
+  assert.equal(isPreset({ id: 'x', name: 'Pi', cli: 'pi' }), true)
+  assert.equal(isPreset({ id: 'x', name: 'Unavailable', cli: 'unreal-agent' }), false)
+  await validateSelection({ id: 'choice', name: 'Default', cli: 'pi' }, catalog, async (cli) => cli === 'pi')
+  await assert.rejects(
+    validateSelection(
+      { id: 'bad', name: 'Bad', cli: 'pi', model: 'opencode-go/muse-spark-1.3-contributor', effort: 'max' },
+      catalog, async (cli) => cli === 'pi'),
+    /installed client catalog/)
+})
+
+test('model catalog merges user-curated entries ahead of discovered ones', async () => {
+  const control = await mkdtemp(join(tmpdir(), 'ez-catalog-curated-'))
+  const home = await mkdtemp(join(tmpdir(), 'ez-catalog-curated-home-'))
+  try {
+    await mkdir(join(home, '.codex'))
+    await writeFile(join(home, '.codex/models_cache.json'), JSON.stringify({ models: [
+      { slug: 'fixture-model', display_name: 'Fixture', visibility: 'list',
+        supported_reasoning_levels: [{ effort: 'medium' }] },
+    ] }))
+    await writeFile(join(control, 'ai-models.json'), JSON.stringify([
+      { cli: 'pi', model: 'opencode-go/muse-spark-1.3-contributor', name: 'Pi · Muse Spark 1.3', efforts: ['xhigh'] },
+      { cli: 'pi', model: 'opencode-go/muse-spark-1.3-contributor', name: 'Dupe', efforts: [] },
+      { cli: 'codex', model: 'fixture-model', name: 'Curated Fixture', efforts: ['medium'] },
+      { cli: 'nope', model: 'x' },
+      'not-an-entry',
+    ]))
+    const installedOnly = async (cli: string) => cli === 'codex' || cli === 'pi'
+    const noRunner = async (_args: string[]): Promise<string> => { throw new Error('no native CLI in test') }
+    const catalog = await readModels(home, installedOnly, join(home, '.codex'),
+      noRunner, undefined, undefined, control)
+    assert.deepEqual(catalog.filter((m) => m.cli === 'pi'), [
+      { cli: 'pi', model: 'opencode-go/muse-spark-1.3-contributor', name: 'Pi · Muse Spark 1.3', efforts: ['xhigh'] },
+      { cli: 'pi', name: 'Pi · client default', efforts: [] },
+    ])
+    // Curated entries win over the same discovered id and validate for selection.
+    assert.deepEqual(catalog.filter((m) => m.cli === 'codex'), [
+      { cli: 'codex', model: 'fixture-model', name: 'Curated Fixture', efforts: ['medium'] },
+    ])
+    await validateSelection(
+      { id: 'choice', name: 'Spark', cli: 'pi', model: 'opencode-go/muse-spark-1.3-contributor', effort: 'xhigh' },
+      catalog, async (cli) => cli === 'pi')
+    // Missing or malformed curation files fall back to discovery alone.
+    assert.deepEqual(await readCuratedModels(join(control, 'missing-dir')), [])
+    await writeFile(join(control, 'ai-models.json'), 'not json')
+    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex', join(home, '.codex'),
+      noRunner, undefined, undefined, control), [
+      { cli: 'codex', model: 'fixture-model', name: 'Fixture', efforts: ['medium'] },
+    ])
+  } finally {
+    await rm(control, { recursive: true, force: true })
+    await rm(home, { recursive: true, force: true })
+  }
+})
+
+test('curated models respect installed clients and provider scope', async () => {
+  const control = await mkdtemp(join(tmpdir(), 'ez-catalog-scope-'))
+  try {
+    await writeFile(join(control, 'ai-models.json'), JSON.stringify([
+      { cli: 'pi', model: 'opencode-go/allowed', efforts: ['xhigh'] },
+      { cli: 'pi', model: 'other/blocked' },
+      { cli: 'opencode', model: 'other/blocked' },
+      { cli: 'claude', model: 'uninstalled' },
+    ]))
+    const catalog = await readModels(undefined, async (cli) => cli === 'pi', undefined as never,
+      async () => { throw new Error('no OpenCode catalog') }, undefined, ['opencode-go'], control)
+    assert.deepEqual(catalog.filter(entry => entry.model).map(entry => entry.model), ['opencode-go/allowed'])
+    assert.equal(catalog.some(entry => entry.cli === 'pi' && !entry.model), false)
+  } finally { await rm(control, { recursive: true, force: true }) }
+})

package/test/application-channel.test.ts

@@ -9,12 +9,13 @@ import { randomBytes } from 'node:crypto'
 import { fileURLToPath } from 'node:url'
 import { createRequire } from 'node:module'
 import { ApplicationChannel, ApplicationBindings, applicationScope } from '../src/application-channel.js'
-import { ControlStore, ownerId } from '../src/control-state.js'
+import { ControlStore, ownerId, ownerEpoch } from '../src/control-state.js'
 import { RunStore } from '../src/runs.js'
 import { initialPreset } from '../src/ai.js'
 import { requireOwnerExecution } from '../src/execution-authority.js'
 import { createRelay } from '../src/index.js'
 import { EXECUTOR_REGISTRY, executorEnvironment } from '../src/executor.js'
+import { serveTestLedger } from './helpers/ledger.js'
 
 const token = () => randomBytes(32).toString('base64url')
 const owner = async (dir: string) => {
@@ -31,7 +32,7 @@ test('HTTP auth, idempotency, origin/context isolation, revocation and persisted
   const root=await mkdtemp(join(tmpdir(),'ez-app-channel-'))
   const owned=await owner(root), runs=new RunStore(root), control=new ControlStore(root,1000)
   let wakes=0
-  const channel=new ApplicationChannel({controlDir:root,initial:initialPreset('codex'),wake:()=>{wakes++},cancel:async id=>{await runs.patch(id,{status:'cancelled'})}})
+  const channel=new ApplicationChannel({controlDir:root,initial:initialPreset('codex'),wake:()=>{wakes++},cancel:async id=>{await runs.patch(id,{status:'cancelled'})},createTelegramPairing:async()=>{throw new Error('unavailable')},telegramAvailable:()=>false})
   t.after(async()=>{await channel.stop();await rm(root,{recursive:true,force:true})})
   const firstToken=token(), secondToken=token()
   const first=(await channel.bindings.register('first',firstToken,owned))!
@@ -124,12 +125,14 @@ if(result.status!==0){console.error(result.stderr);process.exit(1)};
 `)
   EXECUTOR_REGISTRY.codex={...original,command:process.execPath,buildArgs:(options,_file,prompt)=>{prompts.push(prompt);resumeIds.push(options.isResume?options.sessionId:undefined);return ['--import',require.resolve('tsx'),fixture]}}
   const relay=createRelay({controlDir:root,workspace:root,pairingTtlMs:1000,telegramBotToken:'fixture',executorTimeoutMs:0,executorCli:'codex'})
+  // The engine child reaches the relay memory ledger through the delivery socket.
+  const ledger=await serveTestLedger(root)
   let telegramCalls=0
   relay.bot.api.config.use(async()=>{telegramCalls++;return {ok:true,result:{message_id:1}} as never})
   const owned=await owner(root), secret=token()
   const binding=(await relay.applicationChannel.bindings.register('app',secret,owned))!
   const drain=setInterval(()=>void relay.drainOutbox(),10)
-  t.after(async()=>{clearInterval(drain);await relay.stop();EXECUTOR_REGISTRY.codex=original;await rm(root,{recursive:true,force:true})})
+  t.after(async()=>{clearInterval(drain);await relay.stop();EXECUTOR_REGISTRY.codex=original;await ledger.stop();await rm(root,{recursive:true,force:true})})
   const first=await relay.applicationChannel.submit(binding.bindingId,{requestId:'one',scope:'program',text:'Hello from the app',context:{secret:'must-stay-out-of-prompt'}})
   await waitFor(async()=> (await new RunStore(root).get(first.id))?.status==='completed')
   const second=await relay.applicationChannel.submit(binding.bindingId,{requestId:'two',scope:'program',text:'Continue'})
@@ -137,8 +140,9 @@ if(result.status!==0){console.error(result.stderr);process.exit(1)};
   assert.deepEqual(resumeIds,[undefined,nativeId])
   assert.equal(telegramCalls,0)
   assert.ok(prompts[0].startsWith('Hello from the app'))
-  assert.ok(prompts[0].includes('[Application channel]'))
+  assert.ok(prompts[0].includes('[application scope "program"]'))
   assert.ok(!prompts[0].includes('must-stay-out-of-prompt'))
+  assert.ok(!prompts[0].includes('delegate'))
   assert.equal((await relay.applicationChannel.snapshot(binding.bindingId,second.id)).messages[0].text,'Fixture engine reply')
 })
 
@@ -302,7 +306,7 @@ test('generic attachments stage after auth, preserve literal comments and reject
   const input={requestId:'image',scope:'chat',followOwner:true,text:'  /goal literal\n comment  ',attachment:{name:'image.png',data:Buffer.from('89504e470d0a1a0a','hex').toString('base64')}}
   assert.equal((await post(input,'bad')).status,401)
   const {readdir,stat}=await import('node:fs/promises')
-  await assert.rejects(readdir(join(root,'inbox')),/ENOENT/)
+  await assert.rejects(readdir(join(root,'attachments')),/ENOENT/)
   for (const [name,bytes] of [['image.png',Buffer.from('89504e470d0a1a0a','hex')],['file.pdf',Buffer.from('%PDF-1.4\nfixture')],['notes.md',Buffer.from('# Fixture')]] as const) {
     const body={...input,requestId:name,attachment:{name,data:bytes.toString('base64')}}
     const response=await post(body);assert.equal(response.status,202)
@@ -311,12 +315,12 @@ test('generic attachments stage after auth, preserve literal comments and reject
     assert.equal(run.ownerId,ownerId(owned))
     assert.equal(run.application?.inputText,input.text)
     assert.ok(run.texts[0].endsWith(`Caption: ${input.text}`))
-    const path=run.texts[0].match(/staged at (inbox\/[^ ]+)/)![1]
-    assert.deepEqual(await readFile(join(root,path)),bytes)
-    assert.equal((await stat(join(root,path))).mode & 0o777,0o600)
-    const before=(await readdir(join(root,'inbox'))).length
+    const path=run.texts[0].match(/staged at (\/[^ ]+)/)![1]
+    assert.deepEqual(await readFile(path),bytes)
+    assert.equal((await stat(path)).mode & 0o777,0o600)
+    const before=(await readdir(join(root,'attachments'))).length
     assert.equal((await post(body)).status,202)
-    assert.equal((await readdir(join(root,'inbox'))).length,before)
+    assert.equal((await readdir(join(root,'attachments'))).length,before)
     assert.equal((await post({...body,text:'changed'})).status,409)
     assert.equal((await post({...body,attachment:{name,data:Buffer.from('changed').toString('base64')}})).status,409)
     assert.equal((await fetch(`http://127.0.0.1:${address.port}/v1/runs/${snapshot.id}`,{headers:{Authorization:`Bearer ${other}`}})).status,404)
@@ -326,12 +330,56 @@ test('generic attachments stage after auth, preserve literal comments and reject
   const invalidActivation=await post({...input,requestId:'invalid-activation',followOwner:false,activateTelegram:true,scope:'new-scope',attachment:{name:'x.exe',data:Buffer.from('text').toString('base64')}})
   assert.equal(invalidActivation.status,400)
   assert.deepEqual((await control.status()).activeSession,priorSession)
-  const before=(await readdir(join(root,'inbox'))).length
+  const before=(await readdir(join(root,'attachments'))).length
   for (const attachment of [{name:'x.exe',data:Buffer.from('text').toString('base64')},{name:'x.txt',data:'%%%invalid'},{name:'x.txt',data:Buffer.alloc(10*1024*1024+1,65).toString('base64')}]) {
     assert.equal((await post({...input,requestId:'bad',attachment})).status,400)
   }
-  assert.equal((await readdir(join(root,'inbox'))).length,before)
+  assert.equal((await readdir(join(root,'attachments'))).length,before)
   await channel.bindings.register('web',null,owned)
   await assert.rejects(channel.submit(binding.bindingId,{...input,requestId:'revoked'}),/revoked/)
-  assert.equal((await readdir(join(root,'inbox'))).length,before)
+  assert.equal((await readdir(join(root,'attachments'))).length,before)
+})
+
+test('shareTelegram bindings list Telegram intake and admit one run with context', async t => {
+  const root=await mkdtemp(join(tmpdir(),'ez-app-telegram-'))
+  const control=new ControlStore(root,1000), runs=new RunStore(root)
+  await control.requestPairing(42,42); await control.approveOwner(42)
+  const owned=(await control.status()).owner!
+  const channel=new ApplicationChannel({controlDir:root,initial:initialPreset('codex'),wake:()=>{},cancel:async()=>{},createTelegramPairing:async()=>{throw new Error('unavailable')},telegramAvailable:()=>false})
+  t.after(async()=>{await channel.stop();await rm(root,{recursive:true,force:true})})
+  const sharedToken=token(), plainToken=token()
+  await channel.bindings.register('tg-app',sharedToken,owned,true)
+  await channel.bindings.register('plain',plainToken,owned)
+  const address=await channel.listen(0) as {port:number}
+  const url=`http://127.0.0.1:${address.port}`
+  const get=(bearer:string)=>fetch(url+'/v1/runs',{headers:{Authorization:`Bearer ${bearer}`}})
+  const attach=(id:string,bearer:string,body:unknown)=>fetch(url+`/v1/runs/${id}/application`,{method:'POST',headers:{Authorization:`Bearer ${bearer}`},body:JSON.stringify(body)})
+  const telegram=await runs.create({id:'tg_intake_1',chatId:42,telegramUserId:42,texts:['Attach the session'],ownerId:ownerId(owned),ownerEpoch:ownerEpoch(owned)})
+  assert.equal(telegram.application,undefined)
+  const listed=await (await get(sharedToken)).json() as {runs:{id:string;scope:string}[]}
+  assert.ok(listed.runs.some(run=>run.id==='tg_intake_1' && run.scope==='telegram'))
+  const hidden=await (await get(plainToken)).json() as {runs:{id:string}[]}
+  assert.ok(!hidden.runs.some(run=>run.id==='tg_intake_1'))
+  assert.equal((await attach('tg_intake_1',plainToken,{context:{aifit:{capability:'x'}}})).status,403)
+  assert.equal((await attach('tg_intake_1',sharedToken,{context:'nope'})).status,400)
+  assert.equal((await attach('tg_nope',sharedToken,{context:{}})).status,404)
+  const admitted=await attach('tg_intake_1',sharedToken,{context:{aifit:{capability:'granted'}}})
+  assert.equal(admitted.status,200)
+  assert.deepEqual(await admitted.json(),{id:'tg_intake_1',scope:'telegram',status:'queued'})
+  const stored=await runs.get('tg_intake_1')
+  const storedContext=stored?.telegramApplication?.context as {aifit?:{capability?:string}}|undefined
+  assert.equal(storedContext?.aifit?.capability,'granted')
+  assert.equal(stored?.application,undefined,'owner delivery routing is untouched')
+  const retrySame=await attach('tg_intake_1',sharedToken,{context:{aifit:{capability:'granted'}}})
+  assert.equal(retrySame.status,200)
+  assert.equal((await attach('tg_intake_1',sharedToken,{context:{aifit:{capability:'changed'}}})).status,409)
+  const stranger=await runs.create({id:'tg_stranger_1',chatId:43,telegramUserId:43,texts:['Not the owner'],ownerId:ownerId(owned),ownerEpoch:ownerEpoch(owned)})
+  const stillHidden=await (await get(sharedToken)).json() as {runs:{id:string}[]}
+  assert.ok(!stillHidden.runs.some(run=>run.id===stranger.id))
+  assert.equal((await attach(stranger.id,sharedToken,{context:{}})).status,400)
+  const plain=await runs.create({id:'r_plain_1',texts:['No telegram origin'],ownerId:ownerId(owned),ownerEpoch:ownerEpoch(owned)})
+  assert.equal((await attach(plain.id,sharedToken,{context:{}})).status,404)
+  const finished=await runs.create({id:'tg_finished_1',chatId:42,telegramUserId:42,texts:['Done already'],ownerId:ownerId(owned),ownerEpoch:ownerEpoch(owned)})
+  await runs.patch(finished.id,{status:'completed'})
+  assert.equal((await attach(finished.id,sharedToken,{context:{}})).status,409)
 })

package/test/application-only.test.ts

@@ -20,12 +20,10 @@ const waitFor = async (condition: () => Promise<boolean>) => {
   throw new Error('Timed out')
 }
 
-test('application-only mode explicitly requires native listener and ignores bot credentials', () => {
-  assert.throws(()=>loadConfig({}), /TELEGRAM_BOT_TOKEN/)
-  assert.throws(()=>loadConfig({EZ_TELEGRAM_ENABLED:'false'}), /EZ_APPLICATION_PORT/)
-  assert.throws(()=>loadConfig({EZ_TELEGRAM_ENABLED:'no'}), /true or false/)
-  assert.throws(()=>loadConfig({EZ_TELEGRAM_ENABLED:'false',EZ_APPLICATION_PORT:'8110',EZ_CHANNEL_BACKEND_URL:'http://backend',EZ_CHANNEL_BACKEND_TOKEN:'secret'}), /native Ez executor/)
-  const config=loadConfig({EZ_TELEGRAM_ENABLED:'false',EZ_APPLICATION_PORT:'8110',TELEGRAM_BOT_TOKEN:'unused-secret'})
+test('application-only mode is inferred from the absence of a bot token and requires a native listener', () => {
+  assert.throws(()=>loadConfig({}), /EZ_APPLICATION_PORT/)
+  assert.throws(()=>loadConfig({EZ_APPLICATION_PORT:'8110',EZ_CHANNEL_BACKEND_URL:'http://backend',EZ_CHANNEL_BACKEND_TOKEN:'secret'}), /native Ez executor/)
+  const config=loadConfig({EZ_APPLICATION_PORT:'8110'})
   assert.equal(config.telegramBotToken,'')
   assert.equal(config.telegramEnabled,false)
 })
@@ -36,8 +34,8 @@ test('administrator bootstrap is explicit, local-only and cannot replace identit
   const token=join(root,'token'); await writeFile(token,'x'.repeat(48),{mode:0o600})
   const cli=fileURLToPath(new URL('../bin/ezenciel-agents-application.mjs',import.meta.url))
   const args=[cli,'--id','app','--token-file',token,'--owner','42']
-  const env={...process.env,EZ_CONTROL_DIR:root,EZ_RUN_ID:'',EZ_TELEGRAM_ENABLED:'false'}
-  assert.notEqual(spawnSync(process.execPath,args,{env:{...env,EZ_TELEGRAM_ENABLED:'true'}}).status,0)
+  const env={...process.env,EZ_CONTROL_DIR:root,EZ_RUN_ID:'',TELEGRAM_BOT_TOKEN:''}
+  assert.notEqual(spawnSync(process.execPath,args,{env:{...env,TELEGRAM_BOT_TOKEN:'fixture'}}).status,0)
   assert.notEqual(spawnSync(process.execPath,args,{env:{...env,EZ_RUN_ID:'r_agent'}}).status,0)
   assert.equal((await new ControlStore(root,1000).status()).owner,null)
   const invalidToken=join(root,'invalid-token');await writeFile(invalidToken,'short')
@@ -64,7 +62,7 @@ test('botless daemon executes application turn and rejects Telegram-origin work/
   const purpose=join(root,'purpose.md');await writeFile(purpose,'Fixture application agent\n');await initializeWorkspace(root,purpose)
   const portServer=createServer();await new Promise<void>(r=>portServer.listen(0,'127.0.0.1',r))
   const port=(portServer.address() as {port:number}).port;await new Promise<void>(r=>portServer.close(()=>r()))
-  const config=loadConfig({EZ_TELEGRAM_ENABLED:'false',EZ_APPLICATION_PORT:String(port),EZ_CONTROL_DIR:root,EZ_AGENT_WORKSPACE:root,EZ_EXECUTOR_CLI:'codex'})
+  const config=loadConfig({EZ_APPLICATION_PORT:String(port),EZ_CONTROL_DIR:root,EZ_AGENT_WORKSPACE:root,EZ_EXECUTOR_CLI:'codex'})
   const native='11111111-1111-1111-1111-111111111111', fixture=join(root,'engine.mjs')
   await writeFile(fixture,`import {spawnSync} from 'node:child_process';if(process.env.TELEGRAM_BOT_TOKEN)throw Error('secret leak');console.log(JSON.stringify({type:'thread.started',thread_id:${JSON.stringify(native)}}));const r=spawnSync(process.execPath,[${JSON.stringify(fileURLToPath(new URL('../bin/ezenciel-agents-message.mjs',import.meta.url)))},'--text','Application reply'],{env:process.env});process.exit(r.status);`)
   const original=EXECUTOR_REGISTRY.codex,require=createRequire(import.meta.url)
@@ -91,12 +89,15 @@ test('botless daemon executes application turn and rejects Telegram-origin work/
   assert.equal((await runs.get(legacy.id))?.status,'queued')
 })
 
-test('Docker health accepts application readiness only with explicit botless configuration', async t => {
+test('Docker health accepts application readiness when the agent has no bot', async t => {
   const root=await mkdtemp(join(tmpdir(),'ez-app-only-health-'))
   t.after(()=>rm(root,{recursive:true,force:true}))
-  await writeFile(join(root,'heartbeat.json'),JSON.stringify({at:Date.now(),polling:false,applicationOnly:true}))
+  await writeFile(join(root,'heartbeat.json'),JSON.stringify({at:Date.now(),polling:false,applicationOnly:true,telegramConfigured:false}))
   const command=fileURLToPath(new URL('../docker/healthcheck.mjs',import.meta.url))
   const env={...process.env,EZ_HEALTH_RELAY_CONTROL_DIR:root,EZ_EXECUTOR_TRANSPORT:'local'}
-  assert.equal(spawnSync(process.execPath,[command],{env:{...env,EZ_TELEGRAM_ENABLED:'false'}}).status,0)
-  assert.notEqual(spawnSync(process.execPath,[command],{env:{...env,EZ_TELEGRAM_ENABLED:'true'}}).status,0)
+  assert.equal(spawnSync(process.execPath,[command],{env}).status,0)
+  await writeFile(join(root,'heartbeat.json'),JSON.stringify({at:Date.now(),polling:false,applicationOnly:false,telegramConfigured:false}))
+  assert.notEqual(spawnSync(process.execPath,[command],{env}).status,0)
+  await writeFile(join(root,'heartbeat.json'),JSON.stringify({at:Date.now(),polling:false,applicationOnly:true,telegramConfigured:true}))
+  assert.notEqual(spawnSync(process.execPath,[command],{env}).status,0)
 })

package/test/channel-backend.test.ts

@@ -43,7 +43,6 @@ test('structured photo transport and deterministic reply recovery', async () =>
 test('backend dispatch keeps owner/private gate and never starts a CLI', async () => {
   const { createRelay } = await import('../src/index.js')
   const { ControlStore } = await import('../src/control-state.js')
-  const { recoverInterruptedRuns } = await import('../docker/recovery.js')
   const root = await mkdtemp(join(tmpdir(), 'channel-gate-'))
   const originalFetch = globalThis.fetch
   let calls = 0
@@ -68,16 +67,14 @@ test('backend dispatch keeps owner/private gate and never starts a CLI', async (
     assert.equal(calls, 1)
     const store = new RunStore(root)
     assert.equal((await store.get('tg_3'))?.status, 'completed')
-    await store.patch('tg_3', { status: 'running' })
-    await recoverInterruptedRuns(root, true)
-    assert.equal((await store.get('tg_3'))?.status, 'queued')
+    await store.patch('tg_3', { status: 'running', backendSubmitted: true })
     const cancel = update(4, 42); cancel.message.text = '/cancel'
     await relay.bot.handleUpdate(cancel)
-    assert.equal((await store.get('tg_3'))?.status, 'queued', 'cancel must retain submitted operation polling')
+    assert.equal((await store.get('tg_3'))?.status, 'running', 'cancel must retain submitted operation polling')
   } finally { await relay.stop(); globalThis.fetch = originalFetch; await rm(root, { recursive: true, force: true }) }
 })
 
-test('backend mode cannot dispatch restricted, external, scheduled or update runs', async () => {
+test('backend mode cannot dispatch restricted, external or scheduled runs', async () => {
   const { createRelay } = await import('../src/index.js')
   const { ControlStore } = await import('../src/control-state.js')
   const root = await mkdtemp(join(tmpdir(), 'channel-authority-'))
@@ -92,7 +89,6 @@ test('backend mode cannot dispatch restricted, external, scheduled or update run
     await runs.create({ ...common, id: 'restricted', taskId: `task_${'a'.repeat(32)}` })
     await runs.create({ ...common, id: 'external', external: { sourceId: 'fixture', bindingId: 'binding', eventIds: ['1'] } })
     await runs.create({ ...common, id: 'scheduled', scheduled: { id: 's', revision: 'r', dueAt: new Date().toISOString(), pairedAt: owner.pairedAt } })
-    await runs.create({ ...common, id: 'r_update_fixture' })
     await relay.drainSources()
     assert.equal(calls, 0); assert.equal(launches, 0)
     assert.ok((await runs.list()).every(run => run.status === 'failed'))

package/test/channel-delivery.test.ts

@@ -8,11 +8,14 @@ import {ControlStore} from '../src/control-state.js'
 import {RunStore} from '../src/runs.js'
 import {authorizeDeliveryContext,captureDeliveryContext} from '../src/delivery-context.mjs'
 import {nativeTasks,nativeTaskBinding} from '../src/plugins/native-tasks.mjs'
+import {serveTestLedger} from './helpers/ledger.js'
 
 test('authenticated connection sends text and files through ordinary outbox receipts without a native run',async()=>{
   const root=await fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(),'ez-channel-delivery-'))),workspace=path.join(root,'mind'),controlDir=path.join(root,'control'),home=path.join(root,'tools'),hostConfig=path.join(root,'host-executor.json')
   for(const dir of [workspace,controlDir,home])await fs.mkdir(dir)
   const relay=createRelay({controlDir,workspace,pairingTtlMs:1000,executorTimeoutMs:1000,executorCli:'grok',telegramBotToken:'fixture'},async()=>{throw Error('Must not launch native execution')})
+  // The message CLI child reaches the relay memory ledger through the delivery socket.
+  const ledger=await serveTestLedger(controlDir)
   const calls:string[]=[];relay.bot.api.config.use(async(_prev,method)=>{calls.push(method);return {ok:true,result:{message_id:42}} as never})
   try {
     await fs.writeFile(path.join(home,'config.json'),JSON.stringify({schemaVersion:1,workspace,hostConfig}))
@@ -38,7 +41,7 @@ test('authenticated connection sends text and files through ordinary outbox rece
     await relay.drainOutbox();assert.equal(calls.length,2);await assert.rejects(store.waitForDelivery(queued.id),/revoked/)
     await assert.rejects(nativeTasks(home,['--text','denied'],{command:'message',deliveryContext:context}),/revoked/)
     await assert.rejects(store.ownerDeliveryReceipt(context,queued.id),/revoked/)
-  } finally {await relay.stop();await fs.rm(root,{recursive:true,force:true})}
+  } finally {await relay.stop();await ledger.stop();await fs.rm(root,{recursive:true,force:true})}
 })
 test('delivery authority cannot revive after Telegram relink or same-time owner replacement',async t=>{
   const root=await fs.mkdtemp(path.join(os.tmpdir(),'ez-channel-delivery-epoch-'))

package/test/channel-owner.test.ts

@@ -16,6 +16,7 @@ import { ownsRun, isOwner } from '../src/identity.js'
 import { createRelay } from '../src/index.js'
 import { EXECUTOR_REGISTRY } from '../src/executor.js'
 import { loadConfig } from '../src/config.js'
+import { serveTestLedger } from './helpers/ledger.js'
 
 const secret = () => randomBytes(32).toString('base64url')
 const waitFor = async (check: () => Promise<boolean>) => {
@@ -87,13 +88,15 @@ test('web owner uses the standard schedule CLI, executor and outbox with Telegra
     if(!scheduled){const r=spawnSync(process.execPath,[${JSON.stringify(scheduleCli)},'create','followup','--now','--name','Followup','--text','Finish the requested work'],{env:process.env,encoding:'utf8'});if(r.status)throw Error(r.stderr)}
     const r=spawnSync(process.execPath,[${JSON.stringify(messageCli)},'--text',scheduled?'Scheduled reply':'Chat reply'],{env:process.env,encoding:'utf8'});if(r.status)throw Error(r.stderr);`)
   EXECUTOR_REGISTRY.grok={...original,command:process.execPath,buildArgs:()=>['--import',require.resolve('tsx'),fixture]}
-  const config=loadConfig({EZ_TELEGRAM_ENABLED:'false',EZ_APPLICATION_PORT:'8787',EZ_CONTROL_DIR:root,EZ_AGENT_WORKSPACE:root,EZ_EXECUTOR_CLI:'grok'})
+  const config=loadConfig({EZ_APPLICATION_PORT:'8787',EZ_CONTROL_DIR:root,EZ_AGENT_WORKSPACE:root,EZ_EXECUTOR_CLI:'grok'})
   const relay=createRelay(config), control=new ControlStore(root,60000), runs=new RunStore(root)
+  // Engine children reach the relay memory ledger through the delivery socket.
+  const ledger=await serveTestLedger(root)
   const owner=await control.registerOwner('web-owner'),token=secret()
   const binding=(await relay.applicationChannel.bindings.register('web',token,owner))!
   const address=await relay.applicationChannel.listen(0) as {port:number}
   const timer=setInterval(()=>{void relay.drainSources();void relay.drainOutbox()},25)
-  t.after(async()=>{clearInterval(timer);await relay.stop();EXECUTOR_REGISTRY.grok=original;await rm(root,{recursive:true,force:true})})
+  t.after(async()=>{clearInterval(timer);await relay.stop();EXECUTOR_REGISTRY.grok=original;await ledger.stop();await rm(root,{recursive:true,force:true})})
   const first=await relay.applicationChannel.submit(binding.bindingId,{requestId:'chat',scope:'main',text:'Schedule a followup'})
   await waitFor(async()=> (await runs.get(first.id))?.status==='completed')
   await waitFor(async()=> (await runs.list()).some(r=>r.scheduled && r.status==='completed'))
@@ -141,7 +144,7 @@ for (const mode of ['owner','web','telegram']) test(`${mode} revocation stops it
   const control=new ControlStore(root,60000),runs=new RunStore(root),scheduler=new Scheduler(root)
   await control.requestPairing(42,42)
   const owner=await control.approveOwner(42)
-  const relay=createRelay(loadConfig({TELEGRAM_BOT_TOKEN:'synthetic',EZ_CONTROL_DIR:root,EZ_AGENT_WORKSPACE:root,EZ_EXECUTOR_CLI:'grok'}),async()=>({child:spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{detached:true,stdio:'pipe'}),stdout:'',cleanup:async()=>{}}))
+  const relay=createRelay(loadConfig({TELEGRAM_BOT_TOKEN:'110201543:AAHdqTcvCH1vGWJxfSeofSAs0K5PALDsY',EZ_CONTROL_DIR:root,EZ_AGENT_WORKSPACE:root,EZ_EXECUTOR_CLI:'grok'}),async()=>({child:spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{detached:true,stdio:'pipe'}),stdout:'',cleanup:async()=>{}}))
   relay.bot.api.config.use(async()=>({ok:true,result:true}) as never)
   t.after(async()=>{await relay.stop();await rm(root,{recursive:true,force:true})})
   if (mode==='telegram') {

package/test/codex-context.test.ts

@@ -110,11 +110,11 @@ if(q.method==='turn/start'){send({id:q.id,result:{turn:{id:'one'}}});send({metho
 send({id:q.id,result:q.method==='thread/goal/get'?{goal:null}:{}});});setInterval(()=>{},1000);
 `,{mode:0o700})
   process.env.HOME=root;process.env.PATH=bin+path.delimiter+priorPath
-  await assert.rejects(startExecutorJob(['test'],{workspace:root,controlDir,binDir:bin,cli:'codex',runId:'r_schedule_/../../escape',timeoutMs:0}),/Invalid native task run ID/)
+  await assert.rejects(startExecutorJob(['test'],{workspace:root,controlDir,binDir:bin,cli:'codex',runId:'r_schedule_/../../escape',timeoutMs:0,nativeSession:true}),/Invalid native task run ID/)
   await ownerRun(controlDir, 'r_pair_fixture')
   await Promise.all(['r_schedule_one','r_schedule_two'].map(async runId=>{
    await ownerRun(controlDir, runId)
-   const job=await startExecutorJob(['test'],{workspace:root,controlDir,binDir:bin,cli:'codex',runId,timeoutMs:0})
+   const job=await startExecutorJob(['test'],{workspace:root,controlDir,binDir:bin,cli:'codex',runId,timeoutMs:0,nativeSession:true})
    assert.equal(await new Promise(resolve=>job.child.once('close',resolve)),0);await job.cleanup()
    const home=path.join(controlDir,'cli/codex/tasks',runId)
    assert.equal(JSON.parse(await readFile(path.join(home,'observed.json'),'utf8')).home,home)