@jc_stack/ez-agents 0.1.0-beta.50 → 0.1.0-beta.51

package/test/ai-cli.test.ts

@@ -6,6 +6,7 @@ import path from 'node:path'
 import {spawnSync} from 'node:child_process'
 import {fileURLToPath} from 'node:url'
 import {ControlStore} from '../src/control-state.js'
+import {executorJobEnv} from '../src/executor.js'
 import {initialPreset} from '../src/ai.js'
 
 test('explicit CLI/model selection preserves installation default and rejects unavailable choices',async()=>{
@@ -50,12 +51,33 @@ test('an agent can select a declared provider and model without putting the key
   await writeFile(path.join(binDir,'codex'),'#!/bin/sh\nexit 0\n',{mode:0o700})
   await writeFile(path.join(controlDir,'host-executor','models.json'),JSON.stringify([{cli:'codex',provider:'openrouter',model:'google/gemini-3.8-flash',name:'Gemini',efforts:[]}]))
   const store=new ControlStore(controlDir,900000);await store.aiState(initialPreset('codex'))
-  const env={...process.env,HOME:root,PATH:binDir+path.delimiter+process.env.PATH,EZ_CONTROL_DIR:controlDir,OPENROUTER_API_KEY:'must-not-persist'}
+  const env=executorJobEnv({runId:'fixture',controlDir,binDir,catalogTransport:'host'},{...process.env,HOME:root,PATH:binDir+path.delimiter+process.env.PATH,OPENROUTER_API_KEY:'must-not-persist'})
   const bin=fileURLToPath(new URL('../bin/ezenciel-agents-ai.mjs',import.meta.url))
   const result=spawnSync(process.execPath,[bin,'select','--cli','codex','--provider','openrouter','--model','google/gemini-3.8-flash'],{env,encoding:'utf8'})
   assert.equal(result.status,0,result.stderr)
   const state=await store.status(),selected=state.ai?.presets.find(p=>p.id===state.ai?.selectedId)
   assert.equal(selected?.provider,'openrouter');assert.equal(selected?.model,'google/gemini-3.8-flash')
   assert.equal(JSON.stringify(state).includes('must-not-persist'),false)
+  assert.equal(env.EZ_EXECUTOR_TRANSPORT,undefined)
+  assert.equal(env.EZ_ISOLATION,undefined)
+ }finally{await rm(root,{recursive:true,force:true})}
+})
+
+
+test('isolated AI CLI ignores a legacy host catalog and discovers its own Sonnet',async()=>{
+ const root=await mkdtemp(path.join(tmpdir(),'ez-ai-local-catalog-'))
+ try{
+  const controlDir=path.join(root,'control'),binDir=path.join(root,'bin')
+  await mkdir(path.join(controlDir,'host-executor'),{recursive:true});await mkdir(binDir)
+  const stale=JSON.stringify([{cli:'codex',model:'host-only',name:'Host only',efforts:[]}])
+  await writeFile(path.join(controlDir,'host-executor','models.json'),stale)
+  await writeFile(path.join(binDir,'claude'),"#!/bin/sh\nprintf '%s\n' \"  --model <model> Model (e.g. 'sonnet', 'opus')\" \"  --effort <level> Effort (low, high)\"\n",{mode:0o700})
+  const env={...process.env,HOME:root,PATH:binDir,EZ_CONTROL_DIR:controlDir,EZ_ISOLATION:'isolated',EZ_EXECUTOR_TRANSPORT:'local'}
+  const bin=fileURLToPath(new URL('../bin/ezenciel-agents-ai.mjs',import.meta.url))
+  const result=spawnSync(process.execPath,[bin,'list'],{env,encoding:'utf8'})
+  assert.equal(result.status,0,result.stderr)
+  const catalog=JSON.parse(result.stdout)
+  assert.ok(catalog.some((m:{cli:string;model:string})=>m.cli==='claude'&&m.model==='sonnet'))
+  assert.ok(!catalog.some((m:{model:string})=>m.model==='host-only'))
  }finally{await rm(root,{recursive:true,force:true})}
 })

package/test/ai.test.ts

@@ -631,7 +631,7 @@ test('private channel model choices do not consume owner preset slots', async ()
     assert.equal(readback.preset?.model, model.model)
     assert.equal(readback.preset?.effort, 'low')
     assert.deepEqual((await store.status()).ai, before)
-    await assert.rejects(menu.saveSelection(model, 'max'), /at most 12/)
+    assert.equal((await menu.saveSelection(model, 'max')).effort, 'max')
     await assert.rejects(store.changeApplicationSession(scope, {...guard, expectedSession:null}, preset), /Conversation changed/)
     assert.deepEqual((await store.applicationSession(scope))?.preset, readback.preset)
   } finally { await rm(dir, {recursive:true, force:true}) }
