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

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)

package/test/updates.test.mjs

@@ -13,7 +13,7 @@ import { perform, environment, packageManager, backupStateDirectory, execute } f
 import { atomic, snapshot, compose, prepareCommand } from '../src/plugins/manager.mjs';
 import { bindUpdates } from '../src/updates/binding.mjs';
 import { status as runtimeStatus } from '../src/updates/status.mjs';
-import { providerEnvironment, queueAutomatic, waitForHostHeartbeat } from '../src/updates/supervisor.mjs';
+import { providerEnvironment, queueAutomatic, waitForHostHeartbeat, withIdleUpgrade } from '../src/updates/supervisor.mjs';
 const exec=promisify(execFile);
 
 test('structured runtime output excludes warnings but failures retain diagnostics',async()=>{
@@ -113,10 +113,10 @@ test('root preparation leaves private plugin updates readable by the installer',
  const script=`const fs=require('fs');fs.readFileSync(${JSON.stringify(path.join(dir,'job.json'))});fs.readFileSync(${JSON.stringify(path.join(dir,'candidate.tgz'))});`;
  await exec('setpriv',['--reuid=20001','--regid=20002','--clear-groups','--no-new-privs',process.execPath,'-e',script]);
 });
-function runtime(f,{fail,stopped=false,buildArgs={CODEX_CLI_VERSION:'0.156.1'}}={}) {
+function runtime(f,{fail,stopped=false,buildArgs={CODEX_CLI_VERSION:'0.156.1'},latest='0.160.0'}={}) {
  const calls=[];let failed=false;
  const execute=async(command,args,opts)=>{
-  calls.push([command,...args]);if(fail&&!failed&&fail(command,args)){failed=true;throw Error('Synthetic failure');}
+  calls.push([command,...args]);if(args.includes('view'))return JSON.stringify(latest);if(fail&&!failed&&fail(command,args)){failed=true;throw Error('Synthetic failure');}
   if(args.at(-1)==='--version')return '10.30.3';
   if(args.includes('config'))return JSON.stringify({services:{relay:{build:{args:buildArgs}}}});
   if(args.includes('ps'))return stopped?'':'container-id';
@@ -276,6 +276,16 @@ test('compatibility bridge hands off any matching canonical beta release',async
  await atomic(path.join(f.source,'package.json'),{...candidate,version:'0.1.0-beta.34'});
  await assert.rejects(eligibility(f.home,'main',f.source,false),/newer/);
 });
+test('private RC and QA builds graduate only to their matching beta release',async t=>{
+ const f=await fixture(t),prior=await read(path.join(f.old,'package.json')),candidate=await read(path.join(f.source,'package.json'));
+ for(const suffix of ['rc.7','qa.4']) {
+  await atomic(path.join(f.old,'package.json'),{...prior,version:'0.1.0-beta.46.'+suffix});
+  await atomic(path.join(f.source,'package.json'),{...candidate,version:'0.1.0-beta.46'});
+  assert.equal((await eligibility(f.home,'main',f.source,true)).pkg.version,'0.1.0-beta.46');
+  await atomic(path.join(f.source,'package.json'),{...candidate,version:'0.1.0-beta.45'});
+  await assert.rejects(eligibility(f.home,'main',f.source,false),/newer/);
+ }
+});
 test('reviewed Library beta14 command migration is exact and fail-closed',()=>{
  const manifest=(version,document)=>({schemaVersion:1,id:'library',version,description:'library',commands:{library:{executable:'bin/ez-library.mjs',args:[]},'library-query':{executable:'bin/ez-library.mjs',args:[],channelQuery:true},...(document?{'library-document':{executable:'bin/ez-library.mjs',args:[],channelQuery:true}}:{})},skills:['skills/library/SKILL.md']});
  const deployment=(query,document)=>({schemaVersion:3,services:{library:{buildTarget:'runtime',volumes:{data:'/state'},healthcheck:['node','/app/bin/ez-library.mjs','--version'],memoryMiB:4096,cpus:2}},commands:{'library-query':{service:'library',argv:['node','/app/bin/ez-library.mjs',query]},...(document?{'library-document':{service:'library',argv:['node','/app/bin/ez-library.mjs','document']}}:{})},sharedServices:{}});
@@ -296,7 +306,7 @@ test('main transaction stages before stopping, pins rollback image, preserves st
  assert.notEqual(await fs.readFile(path.join(active,'bin/example.mjs'),'utf8'),'tampered');
  assert(r.calls.findIndex(c=>c.includes('build'))<r.calls.findIndex(c=>c[0]==='stopHost'));
  const build=r.calls.find(c=>c[0]==='docker'&&c[1]==='build');
- assert.equal(build[build.indexOf('--build-arg')+1],'CODEX_CLI_VERSION=0.156.1');
+ assert.equal(build[build.indexOf('--build-arg')+1],'CODEX_CLI_VERSION=0.160.0');
  const status=await command(f.home,['status']);assert(!JSON.stringify(status).includes('private-test-token'));assert(!('rollback'in status.jobs[0]));
  assert.equal((await fs.stat(path.join(jobPath(f.home,job.id),'job.json'))).mode&0o777,0o600);
 });
@@ -310,12 +320,14 @@ test('main activation and rollback bind guidance from the selected package root'
  assert.equal((await perform(failed.home,await queued(failed),runtime(failed,{fail:(_command,args)=>args.includes('up')}))).status,'rolled-back');
  assert.equal(await fs.readFile(path.join(failed.agent.workspace,'AGENTS.md'),'utf8'),'old guidance\n');
 });
-test('the same archive with different deployment CLI pins gets distinct image bindings',async t=>{
+test('latest overrides stale deployment pins and changing latest changes image bindings',async t=>{
  const tags=[],hashes=[];
  for(const pin of ['0.153.4','0.156.1']) {
-  const f=await fixture(t),job=await queued(f),r=runtime(f,{buildArgs:{CODEX_CLI_VERSION:pin}});
+  const f=await fixture(t),job=await queued(f),r=runtime(f,{buildArgs:{CODEX_CLI_VERSION:'0.153.4'},latest:pin});
   assert.equal((await perform(f.home,job,r)).status,'completed');
   const build=r.calls.find(c=>c[0]==='docker'&&c[1]==='build'),tag=build[build.indexOf('-t')+1];
+  assert.ok(build.includes(`CODEX_CLI_VERSION=${pin}`));
+  assert.equal((await read(path.join(jobPath(f.home,job.id),'job.json'))).codexVersion,pin);
   assert.match(await fs.readFile(path.join(f.config.deploymentDir,'docker.env'),'utf8'),new RegExp(tag));
   tags.push(tag);hashes.push(job.sha256);
  }
@@ -372,6 +384,33 @@ test('plugin updates register additive command routes on an unchanged deployment
  const dispatch=await prepareCommand(f.home,'query',[]);assert.deepEqual(dispatch.argv.slice(-4),['node','sample','/app/bin/example.mjs','query']);
  assert(r.calls.some(call=>call.includes('up')));
 });
+test('isolated plugin replacement refreshes broker version inventory after registry activation',async t=>{
+ const f=await fixture(t,'plugin');
+ await fs.appendFile(path.join(f.config.deploymentDir,'docker.env'),'EZ_EXECUTOR_TRANSPORT=local\n');
+ const job=await queued(f),r=runtime(f),execute=r.execute;
+ let observed;
+ r.execute=async(command,args,options)=>{
+  if(args.includes('restart')&&args.at(-1)==='plugin-broker') observed=(await read(path.join(f.home,'registry.json'))).plugins.sample.manifest.version;
+  return execute(command,args,options);
+ };
+ assert.equal((await perform(f.home,job,r)).status,'completed');
+ assert.equal(observed,'0.1.1');
+ assert.equal(r.calls.filter(call=>call.includes('restart')).length,1);
+ const interrupted=await read(path.join(jobPath(f.home,job.id),'job.json'));interrupted.status='applying';
+ assert.equal((await perform(f.home,interrupted,r)).status,'rolled-back');
+ assert.equal(observed,'0.1.0');
+ assert.equal(r.calls.filter(call=>call.includes('restart')).length,2);
+});
+test('plugin update preserves a created but never running service as stopped',async t=>{
+ const f=await fixture(t,'plugin'),job=await queued(f),r=runtime(f),execute=r.execute;
+ r.execute=async(command,args,options)=>{
+  if(args.includes('ps')) {r.calls.push([command,...args]);if(args.includes('view'))return JSON.stringify(latest);return args.includes('--status')?'':'created-container';}
+  return execute(command,args,options);
+ };
+ assert.equal((await perform(f.home,job,r)).status,'completed');
+ assert.equal(job.rollback.running,false);
+ assert.equal(r.calls.some(call=>call.includes('up')),false);
+});
 test('plugin command additions ignore object key order but reject collisions and changed routes',async t=>{
  const f=await fixture(t,'plugin'),deployment=await read(path.join(f.source,'ez-deployment.json'));
  deployment.services.sample={healthcheck:deployment.services.sample.healthcheck,volumes:deployment.services.sample.volumes,buildTarget:deployment.services.sample.buildTarget};
@@ -458,7 +497,7 @@ for(const provider of ['pnpm','corepack']) test(`supervisor with only ${provider
  // Package archives never contain node_modules; the fake pnpm below provisions the fixture loader.
  await fs.rm(path.join(f.source,'node_modules'),{recursive:true});
  const log=path.join(f.root,'commands.jsonl');
- await fs.writeFile(path.join(fake,provider),`#!${process.execPath}\nif(${JSON.stringify(provider)}==='corepack'&&process.argv[2]!=='pnpm@10.30.3')throw Error('Unpinned manager');if(process.argv.includes('--version')){console.log('10.30.3');process.exit(0)}const fs=require('fs');fs.mkdirSync('node_modules/tsx/dist',{recursive:true});fs.writeFileSync('node_modules/tsx/dist/loader.mjs','');`,{mode:0o755});
+ await fs.writeFile(path.join(fake,provider),`#!${process.execPath}\nif(${JSON.stringify(provider)}==='corepack'&&process.argv[2]!=='pnpm@10.30.3')throw Error('Unpinned manager');if(process.argv.includes('view')){console.log(JSON.stringify('0.160.0'));process.exit(0)}if(process.argv.includes('--version')){console.log('10.30.3');process.exit(0)}const fs=require('fs');fs.mkdirSync('node_modules/tsx/dist',{recursive:true});fs.writeFileSync('node_modules/tsx/dist/loader.mjs','');`,{mode:0o755});
  await fs.writeFile(path.join(fake,'docker'),`#!${process.execPath}\nconst fs=require('fs');const a=process.argv.slice(2);fs.appendFileSync(${JSON.stringify(log)},JSON.stringify(a)+'\\n');if(a.includes('config'))console.log(JSON.stringify({services:{relay:{build:{args:{}}}}}));if(a.includes('ps'))console.log('cid');if(a[0]==='inspect')console.log('sha256:'+'a'.repeat(64));`,{mode:0o755});
  const wrapper=path.join(f.root,'supervisor.mjs'),module=new URL('../src/updates/supervisor.mjs',import.meta.url).href;
  await fs.writeFile(wrapper,`import {supervise} from ${JSON.stringify(module)};const a=new AbortController();process.on('SIGTERM',()=>a.abort());await supervise(${JSON.stringify(f.config.deploymentDir)},a.signal,{discover:async()=>{${provider==='pnpm' ? "throw Error('Synthetic discovery failure')" : 'return []'}}});`);
@@ -473,6 +512,7 @@ for(const provider of ['pnpm','corepack']) test(`supervisor with only ${provider
  const requester=await exec(process.execPath,['--input-type=module','-e',`import {submit} from ${JSON.stringify(new URL('../src/updates/control.mjs',import.meta.url).href)};console.log(JSON.stringify(await submit(${JSON.stringify(f.home)},${JSON.stringify(job.id)},false)));`]);
  assert.equal(JSON.parse(requester.stdout).status,'queued');
  await new Promise(r=>setTimeout(r,1800));assert.equal((await read(path.join(jobPath(f.home,job.id),'job.json'))).status,'queued');
+ await assert.rejects(fs.readFile(path.join(f.agent.controlDir,'upgrade-pause.json')),e=>e.code==='ENOENT');
  await fs.rm(running);
  await wait(async()=>{const j=await read(path.join(jobPath(f.home,job.id),'job.json'));if(j.status==='failed'||j.status==='rolled-back')throw Error(JSON.stringify(j)+first.output());return j.status==='completed';});
  const newBeat=await heartbeat();assert.notEqual(newBeat.pid,oldBeat.pid);assert.equal(await firstClosed,0,first.output());
@@ -492,6 +532,26 @@ for(const provider of ['pnpm','corepack']) test(`supervisor with only ${provider
  const closed3=new Promise(r=>third.p.once('close',r));third.p.kill('SIGTERM');assert.equal(await closed3,0,third.output());
 });
 
+test('queued upgrades keep admission open while busy and release a raced or aborted pause',async t=>{
+ const root=await fs.mkdtemp(path.join(tmpdir(),'ez-upgrade-admission-'));
+ t.after(()=>fs.rm(root,{recursive:true,force:true}));
+ const pause=path.join(root,'upgrade-pause.json'),job={id:'test'},abort=new AbortController();
+ const absent=()=>assert.rejects(fs.readFile(pause),e=>e.code==='ENOENT');
+ let applied=0;
+ const apply=async()=>{assert.equal((await read(pause)).id,job.id);applied++;return 'applied';};
+ await withIdleUpgrade(root,job,abort.signal,apply,{isIdle:async()=>false});
+ await absent();assert.equal(applied,0);
+ let checks=0;
+ await withIdleUpgrade(root,job,abort.signal,apply,{isIdle:async()=>++checks===1,wait:async()=>{}});
+ await absent();assert.equal(applied,0);
+ assert.equal(await withIdleUpgrade(root,job,abort.signal,apply,{isIdle:async()=>true,wait:async()=>{}}),'applied');
+ await absent();assert.equal(applied,1);
+ await assert.rejects(withIdleUpgrade(root,job,abort.signal,async()=>{throw Error('apply failed');},{isIdle:async()=>true,wait:async()=>{}}),/apply failed/);
+ await absent();
+ await withIdleUpgrade(root,job,abort.signal,apply,{isIdle:async()=>true,wait:async()=>abort.abort()});
+ await absent();assert.equal(applied,1);
+});
+
 test('npm candidates verify exact version and integrity; automatic policy is enforced again at execution',async t=>{
  const f=await fixture(t),data=await fs.readFile(await f.pack()),original=globalThis.fetch;
  const {createHash}=await import('node:crypto');
@@ -590,7 +650,7 @@ for(const mode of ['exact','wrong-image','unhealthy']) test(`recovery reuses onl
  const f=await fixture(t),job=await queued(f),r=runtime(f);await perform(f.home,job,r);
  const interrupted=await read(path.join(jobPath(f.home,job.id),'job.json'));interrupted.status='applying';
  const calls=[],execute=async(command,args,options)=>{
-  calls.push([command,...args]);
+  calls.push([command,...args]);if(args.includes('view'))return JSON.stringify(latest);
   if(args.includes('ps'))return 'b'.repeat(64);
   if(args[0]==='inspect'&&args.includes('{{json .}}'))return JSON.stringify({Image:'sha256:'+(mode==='wrong-image'?'c':'a').repeat(64),State:{Running:true,Health:{Status:mode==='unhealthy'?'unhealthy':'healthy'}}});
   if(mode==='exact'&&args.includes('up'))throw Error('Pinned image index no longer exists');