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

package/test/ai.test.ts

@@ -106,13 +106,17 @@ test('OpenCode keeps same-provider models together and separates providers encod
     const other = { ...first, id: 'other', name: 'Other', model: 'openrouter/other' }
     const choice = await store.captureChoice(first)
     await store.saveNativeSession(choice.sessionId, 'ses_original')
-    const menu = createAiMenu(store, 'opencode', async () => [first, second, other].map(p => ({ ...p, efforts: [] })), dir, undefined, async () => true)
+    const closed: string[] = []
+    const menu = createAiMenu(store, 'opencode', async () => [first, second, other].map(p => ({ ...p, efforts: [] })), dir, undefined, async () => true,
+      undefined, async (session) => { if (session) closed.push(session.sessionId) })
     await store.savePreset(second)
     assert.equal((await menu.select(second, choice.sessionId)).fresh, false)
+    assert.deepEqual(closed, [])
     assert.equal((await store.captureChoice(first)).sessionId, choice.sessionId)
     await store.savePreset(other)
     assert.equal(await store.selectPreset(other.id, choice.sessionId), false)
     assert.equal((await menu.select(other, choice.sessionId)).fresh, true)
+    assert.deepEqual(closed, [choice.sessionId]) // switching provider closes the old conversation once
     const next = await store.captureChoice(first)
     assert.notEqual(next.sessionId, choice.sessionId)
     assert.equal((await store.executionSession(next)).nativeSessionId, undefined)
@@ -519,7 +523,7 @@ test('opencode model and variant selections validate against the installed catal
   await validateSelection({ id: 'default', name: 'Default', cli: 'opencode', model: 'opencode/big-pickle' }, catalog, available)
   await assert.rejects(
     validateSelection({ id: 'bad', name: 'Bad', cli: 'opencode', model: 'opencode/ling-free', effort: 'max' }, catalog, available),
-    /installed client catalog/)
+    /Effort max is not supported.*low, medium/)
   await assert.rejects(
     validateSelection({ id: 'missing', name: 'Missing', cli: 'opencode', model: 'opencode/unknown' }, catalog, available),
     /installed client catalog/)
@@ -627,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}) }
@@ -644,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}) }
 })
 
@@ -672,3 +698,45 @@ test('Claude catalog projects only aliases and efforts from the installed native
   await validateSelection({ id: 'c', name: 'c', cli: 'claude', model: 'opus', effort: 'xhigh' }, models, async () => true)
   await assert.rejects(validateSelection({ id: 'c', name: 'c', cli: 'claude', model: 'opus-guess' }, models, async () => true), /not in the installed client catalog/)
 })