@@ -648,7 +648,29 @@ test('detected presets do not count against the saved AI cap', async () => {
     assert.equal((await store.status()).ai!.presets.length, 13)
     const next = {id:'one-more', name:'One more', cli:'claude', model:'sonnet', effort:'medium'}
     await store.savePreset(next)
-    await assert.rejects(store.savePreset({...next, id:'too-many', name:'Too many'}), /at most 12/)
+    await store.savePreset({...next, id:'one-past-cap', name:'One past cap'})
+    const ids = (await store.status()).ai!.presets.map(p => p.id)
+    assert.equal(ids.filter(id => !id.startsWith('detected_')).length, 12)
+    assert.ok(!ids.includes('saved-1') && ids.includes('one-past-cap') && ids.includes(initial.id))
+  } finally { await rm(dir, {recursive:true, force:true}) }
+})
+
+test('a new model choice at the saved AI cap replaces the oldest unused choice', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-ai-cap-select-'))
+  try {
+    const store = new ControlStore(dir, 1000)
+    const initial = initialPreset('claude')
+    await store.captureChoice(initial)
+    for (let n = 1; n < 12; n++) await store.savePreset({...initial, id:`saved-${n}`, name:`Saved ${n}`, model:'opus', effort:n % 2 ? 'high' : 'xhigh'})
+    await store.selectPreset('saved-1', (await store.getActiveSession())?.sessionId ?? null)
+    const model = {cli:'claude', model:'sonnet', name:'sonnet', efforts:['low', 'high']}
+    const menu = createAiMenu(store, 'claude', async () => [model], dir, undefined, async () => true)
+    const preset = await menu.saveSelection(model, 'high')
+    await menu.select(preset, (await store.getActiveSession())?.sessionId ?? null)
+    const ai = (await store.status()).ai!
+    assert.equal(ai.presets.find(p => p.id === ai.selectedId)?.model, 'sonnet')
+    assert.equal(ai.presets.length, 12)
+    assert.ok(ai.presets.some(p => p.id === 'saved-1') && !ai.presets.some(p => p.id === 'saved-2'))
   } finally { await rm(dir, {recursive:true, force:true}) }
 })
 

package/test/delivery-transport.test.ts

@@ -1,6 +1,6 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { mkdtemp, rm, unlink } from 'node:fs/promises'
+import { mkdtemp, rm, unlink, writeFile } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { createConnection } from 'node:net'
@@ -64,9 +64,48 @@ test('a response timeout is not replayed over the loopback endpoint', async t =>
   const dir = await mkdtemp(join(tmpdir(), 'ez-delivery-timeout-'))
   t.after(() => rm(dir, { recursive: true, force: true }))
   let calls = 0
-  const server = await serveDeliverySocket(dir, async () => { calls++; return new Promise(() => {}) }, { tcpPort: 0 })
+  const server = await serveDeliverySocket(dir, async () => { calls++; await new Promise(resolve=>setTimeout(resolve,300)); return {accepted:true} }, { tcpPort: 0 })
   t.after(() => server.stop())
   assert.ok(server.endpoint)
   await assert.rejects(callDeliverySocket(deliverySocketPath(dir), { op: 'enqueue' }, 200), /Delivery relay unavailable/)
   assert.equal(calls, 1)
 })
+
+test('shutdown waits for an admitted enqueue before the final delivery drain',async t=>{
+ const dir=await mkdtemp(join(tmpdir(),'ez-delivery-admission-'))
+ t.after(()=>rm(dir,{recursive:true,force:true}))
+ let release!:()=>void,entered!:()=>void,accepted=0,drained=0
+ const gate=new Promise<void>(resolve=>{release=resolve}),admitted=new Promise<void>(resolve=>{entered=resolve})
+ const server=await serveDeliverySocket(dir,async()=>{entered();await gate;accepted++;return {accepted:true}},{beforeClose:async()=>{drained=accepted}})
+ const request=callDeliverySocket(deliverySocketPath(dir),{op:'enqueue'})
+ await admitted
+ let stopped=false
+ const stop=server.stop().then(()=>{stopped=true})
+ await new Promise(resolve=>setTimeout(resolve,50))
+ assert.equal(stopped,false)
+ assert.equal(drained,0)
+ release()
+ assert.deepEqual(await request,{accepted:true})
+ await stop
+ assert.equal(drained,1)
+})
+
+
+test('a swap connection failure waits for the relay but an accepted timeout is never retried',async t=>{
+ const dir=await mkdtemp(join(tmpdir(),'ez-delivery-swap-'))
+ t.after(()=>rm(dir,{recursive:true,force:true}))
+ await writeFile(join(dir,'upgrade-pause.json'),'{}')
+ const waiting=callDeliverySocket(deliverySocketPath(dir),{op:'enqueue'},1000)
+ await new Promise(r=>setTimeout(r,300))
+ let accepted=0
+ const server=await serveDeliverySocket(dir,async()=>({accepted:++accepted}))
+ t.after(()=>server.stop())
+ assert.deepEqual(await waiting,{accepted:1})
+ assert.equal(accepted,1)
+ await server.stop()
+ let attempted=0
+ const hanging=await serveDeliverySocket(dir,async()=>{attempted++;await new Promise(r=>setTimeout(r,200));return {accepted:true}})
+ t.after(()=>hanging.stop())
+ await assert.rejects(callDeliverySocket(deliverySocketPath(dir),{op:'enqueue'},40),/unavailable/)
+ assert.equal(attempted,1)
+})

package/test/executor.test.ts

@@ -2,11 +2,11 @@ import { ownerRun } from './helpers/owner-run.js'
 import { RunStore } from '../src/runs.js'
 import assert from 'node:assert/strict'
 import test from 'node:test'
