@jc_stack/ez-agents 0.1.0-beta.46 → 0.1.0-beta.47

package/src/task-executor.ts

@@ -11,9 +11,9 @@ import { executorEnvironment, executorInvocation, terminateJob, type ExecutorOpt
 
 // This adapter is deliberately version-pinned: a new native tool default needs
 // a fresh tool-inventory audit before external correspondence can use it.
-export const TASK_CODEX_VERSION = '0.153.4'
+export const TASK_CODEX_VERSION = '0.160.0'
 export const taskDisabledFeatures = ['apps', 'browser_use', 'computer_use', 'in_app_browser', 'image_generation',
-  'memories', 'multi_agent', 'multi_agent_v2', 'hooks', 'shell_tool', 'unified_exec', 'code_mode', 'code_mode_host',
+  'memories', 'goals', 'multi_agent', 'multi_agent_v2', 'hooks', 'shell_tool', 'unified_exec', 'code_mode', 'code_mode_host',
   'skill_search', 'skill_mcp_dependency_install', 'tool_suggest', 'workspace_dependencies', 'view_image']
 // Model catalog defaults can override disabled feature flags (for example,
 // code-only tools and v2 collaboration). Use the audited direct-tool surface.

package/src/updates/runtime.mjs

@@ -1,3 +1,4 @@
+import { latestCodexVersion } from '../install-tools.mjs';
 import { sharedIdentity } from '../plugins/shared.mjs';
 import * as fs from 'node:fs/promises';
 import { createWriteStream } from 'node:fs';
@@ -113,13 +114,15 @@ export async function perform(home,job,hooks) {
       await run(process.execPath,['--import',path.join(root,'node_modules/tsx/dist/loader.mjs'),path.join(root,'bin/ezenciel-agents.mjs'),'--version'],{cwd:root});
       try { await replaceGuidance(root, config.workspace, run); }
       catch(error) { console.error(`Workspace guidance replacement failed; upgrade continues: ${error.message}`); }
-      // Preserve operator-owned native CLI pins from the effective deployment.
-      // Building only the package defaults silently downgrades those clients.
+      // Resolve managed Codex at activation; old deployment pins cannot override latest.
+      // Preserve unrelated operator build arguments.
       const deployment=JSON.parse(await run('docker',[...relayArgs(config),'config','--format','json'],{stdoutOnly:true}));
       const args=deployment.services?.relay?.build?.args||{};
       if(typeof args!=='object'||Array.isArray(args))throw Error('Invalid relay build arguments');
-      const buildArgs=Object.keys(args).sort().flatMap(key=>{
-        const value=args[key];
+      job.codexVersion=await latestCodexVersion(run,job.packageManager);await save();
+      const effective={...args,CODEX_CLI_VERSION:job.codexVersion};
+      const buildArgs=Object.keys(effective).sort().flatMap(key=>{
+        const value=effective[key];
         if(!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)||typeof value!=='string'||value.includes('\0'))throw Error('Unresolved relay build argument');
         return ['--build-arg',`${key}=${value}`];
       });

package/src/updates/supervisor.mjs

@@ -38,6 +38,20 @@ export async function idle(control) {
   const status=await callDeliverySocket(path.join(control,'delivery.sock'),{op:'status'},2000).catch(()=>null);
   return !status||status.running===0;
 }
+// Pause admission only after work is idle, and release it if a turn raced the
+// check. A queued upgrade must never hold the owner's chat behind a long turn.
+export async function withIdleUpgrade(control,job,signal,apply,{isIdle=idle,wait=sleep}={}) {
+  if(signal.aborted||!await isIdle(control))return;
+  const pause=path.join(control,'upgrade-pause.json');
+  await atomic(pause,{id:job.id});
+  try {
+    for(let n=0;n<3;n++) {
+      await wait(500);
+      if(signal.aborted||!await isIdle(control))return;
+    }
+    if(!signal.aborted)return await apply();
+  } finally {await fs.rm(pause,{force:true});}
+}
 export async function queueAutomatic(home,available) {
   const existing=await jobs(home);
   if(existing.some(job=>['queued','applying','recovery-required'].includes(job.status)))return null;
@@ -103,19 +117,15 @@ export async function supervise(deployment,signal,{discover=check}={}) {
       if(!isolated && child?.exitCode!==null&&child?.exitCode!==undefined)throw Error('Host transport exited; supervisor service should restart');
       const pending=(await jobs(home)).find(j=>j.status==='queued');
       if(pending) {
-        await atomic(pause,{id:pending.id});
-        // Relay admission is paused; drain the requesting turn and any already-claimed job.
-        let quiet=0;
-        while(!signal.aborted&&quiet<3){quiet=await idle(agent.controlDir)?quiet+1:0;await sleep(500);}
-        if(signal.aborted)break;
-        let result;
-        try {
-          result=await locked(home,async()=>{const latest=await read(path.join(jobPath(home,pending.id),'job.json'));return perform(home,latest,{stopHost,startHost});});
-        } catch(error) {
-          // A pre-switch rejection is terminal. Applying jobs keep their journal for recovery.
-          const latest=await read(path.join(jobPath(home,pending.id),'job.json'));
-          if(latest.status==='queued'){latest.status='failed';latest.error=error.message;await atomic(path.join(jobPath(home,pending.id),'job.json'),latest);}else throw error;
-        } finally {await fs.rm(pause,{force:true});}
+        const result=await withIdleUpgrade(agent.controlDir,pending,signal,async()=>{
+          try {
+            return await locked(home,async()=>{const latest=await read(path.join(jobPath(home,pending.id),'job.json'));return perform(home,latest,{stopHost,startHost});});
+          } catch(error) {
+            // A pre-switch rejection is terminal. Applying jobs keep their journal for recovery.
+            const latest=await read(path.join(jobPath(home,pending.id),'job.json'));
+            if(latest.status==='queued'){latest.status='failed';latest.error=error.message;await atomic(path.join(jobPath(home,pending.id),'job.json'),latest);}else throw error;
+          }
+        });
         if(result?.status==='completed') {
           if(pending.target==='main')return;
           nextCheck=0;

package/test/ai.test.ts

@@ -4,13 +4,49 @@ 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, readOpencodeModels, readCuratedModels, validateSelection, opencodeProviderAllowlist } from '../src/ai.js'
+import { initialPreset, chatPreset, readModels, readCodexCatalog, 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'
 import { executionDefaults } from '../src/model-policy.js'
 import type { Update } from 'grammy/types'
 
+const noCodex = async (): Promise<string> => { throw new Error('Native discovery unavailable') }
+
+test('Codex discovery refreshes through the bound native CLI without curated overrides or a turn', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'ez-native-catalog-'))
+  const previousToken = process.env.TELEGRAM_BOT_TOKEN
+  try {
+    process.env.TELEGRAM_BOT_TOKEN = 'must-not-reach-native-client'
+    await writeFile(join(home, 'models_cache.json'), JSON.stringify({ models: [
+      { slug: 'old-model', visibility: 'list' },
+    ] }))
+    const calls: string[][] = []
+    const run = async (args: string[], env: NodeJS.ProcessEnv) => {
+      calls.push(args)
+      assert.equal(env.CODEX_HOME, home)
+      assert.equal(env.TELEGRAM_BOT_TOKEN, undefined)
+      return JSON.stringify({ models: [
+        { slug: 'new-model', display_name: 'New model', visibility: 'list',
+          supported_reasoning_levels: [{ effort: 'ultra' }], model_messages: 'untrusted', api_key: 'secret' },
+        { slug: 'hidden-model', visibility: 'hide' },
+      ] })
+    }
+    assert.deepEqual(await readModels(home, async cli => cli === 'codex', home,
+      undefined, undefined, undefined, undefined, run), [
+      { cli: 'codex', model: 'new-model', name: 'New model', efforts: ['ultra'] },
+    ])
+    assert.deepEqual(calls, [['debug', 'models']])
+    for (const unavailable of [noCodex, async () => 'not json', async () => '{"models":[]}']) {
+      assert.deepEqual(await readCodexCatalog(home, unavailable), { models: [{ slug: 'old-model', visibility: 'list' }] })
+    }
+  } finally {
+    if (previousToken === undefined) delete process.env.TELEGRAM_BOT_TOKEN
+    else process.env.TELEGRAM_BOT_TOKEN = previousToken
+    await rm(home, { recursive: true, force: true })
+  }
+})
+
 test('same-client model and default changes preserve history; provider changes require a fresh conversation', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-ai-model-switch-'))
   try {
@@ -173,7 +209,7 @@ test('model catalog projects native metadata only, excluding hidden entries and
         supported_reasoning_levels: [{ effort: 'high' }, { effort: 'xhigh' }, { effort: 'max' }] },
       { slug: 'hidden-model', visibility: 'hide' },
     ] }))
-    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex'), [
+    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex', undefined, undefined, undefined, undefined, undefined, noCodex), [
       { cli: 'codex', model: 'fixture-model', name: 'Fixture', efforts: ['medium'] },
       { cli: 'codex', model: 'gpt-5.6-luna', name: 'Luna', efforts: ['high', 'xhigh', 'max'] },
     ])