+
+test('Telegram Sonnet choice survives restart and reaches the native launch without Opus substitution', async () => {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-sonnet-selection-'))
+  const priorPath = process.env.PATH
+  try {
+    const store = new ControlStore(dir, 1000)
+    await store.captureChoice({id:'opus',name:'Opus',cli:'claude',model:'opus',effort:'xhigh'})
+    const models = [{cli:'claude',model:'opus',name:'Opus',efforts:['xhigh']},
+      {cli:'claude',model:'sonnet',name:'Sonnet',efforts:['low','medium','high']}]
+    const menu = createAiMenu(store, 'claude', async()=>models, dir, undefined, async()=>true)
+    const replies: Array<{text:string; buttons:Array<{text:string;callback_data:string}>}> = []
+    const context = (data?:string) => ({callbackQuery:data ? {data} : undefined,answerCallbackQuery:async()=>({}),
+      reply:async(text:string, options?:{reply_markup?:{inline_keyboard?:Array<Array<{text:string;callback_data:string}>>}})=>{
+        replies.push({text,buttons:options?.reply_markup?.inline_keyboard?.flat() ?? []});return {} as never
+      }})
+    const click = async(text:string) => menu.handle(context(replies.at(-1)!.buttons.find(b=>b.text===text)!.callback_data) as never)
+    await menu.list(context() as never)
+    await click('claude');await click('Sonnet');await click('high')
+    const restarted = new ControlStore(dir,1000)
+    const captured = await restarted.captureChoice(menu.initial)
+    assert.equal(captured.preset.model,'sonnet');assert.equal(captured.preset.effort,'high')
+    const before = await restarted.status()
+    await assert.rejects(menu.saveSelection(models[1], 'xhigh'), /Effort xhigh is not supported.*low, medium, high/)
+    await assert.rejects(validateSelection({id:'s',name:'Sonnet',cli:'claude',model:'sonnet',effort:'high'}, [], async()=>true), /No models advertised for claude.*current selection unchanged/)
+    assert.deepEqual(await restarted.status(), before)
+    const {ownerRun} = await import('./helpers/owner-run.js')
+    const {startExecutorJob} = await import('../src/executor.js')
+    await mkdir(join(dir,'bin'))
+    await writeFile(join(dir,'bin','claude'), `#!${process.execPath}\nrequire('fs').writeFileSync('launched.json',JSON.stringify(process.argv.slice(2)));require('fs').readFileSync(0,'utf8')`, {mode:0o700})
+    process.env.PATH = join(dir,'bin') + ':' + priorPath
+    await ownerRun(dir,'r_sonnet_selected')
+    const job = await startExecutorJob(['synthetic request'], {workspace:dir,controlDir:dir,binDir:join(dir,'bin'),runId:'r_sonnet_selected',timeoutMs:5000,repairEnabled:false,
+      cli:captured.preset.cli,model:captured.preset.model,effort:captured.preset.effort,sessionId:captured.sessionId})
+    const closed = new Promise<number|null>(resolve=>job.child.once('close',resolve))
+    assert.equal(await closed,0)
+    assert.deepEqual(JSON.parse(await readFile(join(dir,'launched.json'),'utf8')).slice(-4), ['--model','sonnet','--effort','high'])
+    await job.cleanup()
+  } finally {
+    if (priorPath === undefined) delete process.env.PATH; else process.env.PATH = priorPath
+    await rm(dir,{recursive:true,force:true})
+  }
+})

package/test/application-channel.test.ts

@@ -450,3 +450,27 @@ test('administrator task grant replacement preserves the runtime file owner', {s
     const disabled=await stat(file);assert.equal(disabled.uid,20000);assert.equal(disabled.gid,20000)
   }finally{await rm(dir,{recursive:true,force:true})}
 })
+
+test('empty server Claude catalog rejects Sonnet chat selection without changing Opus xhigh', async t => {
+  const root = await mkdtemp(join(tmpdir(),'ez-app-missing-claude-'))
+  t.after(()=>rm(root,{recursive:true,force:true}))
+  const owned = await owner(root), control = new ControlStore(root,1000)
+  const initial = {id:'opus',name:'Opus',cli:'claude',model:'opus',effort:'xhigh'}
+  await control.captureChoice(initial)
+  const {createAiMenu} = await import('../src/menu.js')
+  let models: import('../src/ai.js').ModelChoice[] = []
+  const menu = createAiMenu(control,'claude',async()=>models,root,undefined,async()=>true)
+  const channel = new ApplicationChannel({controlDir:root,initial,wake:()=>{},cancel:async()=>{},aiControls:menu})
+  const binding = (await channel.bindings.register('app',token(),owned,true))!
+  const before = await control.status()
+  const input = {action:'model',expectedSession:before.activeSession!.sessionId,cli:'claude',model:'sonnet',effort:'high'}
+  await assert.rejects(channel.changeControls(binding.bindingId,input), /No models advertised for claude.*current selection unchanged/)
+  assert.deepEqual(await control.status(),before)
+  models = [{cli:'claude',model:'sonnet',name:'Sonnet',efforts:['low','medium','high']}]
+  await assert.rejects(channel.changeControls(binding.bindingId,{...input,effort:'xhigh'}), /Effort xhigh is not supported.*low, medium, high/)
+  assert.deepEqual(await control.status(),before)
+  await channel.changeControls(binding.bindingId,input)
+  const admitted = await channel.submit(binding.bindingId,{requestId:'sonnet',scope:'chat',text:'Synthetic request',followTelegram:true})
+  assert.equal(admitted.execution!.preset.model,'sonnet')
+  assert.equal(admitted.execution!.preset.effort,'high')
+})

package/test/application-controls.test.ts

@@ -53,7 +53,8 @@ test('private scope reset and model controls preserve running sessions and share
     {cli:'codex',model:'fixture-model',name:'Fixture',efforts:['low','high']},
     {cli:'opencode',model:'fixture-other',name:'Other',efforts:[]},
   ],root,join(root,'native-home'),async()=>true)