-import { mkdtemp, mkdir, rm, writeFile, readFile } from 'node:fs/promises'
+import { mkdtemp, mkdir, rm, writeFile, readFile, rename, stat } from 'node:fs/promises'
 import { spawn } from 'node:child_process'
 import { tmpdir } from 'node:os'
 import path from 'node:path'
-import { EXECUTOR_REGISTRY, executorEnvironment, grokInvocation, grokJobEnv, opencodeDataHome, opencodeInvocation, piAgentDir, resolveExecutor, resolveHostCommand, startExecutorJob, terminateJob, validateCodexProvider } from '../src/executor.js'
+import { EXECUTOR_REGISTRY, attachHostJob, executorEnvironment, grokInvocation, grokJobEnv, opencodeDataHome, opencodeInvocation, piAgentDir, resolveExecutor, resolveHostCommand, startExecutorJob, terminateJob, validateCodexProvider } from '../src/executor.js'
 import { requireOwnerExecution } from '../src/execution-authority.js'
 import { splitTelegramText } from '../src/reply.js'
 import { matchingProcessIds, processSnapshot } from '../src/process-tree.js'
@@ -139,8 +139,10 @@ test('host transport does not throw when selecting the desktop adapter', async (
       workspace: root, controlDir, binDir: path.join(root, 'bin'), cli: 'codex-gui', runId: 'r_hostgui', timeoutMs: 1500,
     })
     assert.ok(job.child.pid)
-    terminateJob(job.child)
-    await new Promise((resolve) => job.child.once('close', resolve))
+    const closed = new Promise((resolve) => job.child.once('close', resolve))
+    await terminateJob(job.child)
+    await closed
+    assert.equal(await readFile(path.join(controlDir,'host-executor/r_hostgui.cancel'),'utf8'),'')
     await job.cleanup()
   } finally {
     if (prior === undefined) delete process.env.EZ_EXECUTOR_TRANSPORT
@@ -149,6 +151,32 @@ test('host transport does not throw when selecting the desktop adapter', async (
   }
 })
 