@@ -258,7 +294,7 @@ test('model catalog can read an agent-bound Codex home', async () => {
       { slug: 'gpt-6-astra', display_name: 'GPT-6 Astra', visibility: 'list',
         supported_reasoning_levels: [{ effort: 'low' }] },
     ] }))
-    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex', codexHome), [
+    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex', codexHome, undefined, undefined, undefined, undefined, noCodex), [
       { cli: 'codex', model: 'gpt-6-astra', name: 'GPT-6 Astra', efforts: ['low'] },
     ])
   } finally {
@@ -270,7 +306,10 @@ 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-'))
+  const previousPath = process.env.PATH
   try {
+    await writeFile(join(codexHome, 'codex'), '#!/bin/sh\nexit 1\n', { mode: 0o700 })
+    process.env.PATH = `${codexHome}:${previousPath ?? ''}`
     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' }] },
@@ -298,6 +337,7 @@ test('Choose AI lists the agent-bound Codex home instead of only the desktop fal
     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 {
+    process.env.PATH = previousPath
     await rm(dir, { recursive: true, force: true })
     await rm(codexHome, { recursive: true, force: true })
   }
@@ -522,7 +562,7 @@ test('model catalog merges user-curated entries ahead of discovered ones', async
     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)
+      noRunner, undefined, undefined, control, noCodex)
     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: [] },
@@ -538,7 +578,7 @@ test('model catalog merges user-curated entries ahead of discovered ones', async
     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), [
+      noRunner, undefined, undefined, control, noCodex), [
       { cli: 'codex', model: 'fixture-model', name: 'Fixture', efforts: ['medium'] },
     ])
   } finally {

package/test/channel-owner.test.ts

@@ -85,7 +85,7 @@ test('web owner uses the standard schedule CLI, executor and outbox with Telegra
   await writeFile(fixture,`import {spawnSync} from 'node:child_process';
     if(process.env.TELEGRAM_BOT_TOKEN)throw Error('secret leak');
     const scheduled=process.env.EZ_RUN_ID.startsWith('r_schedule_');
-    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)}
+    if(!scheduled){const r=spawnSync(process.execPath,[${JSON.stringify(scheduleCli)},'create','followup','--model','fixture-model','--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_APPLICATION_PORT:'8787',EZ_CONTROL_DIR:root,EZ_AGENT_WORKSPACE:root,EZ_EXECUTOR_CLI:'grok'})
@@ -151,7 +151,7 @@ for (const mode of ['owner','web','telegram']) test(`${mode} revocation stops it
     await runs.create({id:'r_telegram',chatId:42,telegramUserId:42,ownerId:ownerId(owner),ownerEpoch:ownerEpoch(owner),texts:['Wait'],execution:await control.captureChoice(initialPreset('grok'))})
   } else {
     const binding=(await relay.applicationChannel.bindings.register('web',secret(),owner))!
-    await scheduler.save({id:'wait',name:'Wait',text:'Wait',enabled:true,trigger:{at:new Date(Date.now()+1000).toISOString()},owner,delivery:{bindingId:binding.bindingId,scope:'main'},execution:await control.captureChoice(initialPreset('grok'))})
+    await scheduler.save({id:'wait',name:'Wait',text:'Wait',enabled:true,trigger:{at:new Date(Date.now()+1000).toISOString()},owner,delivery:{bindingId:binding.bindingId,scope:'main'},execution:await control.captureChoice({...initialPreset('grok'),model:'fixture-model'})})
     await scheduler.tick(owner,runs,Date.now()+2000)
   }
   await relay.drainSources()

package/test/desktop-bridge.test.ts

@@ -52,7 +52,8 @@ test('codex-gui is a distinct preset and catalog entry', async () => {
     await writeFile(path.join(home, '.codex/models_cache.json'), JSON.stringify({ models: [
       { slug: 'fixture-model', display_name: 'Fixture', visibility: 'list', supported_reasoning_levels: [{ effort: 'medium' }] },
     ] }))
-    const models = await readModels(home, async (cli) => cli === 'codex' || cli === 'codex-gui')
+    const models = await readModels(home, async (cli) => cli === 'codex' || cli === 'codex-gui', undefined, undefined, undefined, undefined, undefined,
+      async () => { throw new Error('Native discovery unavailable') })
     assert.ok(models.some((model) => model.cli === 'codex' && model.model === 'fixture-model'))
     assert.ok(models.some((model) => model.cli === 'codex-gui' && model.model === 'fixture-model'))
   } finally { await rm(home, { recursive: true, force: true }) }

package/test/failure.test.ts

@@ -100,7 +100,7 @@ test('failure capture, diagnosis, verified recovery and conditional quiet next t
  })
  try{
   await control.requestPairing(101,101);await control.approveOwner(101)
-  const owner=(await control.status()).owner!,execution=await control.captureChoice(initialPreset('grok')),start=Date.now()+2000
+  const owner=(await control.status()).owner!,execution=await control.captureChoice({...initialPreset('grok'),model:'fixture-model'}),start=Date.now()+2000
   await scheduler.save({id:'review',name:'Review failures',text:'Review failures',trigger:{everySeconds:60,start:new Date(start).toISOString()},when:'unreviewed-failures',enabled:true,owner,execution})
   await scheduler.tick(owner,runs,start)
   assert.equal((await runs.list()).length,0,'no model job for an empty inbox')
@@ -251,7 +251,7 @@ for (const intake of [true,false]) test(`relay shutdown terminates an in-flight
   await control.requestPairing(101,101);const owner=await control.approveOwner(101)
   if(intake) await relay.bot.handleUpdate({update_id:91,message:{message_id:91,date:0,text:'fixture',from:{id:101,is_bot:false,first_name:'Fixture'},chat:{id:101,type:'private',first_name:'Fixture'}}})
   else {
-   const scheduler=new Scheduler(dir),at=Date.now()+1000,execution=await control.captureChoice(initialPreset('grok'))
+   const scheduler=new Scheduler(dir),at=Date.now()+1000,execution=await control.captureChoice({...initialPreset('grok'),model:'fixture-model'})
    await scheduler.save({id:'fixture',name:'Fixture',text:'fixture',trigger:{at:new Date(at).toISOString()},enabled:true,owner,execution})
    await scheduler.tick(owner,runs,at)
   }
@@ -276,7 +276,7 @@ test('group members can inspect failures and wake review without exposing other
  const ledger=await serveTestLedger(dir);t.after(()=>ledger.stop())
  const runs=new RunStore(dir),control=new ControlStore(dir,900000),scheduler=new Scheduler(dir)
  await control.requestPairing(101,-123,'Fixture');const owner=await control.approveOwner(-123,true)
- const execution=await control.captureChoice(initialPreset('grok'))
+ const execution=await control.captureChoice({...initialPreset('grok'),model:'fixture-model'})
  await runs.create({id:'tg_1',chatId:-123,telegramUserId:202,texts:['failed'],execution})
  await runs.patch('tg_1',{status:'failed',endedAt:new Date().toISOString()})
  await runs.create({id:'tg_2',chatId:-124,telegramUserId:202,texts:['private'],execution})
@@ -343,7 +343,7 @@ test('failed reviewer readback exposes its stop through show, list and resume un
  const ledger=await serveTestLedger(dir);t.after(()=>ledger.stop())
  const control=new ControlStore(dir,1000),runs=new RunStore(dir),scheduler=new Scheduler(dir)
  await control.requestPairing(101,101);const owner=await control.approveOwner(101)
- const execution=await control.captureChoice(initialPreset('grok')),now=Date.now()+1000
+ const execution=await control.captureChoice({...initialPreset('grok'),model:'fixture-model'}),now=Date.now()+1000
  const s=await scheduler.save({id:'review',name:'Review',text:'Review failures',trigger:{everySeconds:60,start:new Date(now).toISOString()},when:'unreviewed-failures',enabled:true,owner,execution})
  await runs.create({id:'r_original',chatId:101,telegramUserId:101,texts:['Work'],execution});await runs.patch('r_original',{status:'failed'})
  await scheduler.tick(owner,runs,now)

package/test/host-executor.test.ts

@@ -265,13 +265,13 @@ test('one installed CLI executes two agent bindings with separate minds and sani
     await assert.rejects(serveHostExecutor({cli:'grok',agents},new AbortController().signal),/already running/)
     const directory=path.join(agents[0].controlDir,'host-executor')
     const runs=new RunStore(agents[0].controlDir)
-    await runs.create({id:'r_hold',chatId:101,telegramUserId:101,texts:['test'],scheduled:{id:'held',revision:'v1',dueAt:new Date().toISOString(),pairedAt:new Date().toISOString()}})
+    await runs.create({id:'r_hold',execution:{sessionId:crypto.randomUUID(),preset:{id:'fixture',name:'Fixture',cli:'grok',model:'fixture-model'}},chatId:101,telegramUserId:101,texts:['test'],scheduled:{id:'held',revision:'v1',dueAt:new Date().toISOString(),pairedAt:new Date().toISOString()}})
     await runs.patch('r_hold',{status:'running'})
-    await writeFile(path.join(directory,'r_hold.request.json'),JSON.stringify({texts:['test'],options:{cli:'grok'}}))
+    await writeFile(path.join(directory,'r_hold.request.json'),JSON.stringify({texts:['test'],options:{cli:'grok',model:'fixture-model'}}))
     for(let n=0;n<100;n++){try{await readFile(path.join(directory,'r_hold.process.json'));break}catch{await new Promise(r=>setTimeout(r,20))}}
-    await new RunStore(agents[0].controlDir).create({id:'r_schedule_queued',chatId:101,telegramUserId:101,texts:['test'],scheduled:{id:'shared',revision:'v1',dueAt:new Date().toISOString(),pairedAt:new Date().toISOString()}})
+    await new RunStore(agents[0].controlDir).create({id:'r_schedule_queued',execution:{sessionId:crypto.randomUUID(),preset:{id:'fixture',name:'Fixture',cli:'grok',model:'fixture-model'}},chatId:101,telegramUserId:101,texts:['test'],scheduled:{id:'shared',revision:'v1',dueAt:new Date().toISOString(),pairedAt:new Date().toISOString()}})
     await new RunStore(agents[0].controlDir).patch('r_schedule_queued',{status:'running'})
-    await writeFile(path.join(directory,'r_schedule_queued.request.json'),JSON.stringify({texts:['test'],options:{cli:'grok',sharedWorkspace:'/wrong'}}))
+    await writeFile(path.join(directory,'r_schedule_queued.request.json'),JSON.stringify({texts:['test'],options:{cli:'grok',model:'fixture-model',sharedWorkspace:'/wrong'}}))
     const otherDirectory=path.join(agents[1].controlDir,'host-executor')
     await ownerRun(agents[1].controlDir,'r_other_shared')
     await writeFile(path.join(otherDirectory,'r_other_shared.request.json'),JSON.stringify({texts:['test'],options:{cli:'grok'}}))

package/test/install-tools.test.mjs

@@ -79,19 +79,20 @@ test('isolated deployments need no host ledger endpoint',async t=>{
 });
 test('same-artifact build retries do not spawn a second Docker build and reuse verified completed image',async t=>{
   const home=await fixture(t),source=path.join(home,'source');await fs.mkdir(source);await fs.writeFile(path.join(source,'package.json'),'{}');
-  let started,finish,count=0;const running=new Promise(r=>started=r),held=new Promise(r=>finish=r);
-  const invoke=async(cmd,args)=>{if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);if(args[0]==='build'){count++;started();await held;}return 'sha256:fixture';};
+  let started,finish,count=0,latest='0.160.0';const running=new Promise(r=>started=r),held=new Promise(r=>finish=r);
+  const invoke=async(cmd,args)=>{if(cmd==='npm'&&args?.[0]==='view')return JSON.stringify(latest);if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);if(args[0]==='build'){count++;started();await held;}return 'sha256:fixture';};
   const first=build({home,source},invoke);await running;
   assert.equal((await build({home,source},invoke)).state,'busy-or-interrupted');assert.equal(count,1);
   finish();const result=await first;assert.equal(result.state,'completed');
   assert.equal((await build({home,source},invoke)).reused,true);assert.equal(count,1);
   await fs.writeFile(path.join(source,'package.json'),'{"changed":true}');await build({home,source},invoke);assert.equal(count,2);
+  latest='0.160.1';const newer=await build({home,source},invoke);assert.equal(count,3);assert.equal(newer.codexVersion,latest);assert.notEqual(newer.image,result.image);
 });
 test('source checkouts build RCs only: clean reviewed commit plus increasing label',async t=>{
   const home=await fixture(t),source=path.join(home,'source');await fs.mkdir(source);await fs.writeFile(path.join(source,'package.json'),'{}');
   let inside=true,status='',built=[],toplevel=source;const sha='a'.repeat(40);
   const invoke=async(cmd,args)=>{
-    if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);
+    if(cmd==='npm'&&args?.[0]==='view')return '"0.160.0"';if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);
     if(cmd==='git'){
       if(!inside)throw Error('not a git repository');
       if(args[2]==='rev-parse'&&args[3]==='--show-toplevel')return toplevel;
@@ -120,13 +121,13 @@ test('source checkouts build RCs only: clean reviewed commit plus increasing lab
 });
 test('a failed build releases its own lock and leaves a failure receipt for diagnosis',async t=>{
   const home=await fixture(t),source=path.join(home,'source');await fs.mkdir(source);await fs.writeFile(path.join(source,'package.json'),'{}');
-  const invoke=async(cmd)=>{if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);throw Error('Synthetic build failed');};
+  const invoke=async(cmd,args)=>{if(cmd==='npm'&&args?.[0]==='view')return '"0.160.0"';if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);throw Error('Synthetic build failed');};
   await assert.rejects(build({home,source},invoke),/Synthetic/);
   const [id]=await fs.readdir(path.join(home,'builds'));const dir=path.join(home,'builds',id);
   assert.equal(JSON.parse(await fs.readFile(path.join(dir,'status.json'))).state,'failed');await assert.rejects(fs.access(path.join(dir,'lock')));
 });
 test('source changes during a build cannot produce a reusable success receipt',async t=>{
   const home=await fixture(t),source=path.join(home,'source');await fs.mkdir(source);await fs.writeFile(path.join(source,'package.json'),'{}');
-  const invoke=async(cmd,args)=>{if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);if(args[0]==='build')await fs.writeFile(path.join(source,'package.json'),'{"changed":true}');return 'image';};
+  const invoke=async(cmd,args)=>{if(cmd==='npm'&&args?.[0]==='view')return '"0.160.0"';if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);if(args[0]==='build')await fs.writeFile(path.join(source,'package.json'),'{"changed":true}');return 'image';};
   await assert.rejects(build({home,source},invoke),/changed during build/);
 });

package/test/native-tasks.test.ts

@@ -20,7 +20,7 @@ test('native tasks use verified control binding, sanitized environment and uncha
     const denied=await nativeTasks(home,['list']);assert.notEqual(denied.code,0);assert.match(denied.stderr,/Pair an owner/)
     const control=new ControlStore(controlDir,1000);await control.requestPairing(101,101);await control.approveOwner(101)
     const text='Read scan; $(must-not-run) /goal literal'
-    const saved=await nativeTasks(home,['create','native-fixture','--now','--text',text]);assert.equal(saved.code,0,saved.stderr)
+    const saved=await nativeTasks(home,['create','native-fixture','--model','fixture-model','--now','--text',text]);assert.equal(saved.code,0,saved.stderr)
     const value=JSON.parse(saved.stdout);assert.equal(value.text,text);assert.equal(value.execution.preset.cli,'grok')
     assert.equal(JSON.parse((await nativeTasks(home,['show','native-fixture'])).stdout).text,text)
     assert.equal((await nativeTasks(home,['remove','native-fixture'])).code,0)

package/test/schedule-cli.test.ts

@@ -10,6 +10,8 @@ import { ControlStore } from '../src/control-state.js'
 import { RunStore } from '../src/runs.js'
 import { initialPreset } from '../src/ai.js'
 import { serveTestLedger } from './helpers/ledger.js'
+import { Scheduler } from '../src/scheduler.js'
+import { callDeliverySocket, socketPathFor } from '../src/delivery-socket.js'
 const exec=promisify(execFile),bin=fileURLToPath(new URL('../bin/ezenciel-agents-schedule.mjs',import.meta.url))
 test('public scheduler CLI saves literal text, reads back, edits, pauses, and rejects external or finished callers',async t=>{
  const dir=await mkdtemp(join(tmpdir(),'ez-schedule-cli-'));t.after(()=>rm(dir,{recursive:true,force:true}))
@@ -25,10 +27,11 @@ test('public scheduler CLI saves literal text, reads back, edits, pauses, and re
   const context=JSON.parse((await exec(process.execPath,[bin,'context'],{env})).stdout)
   assert.deepEqual(context.run.texts,['owner request']);assert.equal(context.busyReplies,undefined)
  await assert.rejects(exec(process.execPath,[bin,'context'],{env:{...env,EZ_RUN_ID:''}}),/active owner run/)
- const args=['create','test','--at','2027-09-09T09:00:00+04:00','--text','Literal $(do-not-execute) /goal objective']
+ await assert.rejects(exec(process.execPath,[bin,'create','missing-model','--now','--text','Do work'],{env}),/saved explicit model/)
+ const args=['create','test','--model','fixture-model','--at','2027-09-09T09:00:00+04:00','--text','Literal $(do-not-execute) /goal objective']
  const saved=JSON.parse((await exec(process.execPath,[bin,...args],{env})).stdout)
  assert.equal(saved.text,args.at(-1));assert.equal(saved.execution.preset.cli,'grok')
- assert.equal(saved.execution.preset.model,undefined);assert.equal(saved.execution.preset.effort,undefined)
+ assert.equal(saved.execution.preset.model,'fixture-model');assert.equal(saved.execution.preset.effort,undefined)
  await assert.rejects(exec(process.execPath,[bin,'create','blocked','--at','2027-09-09T09:00:00+04:00','--text','test','--model','gpt-5.6-terra','--effort','bad option'],{env}),/Invalid reasoning effort/)
  const astra=JSON.parse((await exec(process.execPath,[bin,'create','astra','--at','2027-09-09T10:00:00+04:00','--text','Astra task','--model','gpt-6-astra'],{env})).stdout)
  assert.equal(astra.execution.preset.model,'gpt-6-astra');assert.equal(astra.execution.preset.effort,undefined)
@@ -68,6 +71,47 @@ test('executor PATH exposes the extensionless scheduler command',async()=>{
   assert.match((await exec(command,['--help'])).stdout,/Creates a scheduled task/)
 })
 
+test('trigger uses saved task settings after a chat switch, preserves cadence and reconciles its request key',async t=>{
+ const dir=await mkdtemp(join(tmpdir(),'ez-trigger-cli-'));t.after(()=>rm(dir,{recursive:true,force:true}))
+ const ledger=await serveTestLedger(dir);t.after(()=>ledger.stop())
+ const control=new ControlStore(dir,1000),runs=new RunStore(dir),scheduler=new Scheduler(dir)
+ await control.requestPairing(101,101);await control.approveOwner(101)
+ const owner=(await control.status()).owner!
+ const execution={sessionId:crypto.randomUUID(),preset:{id:'task',name:'Saved task',cli:'codex',model:'gpt-6-astra',effort:'medium'}}
+ const saved=await scheduler.save({id:'daily',name:'Daily',text:'Literal /goal task',owner,execution,enabled:true,trigger:{cron:'5 7 * * 1-5',timezone:'America/New_York',start:'2027-01-01T00:00:00Z'}},true)
+ const next=await scheduler.pendingOccurrence(saved)
+ const chat=await control.captureChoice({...initialPreset('codex'),model:'fixture-model'})
+ await control.savePreset({id:'chat',name:'Chat',cli:'codex',model:'gpt-6-luna',effort:'max'})
+ await control.selectPreset('chat',chat.sessionId)
+ assert.equal((await control.status()).ai?.selectedId,'chat')
+ const env={...process.env,EZ_CONTROL_DIR:dir,EZ_RUN_ID:''}
+ const args=[bin,'trigger','daily','--key','smoke-1']
+ const first=JSON.parse((await exec(process.execPath,args,{env})).stdout)
+ assert.equal(first.status,'queued');assert.deepEqual(first.execution.preset,execution.preset)
+ assert.notEqual(first.execution.sessionId,execution.sessionId)
+ assert.equal(first.scheduled.id,saved.id);assert.equal(first.scheduled.revision,saved.revision)
+ assert.equal(first.texts[1],saved.text)
+ assert.deepEqual(await scheduler.get('daily'),saved);assert.equal(await scheduler.pendingOccurrence(saved),next)
+ const retry=JSON.parse((await exec(process.execPath,args,{env})).stdout)
+ assert.equal(retry.id,first.id);assert.equal((await runs.list()).length,1)
+ await assert.rejects(exec(process.execPath,[bin,'trigger','daily','--key','different'],{env}),/queued or running/)
+ await assert.rejects(exec(process.execPath,[...args,'--model','gpt-6-luna'],{env}),/overrides are not allowed/)
+ await runs.patch(first.id,{status:'completed'})
+ const parallel=await Promise.allSettled(['smoke-2','smoke-3'].map(key=>callDeliverySocket(socketPathFor(dir),{op:'triggerSchedule',payload:{scheduleId:'daily',revision:saved.revision,key}})))
+ assert.equal(parallel.filter(r=>r.status==='fulfilled').length,1,'concurrent trigger keys cannot overlap')
+ for(const run of await runs.list())await runs.patch(run.id,{status:'completed'})
+ const restricted=await runs.create({chatId:101,telegramUserId:101,texts:[],execution,external:{sourceId:'source',bindingId:'binding',eventIds:['event']}})
+ await runs.patch(restricted.id,{status:'running'})
+ await assert.rejects(callDeliverySocket(socketPathFor(dir),{op:'triggerSchedule',payload:{scheduleId:'daily',revision:saved.revision,key:'restricted',callerRunId:restricted.id}}),/blocked/)
+ await assert.rejects(callDeliverySocket(socketPathFor(dir),{op:'triggerSchedule',payload:{scheduleId:'daily',revision:'stale',key:'stale'}}),/changed/)
+ await assert.rejects(exec(process.execPath,[bin,'trigger','daily','--key','../bad'],{env}),/Invalid record identifier/)
+ await scheduler.enable('daily',false)
+ await assert.rejects(exec(process.execPath,[bin,'trigger','daily','--key','paused'],{env}),/disabled/)
+ await scheduler.enable('daily',true)
+ await control.revokeOwner();await control.requestPairing(202,202);await control.approveOwner(202)
+ await assert.rejects(exec(process.execPath,[bin,'trigger','daily','--key','wrong-owner'],{env}),/ownership mismatch/)
+})
+
 
 test('deferred literal input retains owner-scoped conversation through source metadata',async t=>{
  const {Scheduler}=await import('../src/scheduler.js')
@@ -75,7 +119,7 @@ test('deferred literal input retains owner-scoped conversation through source me
  const ledger=await serveTestLedger(dir);t.after(()=>ledger.stop())
  const control=new ControlStore(dir,1000),runs=new RunStore(dir)
  await control.requestPairing(101,101);await control.approveOwner(101)
- const execution=await control.captureChoice(initialPreset('codex'))
+ const execution=await control.captureChoice({...initialPreset('codex'),model:'fixture-model'})
  await runs.create({id:'tg_1',chatId:101,telegramUserId:101,texts:['Use the blue ledger'],execution})
  await runs.patch('tg_1',{status:'completed'})
  await runs.create({id:'tg_2',chatId:101,telegramUserId:101,texts:['Do the same for March'],execution})

package/test/scheduled-tasks.test.ts

@@ -9,7 +9,7 @@ import { scheduledTaskDetailText, scheduledTasksText } from '../src/scheduled-ta
 import { RunStore } from '../src/runs.js'
 
 const owner = { telegramUserId: 101, telegramChatId: 101, pairedAt: '2026-09-11T00:00:00.000Z' }
-const execution = { sessionId: randomUUID(), preset: { id: 'fixture', name: 'Fixture', cli: 'codex' } }
+const execution = { sessionId: randomUUID(), preset: { id: 'fixture', name: 'Fixture', cli: 'codex', model: 'fixture-model' } }
 
 test('scheduled task view is read-only, owner-bound, and shows active task prompts and effective AI settings', async (t) => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-scheduled-tasks-'))
@@ -40,7 +40,7 @@ test('scheduled task view is read-only, owner-bound, and shows active task promp
   const active = await scheduler.listActiveReadOnly(await runs.list())
   const text = scheduledTasksText(active, owner)
 
-  assert.equal(text, '📅 Scheduled tasks · 1 active\n\nAll times UTC. Use /tasks 1 for task details.\n\n1 · Daily report\n  ● Active\n  Next · Thu, Jan 1 · 05:00 UTC\n  Last · ✓ Completed · Thu, Jan 1 · 05:04 UTC\n  codex · client default · default effort\n  Read the ledger and send the owner a concise report.')
+  assert.equal(text, '📅 Scheduled tasks · 1 active\n\nAll times UTC. Use /tasks 1 for task details.\n\n1 · Daily report\n  ● Active\n  Next · Thu, Jan 1 · 05:00 UTC\n  Last · ✓ Completed · Thu, Jan 1 · 05:04 UTC\n  codex · fixture-model · default effort\n  Read the ledger and send the owner a concise report.')
   assert.match(scheduledTaskDetailText(active.find(schedule => schedule.id === saved.id)!, 1), /Last run\n✓ Completed · Thu, Jan 1 · 05:04 UTC/)
   assert.doesNotMatch(text, /Other owner task|This must never be visible/)
   assert.equal(await readFile(join(scheduleDir, 'owner-task.json'), 'utf8'), before)

package/test/scheduler-host.test.ts

@@ -20,14 +20,25 @@ test('host transport keeps chat responsive beside a schedule in the bound mind',
  const old={...EXECUTOR_REGISTRY.grok},token=process.env.TELEGRAM_BOT_TOKEN
  EXECUTOR_REGISTRY.grok.command=process.execPath;EXECUTOR_REGISTRY.grok.buildArgs=()=>[script]
  process.env.TELEGRAM_BOT_TOKEN='never-in-child'
- const abort=new AbortController(),server=serveHostExecutor({cli:'grok',agents:[{name:'test',workspace,controlDir,binDir:root}]},abort.signal)
+ const abort=new AbortController(),server=serveHostExecutor({cli:'grok',agents:[{name:'test',workspace,controlDir,binDir:root}]},abort.signal,undefined,async()=>[{cli:'grok',model:'fixture-model',name:'Fixture',efforts:[]}])
  const dir=join(controlDir,'host-executor'),runs=new RunStore(controlDir),id='r_schedule_fixture'
  const exists=async(file:string)=>readFile(join(dir,file),'utf8').catch(()=>'')
  try{
   await until(async()=>Boolean(await exists('heartbeat.json')))
-  await runs.create({id,chatId:101,telegramUserId:101,texts:['slow'],execution:{sessionId:randomUUID(),preset:{id:'fixture',name:'Fixture',cli:'grok'}},scheduled:{id:'s',revision:'v',dueAt:new Date().toISOString(),pairedAt:'paired'}})
-  const submit=async(id:string)=>writeFile(join(dir,id+'.request.json'),JSON.stringify({texts:['fixture'],options:{workspace:'/evil',controlDir:'/evil',cli:'grok',timeoutMs:1}}))
+  await runs.create({id,chatId:101,telegramUserId:101,texts:['slow'],execution:{sessionId:randomUUID(),preset:{id:'fixture',name:'Fixture',cli:'grok',model:'fixture-model'}},scheduled:{id:'s',revision:'v',dueAt:new Date().toISOString(),pairedAt:'paired'}})
+  const submit=async(id:string)=>writeFile(join(dir,id+'.request.json'),JSON.stringify({texts:['fixture'],options:{workspace:'/evil',controlDir:'/evil',cli:'grok',model:'fixture-model',timeoutMs:1}}))
   await ownerRun(controlDir,'tg_1')
+  for(const [badId,savedModel,requestedModel,reason] of [
+    ['r_schedule_missing',undefined,undefined,'saved explicit model'],
+    ['r_schedule_mismatch','fixture-model','wrong-model','does not match'],
+  ] as const){
+    await runs.create({id:badId,chatId:101,telegramUserId:101,texts:['blocked'],execution:{sessionId:randomUUID(),preset:{id:'fixture',name:'Fixture',cli:'grok',model:savedModel}},scheduled:{id:badId,revision:'v',dueAt:new Date().toISOString(),pairedAt:'paired'}})
+    await runs.patch(badId,{status:'running'})
+    await writeFile(join(dir,badId+'.request.json'),JSON.stringify({texts:['blocked'],options:{cli:'grok',model:requestedModel}}))
+    await until(async()=> (await exists(badId+'.events')).includes('"stream":"exit"'))
+    assert.match(await exists(badId+'.events'),new RegExp(reason))
+    assert.equal(await exists(badId+'.process.json'),'','host must reject before engine spawn')
+  }
   await runs.patch(id,{status:'running'})
   await submit(id)
   await until(async()=>Boolean(await exists(id+'.process.json')))

package/test/scheduler-relay.test.ts

@@ -11,9 +11,54 @@ import { ControlStore } from '../src/control-state.js'
 import { RunStore } from '../src/runs.js'
 import { Scheduler } from '../src/scheduler.js'
 import { initialPreset } from '../src/ai.js'
+import type { ExecutorOptions } from '../src/executor.js'
 
 const until=async(check:()=>Promise<boolean>)=>{for(let i=0;i<200;i++){if(await check())return;await new Promise(r=>setTimeout(r,20))}throw new Error('Timed out')}
 
+test('executor admission rejects a legacy queued schedule with no model before spawning',async()=>{
+ const dir=await mkdtemp(join(tmpdir(),'ez-missing-task-model-')),control=new ControlStore(dir,1000),runs=new RunStore(dir),scheduler=new Scheduler(dir)
+ let launches=0
+ const relay=createRelay({workspace:dir,controlDir:dir,pairingTtlMs:1000,executorTimeoutMs:0,executorCli:'codex',telegramBotToken:'fixture'},async()=>{
+  launches++;throw new Error('Must not launch')
+ })
+ relay.bot.api.config.use(async()=>({ok:true,result:{message_id:42}}) as never)
+ try{
+  await control.requestPairing(101,101);await control.approveOwner(101)
+  const owner=(await control.status()).owner!,execution=await control.captureChoice({...initialPreset('codex'),model:'saved-model'})
+  const due=Date.now()+2000
+  const saved=await scheduler.save({id:'legacy',name:'Legacy',text:'Work',owner,execution,enabled:true,trigger:{at:new Date(due).toISOString()}},true)
+  const run=await runs.create({id:'r_schedule_legacy',chatId:101,telegramUserId:101,texts:['Work'],
+   execution:{...execution,preset:{...execution.preset,model:undefined}},
+   scheduled:{id:saved.id,revision:saved.revision,dueAt:new Date(due).toISOString(),pairedAt:owner.pairedAt}})
+  await relay.drainSources()
+  assert.equal((await runs.get(run.id))?.status,'failed');assert.equal(launches,0)
+  assert.equal((await scheduler.get(saved.id)).execution.preset.model,'saved-model')
+ }finally{await relay.stop();await rm(dir,{recursive:true,force:true})}
+})
+
+test('manual task trigger launches its saved model in a fresh native session after chat switches AI',async()=>{
+ const dir=await mkdtemp(join(tmpdir(),'ez-trigger-launch-')),control=new ControlStore(dir,1000),runs=new RunStore(dir),scheduler=new Scheduler(dir)
+ let launched:ExecutorOptions | undefined
+ const relay=createRelay({workspace:dir,controlDir:dir,pairingTtlMs:1000,executorTimeoutMs:0,executorCli:'codex',telegramBotToken:'fixture'},async(_texts,options)=>{
+  launched=options
+  const child=spawn(process.execPath,['-e','setTimeout(()=>{},10)'],{detached:process.platform!=='win32'})
+  await once(child,'spawn');return {child,cleanup:async()=>{},stdout:''}
+ })
+ try{
+  await control.requestPairing(101,101);await control.approveOwner(101)
+  const owner=(await control.status()).owner!,chat=await control.captureChoice(initialPreset('codex'))
+  await control.savePreset({id:'chat',name:'Chat',cli:'codex',model:'gpt-6-luna',effort:'max'})
+  await control.selectPreset('chat',chat.sessionId)
+  const saved=await scheduler.save({id:'daily',name:'Daily',text:'Saved work',owner,execution:{sessionId:chat.sessionId,preset:{id:'daily',name:'Daily model',cli:'codex',model:'gpt-6-astra',effort:'medium'}},enabled:true,trigger:{at:'2027-01-01T00:00:00Z'}},true)
+  const run=await scheduler.trigger(saved.id,saved.revision,'launch-smoke',owner,runs)
+  await relay.drainSources();await until(async()=> (await runs.get(run.id))?.status==='completed')
+  assert.equal(launched?.model,'gpt-6-astra');assert.equal(launched?.effort,'medium')
+  assert.equal(launched?.nativeSession,true);assert.equal(launched?.isResume,false)
+  assert.notEqual(launched?.sessionId,chat.sessionId)
+  assert.equal((await control.status()).ai?.selectedId,'chat')
+ }finally{await relay.stop();await rm(dir,{recursive:true,force:true})}
+})
+
 // Adversarial: the relay must not reserve wrapper semantics for an
 // update-shaped run id or a stale attention notice.
 test('a wrapper-shaped run id has no maintenance treatment and a stale notice is inert',async()=>{
@@ -55,7 +100,7 @@ test('Slack application replies beside a schedule and keeps both streams serial'
  })
  try{
   await control.requestPairing(101,101);await control.approveOwner(101)
-  const owner=(await control.status()).owner!,execution=await control.captureChoice(initialPreset('grok'))
+  const owner=(await control.status()).owner!,execution=await control.captureChoice({...initialPreset('grok'),model:'fixture-model'})
   const due=Date.now()+10000
   for(const id of ['first','second'])await scheduler.save({id,name:id,text:'Long work',trigger:{at:new Date(due).toISOString()},enabled:true,owner,execution})
   await scheduler.tick(owner,runs,due);await relay.drainSources()
@@ -103,7 +148,7 @@ test('owner chat replies while a scheduled CLI keeps running; targeted cancellat
  relay.bot.api.config.use(async(_prev,method,payload)=>{if(method==='sendMessage')replies.push((payload as {text:string}).text);return {ok:true,result:{message_id:42}} as never})
  try{
   await control.requestPairing(101,101);await control.approveOwner(101)
-  const owner=(await control.status()).owner!,execution=await control.captureChoice(initialPreset('grok'))
+  const owner=(await control.status()).owner!,execution=await control.captureChoice({...initialPreset('grok'),model:'fixture-model'})
   const due=Date.now()+2000
   await scheduler.save({id:'slow',name:'Slow',text:'Long work',trigger:{at:new Date(due).toISOString()},enabled:true,owner,execution})
   await scheduler.tick(owner,runs,due);await relay.drainSources()

package/test/scheduler.test.ts

@@ -28,7 +28,7 @@ const fixture=async(t:any)=>{
  const dir=await mkdtemp(join(tmpdir(),'ez-schedules-'));t.after(()=>rm(dir,{recursive:true,force:true}))
  const scheduler=new Scheduler(dir), runs=new RunStore(dir), now=Date.now()+10000
  const owner={telegramUserId:101,telegramChatId:101,pairedAt:new Date().toISOString()}
- const input={id:'test',name:'Test',text:'Do the work',owner,execution:{sessionId:randomUUID(),preset:{id:'fixture',name:'Fixture',cli:'codex'}},enabled:true,trigger:{at:new Date(now).toISOString()}}
+ const input={id:'test',name:'Test',text:'Do the work',owner,execution:{sessionId:randomUUID(),preset:{id:'fixture',name:'Fixture',cli:'codex',model:'fixture-model'}},enabled:true,trigger:{at:new Date(now).toISOString()}}
  return {dir,scheduler,runs,now,owner,input}
 }
 test('durable dispatch survives cursor-write crash without duplicating an occurrence',async t=>{
@@ -158,3 +158,23 @@ test('ordinary recurring work still runs after a non-interrupted failure', async
  await f.scheduler.tick(f.owner,f.runs,f.now+60000)
  assert.equal((await f.runs.list()).length,2)
 })
+
+test('missing models cannot be saved, dispatched or triggered; legacy settings remain readable for repair',async t=>{
+ const f=await fixture(t)
+ const missing={...f.input,execution:{...f.input.execution,preset:{...f.input.execution.preset,model:undefined}}}
+ await assert.rejects(f.scheduler.save(missing),/saved explicit model/)
+ const saved=await f.scheduler.save(f.input,true),next=await f.scheduler.pendingOccurrence(saved)
+ const file=join(f.dir,'schedules/test.json')
+ await writeFile(file,JSON.stringify({...saved,execution:missing.execution}))
+ const legacy=await f.scheduler.get(saved.id)
+ assert.equal(legacy.execution.preset.model,undefined)
+ await f.scheduler.tick(f.owner,f.runs,f.now)
+ assert.equal((await f.runs.list()).length,0)
+ assert.equal(await f.scheduler.pendingOccurrence(legacy),next,'blocked dispatch must preserve the pending occurrence')
+ await assert.rejects(f.scheduler.trigger(saved.id,saved.revision,'legacy',f.owner,f.runs),/saved explicit model/)
+ const repaired=await f.scheduler.save({...legacy,execution:f.input.execution})
+ await f.scheduler.tick(f.owner,f.runs,f.now)
+ const [run]=await f.runs.list()
+ assert.equal(run.execution?.preset.model,f.input.execution.preset.model)
+ assert.equal(run.scheduled?.revision,repaired.revision)
+})

package/test/tasks.test.ts

@@ -247,7 +247,7 @@ test('approved initial task crosses the real host file client and uses a fresh r
   const { isHostRunId } = await import('../src/host-executor-protocol.js')
   const f = await fixture(t), { run } = await f.activate()
   assert.ok(isHostRunId(run.id))
-  await writeFile(join(f.dir, 'codex'), `#!${process.execPath}\nif(process.argv[2]==='--version')console.log('codex-cli 0.153.4');else if(process.argv[2]==='debug')console.log(JSON.stringify({models:[{slug:'fixture',tool_mode:'code_mode_only',apply_patch_tool_type:'freeform',multi_agent_version:'v2'}]}));else console.log(JSON.stringify({cwd:process.cwd(),args:process.argv.slice(2),control:process.env.EZ_CONTROL_DIR}));`, { mode: 0o700 })
+  await writeFile(join(f.dir, 'codex'), `#!${process.execPath}\nif(process.argv[2]==='--version')console.log('codex-cli 0.160.0');else if(process.argv[2]==='debug')console.log(JSON.stringify({models:[{slug:'fixture',tool_mode:'code_mode_only',apply_patch_tool_type:'freeform',multi_agent_version:'v2'}]}));else console.log(JSON.stringify({cwd:process.cwd(),args:process.argv.slice(2),control:process.env.EZ_CONTROL_DIR}));`, { mode: 0o700 })
   const priorPath = process.env.PATH
   process.env.PATH = `${f.dir}:${priorPath}`
   const abort = new AbortController(), host = serveHostExecutor({ cli: 'codex', agents: [{ name: 'test', workspace: f.dir, controlDir: f.dir, binDir: f.dir }] }, abort.signal)