-  const channel = new ApplicationChannel({controlDir:root,initial:menu.initial,aiControls:menu,wake:()=>{},cancel:async()=>{}})
+  const closed:string[] = []
+  const channel = new ApplicationChannel({controlDir:root,initial:menu.initial,aiControls:menu,wake:()=>{},cancel:async()=>{},closeSession:async session=>{if(session)closed.push(session.sessionId)}})
   t.after(async()=>{await channel.stop();await rm(root,{recursive:true,force:true})})
   const token = randomBytes(32).toString('base64url')
   const binding = (await channel.bindings.register('private',token,owner))!
@@ -77,6 +78,7 @@ test('private scope reset and model controls preserve running sessions and share
   assert.equal((await call({action:'new',expectedSession:before.activeSessionId})).status,200)
   const next = await channel.scopeControls(binding.bindingId,'exercise')
   assert.notEqual(next.activeSessionId,before.activeSessionId)
+  assert.deepEqual(closed,[]) // a private scope runs under its binding, so no owner-authority close turn
   assert.equal(next.ai.selectedId,menu.initial.id)
   assert.equal((await call({action:'new',expectedSession:before.activeSessionId})).status,400)
   assert.equal((await control.executionSession(run.execution!)).nativeSessionId,'native-private')
@@ -89,6 +91,7 @@ test('private scope reset and model controls preserve running sessions and share
   assert.deepEqual((await control.status()).ai!.presets,presets)
   assert.equal((await call({action:'model',expectedSession:next.activeSessionId,cli:'codex',model:'fixture-model',effort:'high'})).status,200)
   const updated = await channel.submit(binding.bindingId,{requestId:'updated-model',scope:'exercise',text:'same engine'})
+  assert.deepEqual(closed,[])
   assert.equal(updated.execution!.sessionId,next.activeSessionId)
   assert.equal(updated.execution!.preset.effort,'high')
   assert.deepEqual((await new RunStore(root).get(after.id))!.execution,after.execution)

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

@@ -1,6 +1,6 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { randomBytes } from 'node:crypto'
+import { randomBytes, randomUUID } from 'node:crypto'
 import { mkdtemp, readdir, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -17,6 +17,8 @@ import { atomicTaskFile, Tasks } from '../src/tasks.js'
 import { EventSources } from '../src/event-sources.js'
 import { ownerRun } from './helpers/owner-run.js'
 import { packageVersion } from '../src/version.js'
+import { SESSION_CLOSE_PROMPT } from '../src/session-close.js'
+import type { ExecutorOptions } from '../src/executor.js'
 import type { Config } from '../src/config.js'
 
 const message = (id: number, text = 'hello'): Update => ({
@@ -32,6 +34,7 @@ const message = (id: number, text = 'hello'): Update => ({
 const fixture = async (overrides: Partial<Config> = {}) => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-intake-relay-'))
   const launched: string[][] = []
+  const launchOptions: ExecutorOptions[] = []
   const replies: string[] = []
   const members = new Map<number, string>()
   const keyboards: { text: string; callback_data: string }[][][] = []
@@ -47,8 +50,9 @@ const fixture = async (overrides: Partial<Config> = {}) => {
     ...overrides,
   }
   const make = () => {
-    const relay = createRelay(config, async (texts) => {
+    const relay = createRelay(config, async (texts, options) => {
       launched.push(texts)
+      launchOptions.push(options)
       const child = spawn(process.execPath, ['-e', 'setTimeout(() => {}, 50)'])
       children.push(child)
       await once(child, 'spawn')
@@ -79,6 +83,7 @@ const fixture = async (overrides: Partial<Config> = {}) => {
   return {
     dir,
     launched,
+    launchOptions,
     replies,
     members,
     keyboards,
@@ -290,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)
@@ -336,6 +341,35 @@ test('new conversation leaves already accepted messages pinned to the old conver
   } finally { await f.close() }
 })
 
+test('new conversation gives the started one a single silent close turn in its own native session', async () => {
+  const f = await fixture()
+  try {
+    const runs = new RunStore(f.dir), store = new ControlStore(f.dir, 1000)
+    const settled = async () => {
+      for (let i = 0; i < 200 && (await runs.list()).some((r) => ['queued', 'running'].includes(r.status)); i++)
+        await new Promise((resolve) => setTimeout(resolve, 10))
+    }
+    await f.relay.bot.handleUpdate(message(1, '/new'))
+    assert.equal(f.launched.length, 0) // an unstarted conversation has nothing to keep
+    await f.relay.bot.handleUpdate(message(2, 'My sister is called Ana'))
+    await f.relay.drainInbox(true)
+    await settled()
+    const first = (await store.getActiveSession())!
+    assert.equal(first.hasStarted, true)
+    await f.relay.bot.handleUpdate(message(3, '/new'))
+    await settled()
+    assert.deepEqual(f.launched.at(-1), [SESSION_CLOSE_PROMPT])
+    const close = (await runs.list()).find((r) => r.sessionClose)!
+    assert.equal(close.execution!.sessionId, first.sessionId)
+    assert.equal(close.chatId, undefined); assert.equal(close.messageId, undefined)
+    const options = f.launchOptions.at(-1)!
+    assert.equal(options.isResume, true)
+    assert.equal(options.promptSuffix, '') // no reply mechanism: nothing is delivered
+    assert.notEqual((await store.getActiveSession())!.sessionId, first.sessionId)
+    assert.equal((await runs.list()).filter((r) => r.sessionClose).length, 1)
+  } finally { await f.close() }
+})
+
 test('accepted DM survives relay restart and duplicate delivery creates exactly one run', async () => {
   const f = await fixture()
   try {
@@ -752,3 +786,37 @@ test('tasks command never reaches the executor on invalid input or foreign sende
     assert.equal(f.launched.length, 0)
   } finally { await f.close() }
 })
+
+test('tasks list and detail show saved frequency and ordered setup path without changing or launching work',async()=>{
+  const f=await fixture()
+  try{
+    const {Scheduler}=await import('../src/scheduler.js')
+    const control=new ControlStore(f.dir,1000),scheduler=new Scheduler(f.dir)
+    const preset={id:'primary',name:'Primary',cli:'claude',model:'opus',effort:'high'}
+    const fallbacks=[
+      {...preset,id:'second',authProfile:'claude2'},
+      {id:'third',name:'Third',cli:'codex',authProfile:'work',model:'gpt-6-sol',effort:'xhigh'},
+      {id:'fourth',name:'Fourth',cli:'pi',model:'anthropic/claude-sonnet',effort:'medium'}]
+    const saved=await scheduler.save({id:'analyst',name:'Analyst',text:'Read the saved role.',owner:(await control.status()).owner!,
+      execution:{sessionId:randomUUID(),preset,fallbacks},
+      enabled:true,trigger:{cron:'*/30 * * * *',timezone:'America/New_York',start:'2027-01-01T00:00:00Z'}})
+    const path='claude (default login) · opus · high → claude@claude2 · opus · high → codex@work · gpt-6-sol · xhigh → pi · anthropic/claude-sonnet · medium'
+    await f.relay.bot.handleUpdate(message(1,'/tasks'))
+    const list=f.replies.at(-1)!
+    assert.ok(list.includes('Schedule · Every 30 minutes · America/New_York'))
+    assert.ok(list.includes(`Execution · ${path}`))
+    await f.relay.bot.handleUpdate(message(2,'/tasks 1'))
+    const detail=f.replies.at(-1)!
+    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/model-policy.test.ts

@@ -17,7 +17,7 @@ test('engine defaults stay omitted and explicit native settings survive every ad
   const preset={id:'chosen',name:'Chosen',cli,model:'native-model',effort:'ultra'}
   assert.deepEqual(executionDefaults(cli,preset),preset)
   await validateSelection(preset,[{cli,model:'native-model',name:'Native',efforts:['ultra']}],async()=>true)
-  await assert.rejects(validateSelection({...preset,effort:'unsupported'},[{cli,model:'native-model',name:'Native',efforts:['ultra']}],async()=>true),/installed client catalog/)
+  await assert.rejects(validateSelection({...preset,effort:'unsupported'},[{cli,model:'native-model',name:'Native',efforts:['ultra']}],async()=>true),/Effort unsupported is not supported.*Supported efforts: ultra/)
   assert.throws(()=>executionDefaults(cli,{effort:'bad option'}),/Invalid reasoning effort/)
  }
  assert.deepEqual(executionOverrides('codex',{model:'old',effort:'max'},'new'),{model:'new',effort:undefined})

package/test/plugin-broker.test.mjs

@@ -103,7 +103,8 @@ test('isolated broker authenticates an owned run, pins plugin revision, and writ
     assert.deepEqual(JSON.parse(listed.stdout), { sample: 'sample' });
     const detailed = await request(f.socket, { version: 1, id: randomUUID(), operation: 'manager', runId: f.runId, args: ['tools', 'list', '--details'] });
     assert.equal(detailed.ok, true);
-    assert.deepEqual(JSON.parse(detailed.stdout).sample.commands, ['ez sample --help']);
+    assert.deepEqual(JSON.parse(detailed.stdout).sample.aliases, ['sample']);
+    assert.equal(JSON.parse(detailed.stdout).sample.example, 'ez sample --help');
     assert.deepEqual(JSON.parse(detailed.stdout).sample.skillReads, [['ez', 'tools', 'skill', 'sample', 'SKILL.md']]);
     const skill = await request(f.socket, { version: 1, id: randomUUID(), operation: 'manager', runId: f.runId, args: ['tools', 'skill', 'sample', 'SKILL.md'] });
     assert.equal(skill.code, 0);
@@ -249,3 +250,49 @@ test('task launch broker admits only its fixed application command and writes no
     const revoked=await request(f.socket,{version:1,id:randomUUID(),operation:'task-launch',runId:taskRun,stdin:JSON.stringify(input)});assert.equal(revoked.ok,false);
   }finally{abort.abort();await serving;process.env.PATH=oldPath;await ledger.stop();provider.closeAllConnections();await new Promise(r=>provider.close(r));}
 });
+
+// Native engines and Node scripts wire child stdin as a socket they may never
+// close. The isolated client must reach the broker instead of waiting for EOF,
+// while pipes and files still deliver their complete input.
+test('isolated client does not wait forever on an inherited open stdin socket', async t => {
+  const { createServer: createSocketServer } = await import('node:net');
+  const { spawn } = await import('node:child_process');
+  const { once } = await import('node:events');
+  const root = await fs.realpath(await fs.mkdtemp(path.join(tmpdir(), 'e-')));
+  t.after(() => fs.rm(root, { recursive: true, force: true }));
+  const socket = path.join(root, 'b.sock'), invokes = [];
+  const broker = createSocketServer(connection => {
+    let buffer = '';
+    connection.on('data', chunk => {
+      buffer += chunk;
+      if (!buffer.includes('\n')) return;
+      const frame = JSON.parse(buffer);
+      if (frame.operation === 'invoke') invokes.push(frame);
+      connection.end(JSON.stringify(frame.operation === 'resolve' ? { ok: true, revision, capability: 'c'.repeat(64) } : { ok: true, code: 0, stdout: 'ok' }) + '\n');
+    });
+  });
+  await new Promise(resolve => broker.listen(socket, resolve));
+  t.after(() => broker.close());
+  const client = new URL('../bin/ez', import.meta.url).pathname;
+  const env = { PATH: process.env.PATH, EZ_PLUGIN_BROKER_SOCKET: socket, EZ_RUN_ID: 'r_client' };
+  const finish = async child => {
+    let stdout = '';
+    child.stdout.on('data', chunk => stdout += chunk);
+    const timer = setTimeout(() => child.kill('SIGKILL'), 10_000);
+    const [code, signal] = await once(child, 'close');
+    clearTimeout(timer);
+    return { code, signal, stdout };
+  };
+  const open = spawn(process.execPath, [client, 'sample', 'read'], { env });
+  t.after(() => open.kill('SIGKILL'));
+  assert.deepEqual(await finish(open), { code: 0, signal: null, stdout: 'ok' });
+  assert.deepEqual(invokes.at(-1).args, ['read']);
+  assert.equal(invokes.at(-1).stdin, undefined);
+  const supplied = spawn(process.execPath, [client, 'sample', 'write'], { env });
+  supplied.stdin.end('payload');
+  assert.equal((await finish(supplied)).code, 0);
+  assert.equal(invokes.at(-1).stdin, 'payload');
+  const piped = spawn('/bin/sh', ['-c', '(sleep 1.5; printf late) | "$0" "$1" sample pipe', process.execPath, client], { env, stdio: ['ignore', 'pipe', 'inherit'] });
+  assert.equal((await finish(piped)).code, 0);
+  assert.equal(invokes.at(-1).stdin, 'late');
+});