+test('host cancellation persists before a stalled observer receives a signal', {skip:process.platform==='win32'}, async () => {
+  const root=await mkdtemp(path.join(tmpdir(),'ez-cancel-observer-'))
+  const directory=path.join(root,'host-executor'),id='r_stalled'
+  await mkdir(directory)
+  await assert.rejects(attachHostJob(root,'../escape'),/Invalid host executor run ID/)
+  await writeFile(path.join(directory,id+'.running.json'),'{}')
+  const child=await attachHostJob(root,id)
+  const closed=new Promise(resolve=>child.once('close',resolve))
+  child.kill('SIGSTOP')
+  try {
+    await rename(directory,directory+'.saved')
+    await writeFile(directory,'Blocked transport directory')
+    assert.equal(await terminateJob(child),false)
+    assert.equal(child.exitCode,null)
+    assert.equal(child.signalCode,null)
+    await assert.rejects(readFile(path.join(directory+'.saved',id+'.cancel')),{code:'ENOENT'})
+    await rm(directory);await rename(directory+'.saved',directory)
+    assert.equal(await terminateJob(child),true)
+    assert.equal(await readFile(path.join(directory,id+'.cancel'),'utf8'),'')
+    assert.equal((await stat(path.join(directory,id+'.cancel'))).mode&0o777,0o600)
+  } finally {
+    child.kill('SIGCONT');child.kill('SIGKILL')
+    await closed;await rm(root,{recursive:true,force:true})
+  }
+})
+
 test('Codex jobs disable global memory and host skill discovery', () => {
   const args = EXECUTOR_REGISTRY.codex.buildArgs({workspace:'/agent'},'/prompt','hello')
   assert.ok(args.includes('memories'))

package/test/host-executor.test.ts

@@ -8,7 +8,7 @@ import { serveHostExecutor, refreshAgentCatalog } from '../src/host-executor.js'
 import { spawn } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { isHostRunId } from '../src/host-executor-protocol.js'
-import { EXECUTOR_REGISTRY } from '../src/executor.js'
+import { EXECUTOR_REGISTRY, attachHostJob, terminateJob } from '../src/executor.js'
 import { RunStore } from '../src/runs.js'
 import { packageVersion } from '../src/version.js'
 import { executionDefaults } from '../src/model-policy.js'
@@ -294,11 +294,17 @@ test('one installed CLI executes two agent bindings with separate minds and sani
     assert.equal(await workspaceLease(agents[0].toolsHome),undefined)
     await ownerRun(agents[0].controlDir,'tg_43')
     await writeFile(path.join(directory,'tg_43.request.json'),JSON.stringify({texts:['Hold chat'],options:{cli:'grok'}}))
-    for(let n=0;n<100;n++){try{await readFile(path.join(directory,'tg_43.process.json'));break}catch{await new Promise(r=>setTimeout(r,20))}}
+    for(let n=0;n<100;n++){try{if(JSON.parse(await readFile(path.join(directory,'tg_43.process.json'),'utf8')).pid)break}catch{await new Promise(r=>setTimeout(r,20))}}
     await readFile(path.join(directory,'tg_43.running.json'))
     assert.doesNotMatch(await readFile(path.join(directory,'r_hold.events'),'utf8'),/"stream":"exit"/)
     await readFile(path.join(directory,'r_hold.running.json'))
-    await writeFile(path.join(directory,'r_hold.cancel'),'')
+    // An observer that cannot handle signals must still stop the native run.
+    const observer=await attachHostJob(agents[0].controlDir,'r_hold')
+    const observerClosed=new Promise(resolve=>observer.once('close',resolve))
+    observer.stdout?.resume();observer.stderr?.resume()
+    observer.kill('SIGSTOP')
+    try { assert.equal(await terminateJob(observer),true) }
+    finally { observer.kill('SIGCONT');observer.kill('SIGKILL');await observerClosed }
     let heldOutput=''
     for(let n=0;n<200;n++){heldOutput=await readFile(path.join(directory,'r_hold.events'),'utf8');if(heldOutput.includes('"stream":"exit"'))break;await new Promise(r=>setTimeout(r,20))}
     assert.match(heldOutput, /"stream":"exit","code":1/)
@@ -568,3 +574,64 @@ test('host transport runs a registered script from the run record and refuses ch
     await rm(root,{recursive:true,force:true})
   }
 })
+
+test('a native process that settles during launch records completion without hanging the worker',async t=>{
+ const root=await mkdtemp(path.join(tmpdir(),'ez-fast-native-')),workspace=path.join(root,'mind'),controlDir=path.join(root,'control')
+ await mkdir(workspace);await mkdir(controlDir)
+ const abort=new AbortController(),directory=path.join(controlDir,'host-executor')
+ const launch=async()=>{
+  const child=spawn(process.execPath,['-e','process.exit(0)'],{stdio:['pipe','pipe','pipe']})
+  await new Promise(resolve=>child.once('close',resolve))
+  return {child,cleanup:async()=>{},stdout:''}
+ }
+ const server=serveHostExecutor({cli:'grok',agents:[{name:'test',workspace,controlDir,binDir:root}]},abort.signal,launch,async()=>[])
+ t.after(async()=>{abort.abort();await server;await rm(root,{recursive:true,force:true})})
+ for(let n=0;n<300;n++){try{await readFile(path.join(directory,'heartbeat.json'));break}catch{await new Promise(r=>setTimeout(r,20))}}
+ await ownerRun(controlDir,'r_fast_native')
+ await writeFile(path.join(directory,'r_fast_native.request.json'),JSON.stringify({texts:['fast'],options:{cli:'grok'}}))
+ let events=''
+ for(let n=0;n<300;n++){try{events=await readFile(path.join(directory,'r_fast_native.events'),'utf8');if(events.includes('"stream":"exit"'))break}catch{}await new Promise(r=>setTimeout(r,20))}
+ assert.match(events,/"stream":"exit","code":0/)
+})
+
+test('retiring native generation preserves its run while the replacement claims new work once',async t=>{
+ const root=await mkdtemp(path.join(tmpdir(),'ez-host-generation-'))
+ const workspace=path.join(root,'mind'),controlDir=path.join(root,'control'),toolsHome=path.join(root,'tools')
+ await mkdir(workspace);await mkdir(toolsHome);await mkdir(controlDir)
+ await writeFile(path.join(toolsHome,'config.json'),JSON.stringify({schemaVersion:1,workspace:await realpath(workspace)}))
+ const agent={name:'qa',workspace,controlDir,toolsHome,binDir:root},installation={cli:'grok',agents:[agent]}
+ const stopA=new AbortController(),stopB=new AbortController(),retireA=new AbortController()
+ const children=new Map<string,ReturnType<typeof spawn>>(),launched:string[]=[]
+ const launch=async(_texts:string[],options:any)=>{
+  launched.push(options.runId)
+  const child=spawn(process.execPath,['-e',"process.stdin.resume();process.stdin.once('data',()=>process.exit(0));"],{stdio:['pipe','pipe','pipe']})
+  children.set(options.runId,child)
+  return {child,cleanup:async()=>{},stdout:''}
+ }
+ let a:Promise<void>|undefined,b:Promise<void>|undefined
+ t.after(async()=>{stopA.abort();stopB.abort();for(const child of children.values())child.stdin?.end('done');await Promise.all([a,b]);await rm(root,{recursive:true,force:true})})
+ const directory=path.join(controlDir,'host-executor')
+ const wait=async(check:()=>Promise<boolean>)=>{for(let n=0;n<300;n++){if(await check())return;await new Promise(r=>setTimeout(r,20))}assert.fail('generation did not reach expected state')}
+ const exists=(file:string)=>readFile(file).then(()=>true,()=>false)
+ a=serveHostExecutor(installation,stopA.signal,launch,async()=>[],retireA.signal)
+ await wait(()=>exists(path.join(directory,'heartbeat.json')))
+ await ownerRun(controlDir,'r_old_generation')
+ await writeFile(path.join(directory,'r_old_generation.request.json'),JSON.stringify({texts:['old'],options:{cli:'grok'}}))
+ await wait(async()=>children.has('r_old_generation'))
+ retireA.abort()
+ await wait(async()=>!await exists(path.join(directory,'worker.lock')))
+ assert.equal(children.get('r_old_generation')!.exitCode,null)
+ b=serveHostExecutor(installation,stopB.signal,launch,async()=>[])
+ await wait(()=>exists(path.join(directory,'worker.lock')))
+ await ownerRun(controlDir,'r_new_generation')
+ await writeFile(path.join(directory,'r_new_generation.request.json'),JSON.stringify({texts:['new'],options:{cli:'grok'}}))
+ await wait(async()=>children.has('r_new_generation'))
+ assert.deepEqual(launched,['r_old_generation','r_new_generation'])
+ children.get('r_old_generation')!.stdin!.end('done')
+ await a
+ assert.ok(await exists(path.join(directory,'worker.lock')),'retiring host must not delete replacement lock')
+ assert.match(await readFile(path.join(directory,'r_old_generation.events'),'utf8'),/"stream":"exit","code":0/)
+ children.get('r_new_generation')!.stdin!.end('done')
+ await wait(async()=>(await readFile(path.join(directory,'r_new_generation.events'),'utf8')).includes('"stream":"exit"'))
+ assert.match(await readFile(path.join(directory,'r_new_generation.events'),'utf8'),/"stream":"exit","code":0/)
+})

package/test/intake-relay.test.ts

@@ -295,7 +295,7 @@ test('conversation menu is owner-only and removes the retired settings control',
     await f.relay.bot.handleUpdate(message(8, '/status'))
     assert.ok(!f.keyboards.at(-1)!.flat().some((button) => button.text === 'Scheduled tasks'))
     await f.relay.bot.handleUpdate(message(9, '/tasks'))
-    assert.match(f.replies.at(-1)!, /📅 Scheduled tasks[\s\S]*No active scheduled tasks/)
+    assert.match(f.replies.at(-1)!, /📅 Scheduled tasks[\s\S]*No scheduled tasks/)
     await f.relay.bot.handleUpdate(message(10, '/tasks 2'))
     assert.match(f.replies.at(-1)!, /Scheduled task 2 was not found/)
     assert.equal(f.launched.length, 0)
@@ -810,6 +810,13 @@ test('tasks list and detail show saved frequency and ordered setup path without
     assert.ok(detail.includes('Schedule\nEvery 30 minutes · America/New_York'))
     assert.ok(detail.includes(`Execution path\n${path}`))
     assert.deepEqual(await scheduler.get(saved.id),saved)
+    const paused=await scheduler.enable(saved.id,false)
+    await f.relay.bot.handleUpdate(message(3,'/tasks'))
+    assert.match(f.replies.at(-1)!,/0 active · 1 paused[\s\S]*⏸ Paused[\s\S]*Next · —/)
+    await f.relay.bot.handleUpdate(message(4,'/tasks 1'))
+    assert.match(f.replies.at(-1)!,/⏸ Paused[\s\S]*Next run\n—/)
+    assert.ok(f.replies.at(-1)!.includes(`Execution path\n${path}`))
+    assert.deepEqual(await scheduler.get(saved.id),paused)
     assert.equal(f.launched.length,0)
   }finally{await f.close()}
 })

package/test/plugin-manager.test.mjs

@@ -283,7 +283,7 @@ test('a lease from another PID namespace is live while its call container runs,
  // Isolated broker lease: its pid means nothing in this namespace (EPERM/ESRCH or an unrelated process).
  await fs.writeFile(lease,JSON.stringify({pid:1,container:'broker-call',pidNamespace:'pid:[4026531999]'}),{mode:0o600});
  const path0=process.env.PATH;process.env.PATH=f.fake+path.delimiter+path0;t.after(()=>{process.env.PATH=path0;});
- const docker=state=>fs.writeFile(path.join(f.fake,'docker'),`#!${process.execPath}\nconst a=process.argv.slice(2);if(a[0]==='container'&&a[1]==='inspect'){${state}}\n`,{mode:0o700});
+ const docker=async state=>{const file=path.join(f.fake,'docker');await fs.writeFile(file+'.next',`#!${process.execPath}\nconst a=process.argv.slice(2);if(a[0]==='container'&&a[1]==='inspect'){${state}}\n`,{mode:0o700});await fs.rename(file+'.next',file);};
  await docker(`console.log('true')`);
  await assert.rejects(locked(f.home,async()=>{}),/commands are active/); // never misreported as stale
  let activated=false;const drain=locked(f.home,async()=>{activated=true;},{drainInvocations:true});

package/test/run-handoff.test.ts

@@ -56,6 +56,9 @@ test('a graceful relay stop hands running host work to the next relay, which rec
     await rename(join(host, id + '.request.json'), join(host, id + '.running.json'))
     await appendFile(join(host, id + '.events'), JSON.stringify({ stream: 'stdout', text: 'working\n' }) + '\n')
   }
+  const delivered=await first.enqueueMessage(scheduled.id,'Delivered before replacement')
+  await first.claimOutbox(delivered.id)
+  await first.markOutboxSent(delivered.id,[17])
   await before.stop()
   assert.equal((await stat(join(dir, 'run-handoff.json'))).mode & 0o777, 0o600)
   const handoff = JSON.parse(await readFile(join(dir, 'run-handoff.json'), 'utf8'))
@@ -72,6 +75,7 @@ test('a graceful relay stop hands running host work to the next relay, which rec
     await after.adoptHandoff()
     await assert.rejects(readFile(join(dir, 'run-handoff.json')), { code: 'ENOENT' })
     assert.deepEqual((await runs.list()).map(run => run.status), ['running', 'running'])
+    assert.deepEqual(await runs.waitForDelivery(delivered.id,100),await first.waitForDelivery(delivered.id,100))
     // The new ledger accepts the run's result delivery and holds its recurring schedule.
     assert.ok(await runs.enqueueMessage(scheduled.id, 'Result after replacement'))
     await scheduler.tick(owner, runs, due + 60_000); await after.drainSources()

package/test/schedule-cli.test.ts

@@ -2,7 +2,7 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { fileURLToPath } from 'node:url'
@@ -11,6 +11,7 @@ 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 { Scripts } from '../src/scripts.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=>{
@@ -66,6 +67,28 @@ test('public scheduler CLI saves literal text, reads back, edits, pauses, and re
  await assert.rejects(exec(process.execPath,[bin,'list'],{env}),/owner-authorized/)
 })
 
+test('edit keeps a paused agent or script schedule paused and an enabled one enabled',async t=>{
+ const dir=await mkdtemp(join(tmpdir(),'ez-schedule-edit-'));t.after(()=>rm(dir,{recursive:true,force:true}))
+ const ledger=await serveTestLedger(dir);t.after(()=>ledger.stop())
+ const control=new ControlStore(dir,1000),workspace=join(dir,'workspace')
+ await control.requestPairing(101,101);await control.approveOwner(101)
+ await mkdir(workspace);await writeFile(join(workspace,'guard.mjs'),'')
+ await new Scripts(dir).save({id:'guard',owner:(await control.status()).owner!,workspace,entry:'guard.mjs',interpreter:'node',args:[],timeoutSeconds:60},true)
+ const env={...process.env,EZ_CONTROL_DIR:dir,EZ_RUN_ID:''}
+ const cli=async(...args:string[])=>JSON.parse((await exec(process.execPath,[bin,...args],{env})).stdout)
+ const tasks={agent:(text:string)=>['--model','gpt-6-astra','--text',text],script:(name:string)=>['--script','guard','--name',name]}
+ for(const [id,task] of Object.entries(tasks)){
+  await cli('create',id,...task('Original'),'--every-seconds','3600')
+  await cli('pause',id)
+  // Changing only the instructions, even with --now, must not resume or dispatch it.
+  const paused=await cli('edit',id,...task('Changed'),'--now')
+  assert.equal(paused.enabled,false);assert.equal(paused.nextEligibleAt,null)
+  assert.equal((await cli('show',id)).enabled,false)
+  await cli('resume',id)
+  assert.equal((await cli('edit',id,...task('Again'),'--every-seconds','3600')).enabled,true)
+ }
+})
+
 test('executor PATH exposes the extensionless scheduler command',async()=>{
  const command=fileURLToPath(new URL('../bin/ezenciel-agents-schedule',import.meta.url))
   assert.match((await exec(command,['--help'])).stdout,/Creates a scheduled task/)

package/test/scheduled-tasks.test.ts

@@ -38,10 +38,10 @@ test('scheduled task view is read-only, owner-bound, and shows active task promp
     scheduled: { id: saved.id, revision: saved.revision, dueAt: '2026-01-01T05:00:00.000Z', pairedAt: owner.pairedAt },
   })
   await runs.patch(run.id, { status: 'completed', endedAt: '2026-01-01T05:04:00.000Z' })
-  const active = await scheduler.listActiveReadOnly(await runs.list())
+  const active = await scheduler.listTasksReadOnly(await runs.list())
   const text = scheduledTasksText(active, owner)
 
-  assert.equal(text, '📅 Scheduled tasks · 1 active\n\nNext/last times UTC. Use /tasks 1 for task details.\n\n1 · Daily report\n  ● Active\n  Schedule · Weekdays at 09:00 · Asia/Dubai\n  Next · Thu, Jan 1 · 05:00 UTC\n  Last · ✓ Completed · Thu, Jan 1 · 05:04 UTC\n  Execution · codex (default login) · fixture-model · default effort\n  Read the ledger and send the owner a concise report.')
+  assert.equal(text, '📅 Scheduled tasks · 1 active · 0 paused\n\nNext/last times UTC. Use /tasks 1 for task details.\n\n1 · Daily report\n  ● Active\n  Schedule · Weekdays at 09:00 · Asia/Dubai\n  Next · Thu, Jan 1 · 05:00 UTC\n  Last · ✓ Completed · Thu, Jan 1 · 05:04 UTC\n  Execution · codex (default login) · 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)
@@ -62,29 +62,37 @@ test('active view follows existing cursor and run state without changing schedul
         id==='interrupted'?{everySeconds:60,start:new Date(due).toISOString()}:{at:new Date(due).toISOString()}})
   }
   await scheduler.save({...common,id:'recurring',name:'recurring',trigger:{everySeconds:60,start:new Date(due).toISOString()}})
-  const names = async () => (await scheduler.listActiveReadOnly(await runs.list())).map(s=>s.id).sort()
-  assert.deepEqual(await names(),['expired','interrupted','once','recurring','review'])
+  const names = async () => (await scheduler.listTasksReadOnly(await runs.list())).map(s=>s.id).sort()
+  assert.deepEqual(await names(),['expired','interrupted','once','paused','recurring','review'])
+  const paused = (await scheduler.listTasksReadOnly(await runs.list())).find(s=>s.id==='paused')!
+  assert.equal(paused.enabled,false)
+  assert.equal(paused.nextAt,null)
+  assert.match(scheduledTasksText([paused],owner),/0 active · 1 paused[\s\S]*⏸ Paused/)
+  assert.doesNotMatch(scheduledTasksText([paused],{...owner,pairedAt:'different'}),/⏸ Paused/)
+  assert.match(scheduledTaskDetailText({...paused,runState:'running'},1),/▶ Running · ⏸ Paused/)
+  assert.match(scheduledTaskDetailText({...paused,runState:'queued'},1),/◌ Queued · ⏸ Paused/)
   await scheduler.tick(owner,runs,due)
+  assert.ok(!(await runs.list()).some(r=>r.scheduled?.id==='paused'))
   // The empty conditional review consumes its occurrence without creating work.
-  assert.deepEqual(await names(),['expired','interrupted','once','recurring'])
+  assert.deepEqual(await names(),['expired','interrupted','once','paused','recurring'])
   const queued = (await runs.list()).find(r=>r.scheduled?.id==='once')!
-  const view = (await scheduler.listActiveReadOnly(await runs.list())).find(s=>s.id==='once')!
+  const view = (await scheduler.listTasksReadOnly(await runs.list())).find(s=>s.id==='once')!
   assert.equal(view.nextAt,null)
   assert.equal(view.runState,'queued')
   assert.match(scheduledTasksText([view],owner),/Queued/)
   await runs.patch(queued.id,{status:'running'})
-  assert.equal((await scheduler.listActiveReadOnly(await runs.list())).find(s=>s.id==='once')!.runState,'running')
+  assert.equal((await scheduler.listTasksReadOnly(await runs.list())).find(s=>s.id==='once')!.runState,'running')
   for (const run of await runs.list()) await runs.patch(run.id,run.scheduled?.id==='interrupted'
     ? {status:'failed',interrupted:true} : {status:'completed'})
   const before = await readdir(join(dir,'schedules'))
-  assert.deepEqual(await names(),['recurring'])
+  assert.deepEqual(await names(),['paused','recurring'])
   assert.deepEqual(await readdir(join(dir,'schedules')),before)
   // A held recurring revision remains hidden even when its cursor has a later occurrence.
   const interrupted = await scheduler.get('interrupted')
   assert.equal('everySeconds' in interrupted.trigger && interrupted.trigger.everySeconds,60)
   // A new schedule revision has its own occurrence; old terminal runs cannot hide it.
   await scheduler.save({...common,id:'once',name:'once',trigger:{at:new Date(due+60_000).toISOString()}})
-  assert.deepEqual(await names(),['once','recurring'])
+  assert.deepEqual(await names(),['once','paused','recurring'])
 })
 
 test('prompt preview is one bounded Unicode sentence and preserves stored input', async t => {
@@ -95,15 +103,15 @@ test('prompt preview is one bounded Unicode sentence and preserves stored input'
   const saved=await scheduler.save({id:'preview',name:'Preview',text,owner,
     execution:{...execution,preset:{...execution.preset,model:'gpt-5.6-terra',effort:'high'}},
     enabled:true,trigger:{at:'2027-01-01T00:00:00Z'}})
-  const output=scheduledTasksText(await scheduler.listActiveReadOnly([]),owner)
+  const output=scheduledTasksText(await scheduler.listTasksReadOnly([]),owner)
   assert.match(output,/gpt-5.6-terra · high/)
   assert.match(output,/Next · Fri, Jan 1 · 00:00 UTC/)
   assert.equal(Array.from(output.split('\n').at(-1)!.trim()).length,140)
   assert.ok(output.endsWith('…'))
   assert.doesNotMatch(output,/Do not display/)
   assert.equal((await scheduler.get(saved.id)).text,text)
-  const other=scheduledTasksText(await scheduler.listActiveReadOnly([]),{...owner,pairedAt:'other-pairing'})
-  assert.match(other,/No active scheduled tasks/)
+  const other=scheduledTasksText(await scheduler.listTasksReadOnly([]),{...owner,pairedAt:'other-pairing'})
+  assert.match(other,/No scheduled tasks/)
   assert.doesNotMatch(other,/Preview|🧪/)
 })
 
@@ -118,7 +126,7 @@ test('a legacy invalid selection does not prevent the active menu from rendering
   saved.execution.preset = {...saved.execution.preset,model:'gpt-5.6-terra',effort:'max'}
   await writeFile(file,JSON.stringify(saved))
 
-  const active = await scheduler.listActiveReadOnly([])
+  const active = await scheduler.listTasksReadOnly([])
   assert.match(scheduledTasksText(active,owner),/codex \(default login\) · gpt-5.6-terra · max/)
 })
 
@@ -128,7 +136,7 @@ test('detail view truncates long instructions and tolerates invalid timestamps',
   const scheduler = new Scheduler(dir)
   const saved = await scheduler.save({id:'long',name:'Long task',text:'/goal '+'x'.repeat(5000),owner,
     execution,enabled:true,trigger:{at:'2027-01-01T00:00:00Z'}})
-  const active = await scheduler.listActiveReadOnly([])
+  const active = await scheduler.listTasksReadOnly([])
   const detail = scheduledTaskDetailText(active.find(schedule => schedule.id === saved.id)!,1,1)
   assert.match(detail,/📅 1 of 1 · Long task/)
   assert.match(detail,/truncated; full text lives in the workspace/)
@@ -152,7 +160,7 @@ test('frequency describes saved rules without inventing a uniform interval for a
   ]
   for(const [i,[trigger,label]] of cases.entries()){
     const saved=await scheduler.save({id:`t-${i}`,name:`Task ${i}`,text:'Inspect saved work.',owner,execution,enabled:true,trigger})
-    const active=(await scheduler.listActiveReadOnly([])).find(s=>s.id===saved.id)!
+    const active=(await scheduler.listTasksReadOnly([])).find(s=>s.id===saved.id)!
     assert.ok(scheduledTasksText([active],owner).includes(`Schedule · ${label}\n`))
     assert.ok(scheduledTaskDetailText(active,1).includes(`Schedule\n${label}\n`))
   }

package/test/updates.test.mjs

@@ -573,10 +573,12 @@ for(const provider of ['pnpm','corepack']) test(`supervisor with only ${provider
  const interrupted=await read(path.join(jobPath(f.home,job.id),'job.json'));interrupted.status='applying';await atomic(path.join(jobPath(f.home,job.id),'job.json'),interrupted);
  await atomic(path.join(f.home,'registry.lock'),{pid:second.p.pid});
  const closed2=new Promise(r=>second.p.once('close',r));second.p.kill('SIGKILL');await closed2;
- const third=start();t.after(()=>third.p.kill('SIGTERM'));
+ const third=start(),closed3=new Promise(r=>third.p.once('close',r));t.after(()=>third.p.kill('SIGTERM'));
  await wait(async()=>{const j=await read(path.join(jobPath(f.home,job.id),'job.json'));return j.status==='rolled-back';});
  assert.equal((await read(path.join(f.home,'config.json'))).packageRoot,f.old);
- const closed3=new Promise(r=>third.p.once('close',r));third.p.kill('SIGTERM');assert.equal(await closed3,0,third.output());
+ // A rolled-back main update reloads automatically once native work is idle.
+ await wait(()=>third.p.exitCode!==null||third.p.signalCode!==null);
+ assert.equal(await closed3,0,third.output());
 });
 
 test('queued upgrades keep admission open while busy and release a raced or aborted pause',async t=>{
@@ -760,3 +762,35 @@ test('changed single-file broker binding retains full native drain and broker re
  assert.equal((await perform(f.home,job,{...r,refreshPluginBroker:true})).status,'completed');
  assert.equal(r.calls.filter(call=>call.includes('--force-recreate')).length,1);
 });
+
+test('handoff-compatible core upgrade builds with native work active and retires only at activation',async t=>{
+ const f=await fixture(t),job=await queued(f),r=runtime(f)
+ await fs.mkdir(path.join(f.agent.controlDir,'host-executor'),{recursive:true})
+ const claim=path.join(f.agent.controlDir,'host-executor','r_native.running.json')
+ await fs.writeFile(claim,'active native occurrence')
+ r.preserveRuns=true;r.retireHost=async()=>{assert.equal((await read(path.join(f.agent.controlDir,'upgrade-pause.json'))).id,job.id);r.calls.push(['retireHost'])}
+ const execute=r.execute
+ r.execute=async(command,args,options)=>{
+  if(args.includes('build')){await fs.access(claim);await assert.rejects(fs.access(path.join(f.agent.controlDir,'upgrade-pause.json')),{code:'ENOENT'});await assert.rejects(fs.access(path.join(f.home,'registry.lock')),{code:'ENOENT'})}
+  if(args.includes('stop')){
+   const backup=path.join(jobPath(f.home,job.id),'backup');
+   assert.equal(await fs.readFile(path.join(backup,'workspace','TOOLS.md'),'utf8'),'My notes\n','state backup finishes before relay shutdown');
+   await fs.access(path.join(backup,'control'));
+   await assert.rejects(fs.access(path.join(backup,'control','host-executor')),{code:'ENOENT'});
+  }
+  return execute(command,args,options)
+ }
+ assert.equal((await withUpgrade(f.agent.controlDir,job,new AbortController().signal,()=>perform(f.home,job,r),{preserveRuns:true,isIdle:async()=>false})).status,'completed')
+ assert.equal(r.calls.filter(c=>c[0]==='retireHost').length,1)
+ assert.ok(!r.calls.some(c=>c[0]==='stopHost'))
+ assert.equal(await fs.readFile(claim,'utf8'),'active native occurrence')
+ await assert.rejects(fs.access(path.join(f.agent.controlDir,'upgrade-pause.json')),{code:'ENOENT'})
+})
+
+test('failed handoff-compatible activation retires the candidate and rolls back without stopping native runs',async t=>{
+ const f=await fixture(t),job=await queued(f),r=runtime(f,{fail:(_command,args)=>args.includes('up')})
+ r.preserveRuns=true;r.retireHost=async()=>r.calls.push(['retireHost'])
+ assert.equal((await perform(f.home,job,r)).status,'rolled-back')
+ assert.equal(r.calls.filter(c=>c[0]==='retireHost').length,2)
+ assert.ok(!r.calls.some(c=>c[0]==='stopHost'))
+})