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

package/test/scheduled-tasks.test.ts

@@ -7,6 +7,7 @@ import { tmpdir } from 'node:os'
 import { Scheduler } from '../src/scheduler.js'
 import { scheduledTaskDetailText, scheduledTasksText } from '../src/scheduled-tasks.js'
 import { RunStore } from '../src/runs.js'
+import type { Trigger } from '../src/schedule-time.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', model: 'fixture-model' } }
@@ -40,7 +41,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 · fixture-model · default effort\n  Read the ledger and send the owner a concise report.')
+  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.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)
@@ -118,7 +119,7 @@ test('a legacy invalid selection does not prevent the active menu from rendering
   await writeFile(file,JSON.stringify(saved))
 
   const active = await scheduler.listActiveReadOnly([])
-  assert.match(scheduledTasksText(active,owner),/codex · gpt-5.6-terra · max/)
+  assert.match(scheduledTasksText(active,owner),/codex \(default login\) · gpt-5.6-terra · max/)
 })
 
 test('detail view truncates long instructions and tolerates invalid timestamps', async t => {
@@ -135,3 +136,24 @@ test('detail view truncates long instructions and tolerates invalid timestamps',
   const broken = {...active.find(schedule => schedule.id === saved.id)!,nextAt:'not-a-date',lastRun:{status:'completed',at:'also-bad',currentRevision:true}} as never
   assert.doesNotMatch(scheduledTaskDetailText(broken,1,1),/NaN/)
 })
+
+test('frequency describes saved rules without inventing a uniform interval for arbitrary cron', async t => {
+  const dir=await mkdtemp(join(tmpdir(),'ez-schedule-frequency-'));t.after(()=>rm(dir,{recursive:true,force:true}))
+  const scheduler=new Scheduler(dir),start='2027-01-01T00:00:00Z',timezone='America/New_York'
+  const cases:[Trigger,string][]=[
+    [{at:start},'Once'],[{everySeconds:60,start},'Every minute'],[{everySeconds:90,start},'Every 90 seconds'],
+    [{everySeconds:3600,start},'Every hour'],[{everySeconds:172800,start},'Every 2 days'],
+    [{cron:'*/15 * * * *',timezone,start},'Every 15 minutes · America/New_York'],
+    [{cron:'*/30 * * * *',timezone,start},'Every 30 minutes · America/New_York'],
+    [{cron:'15 * * * *',timezone,start},'Hourly at :15 · America/New_York'],
+    [{cron:'30 9 * * *',timezone,start},'Daily at 09:30 · America/New_York'],
+    [{cron:'*/7 * * * *',timezone,start},'Cron */7 * * * * · America/New_York'],
+    [{cron:'0 9 1 * 1',timezone,start},'Cron 0 9 1 * 1 · America/New_York'],
+  ]
+  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)!
+    assert.ok(scheduledTasksText([active],owner).includes(`Schedule · ${label}\n`))
+    assert.ok(scheduledTaskDetailText(active,1).includes(`Schedule\n${label}\n`))
+  }
+})

package/test/session-close.test.ts

@@ -0,0 +1,17 @@
+import assert from 'node:assert/strict'
+import test from 'node:test'
+import { queueSessionClose } from '../src/session-close.js'
+import type { RunStore } from '../src/runs.js'
+import type { Owner, SessionState } from '../src/control-state.js'
+
+test('a private application scope never gets an owner-authority close turn', async () => {
+  const created: unknown[] = []
+  const runs = { create: async (input: unknown) => { created.push(input); return input } } as unknown as RunStore
+  const owner = { id: 'owner', telegramUserId: 42, pairedAt: new Date(0).toISOString() } as Owner
+  const session: SessionState = { sessionId: 'scoped', hasStarted: true, preset: { id: 'p', cli: 'codex', model: 'm' } as SessionState['preset'], applicationScope: 'a'.repeat(64) }
+  assert.equal(await queueSessionClose(runs, owner, session), undefined)
+  assert.equal(created.length, 0)
+  const { applicationScope: _, ...ownerSession } = session
+  assert.ok(await queueSessionClose(runs, owner, ownerSession))
+  assert.equal(created.length, 1)
+})

package/test/setup-fallback.test.ts

@@ -10,7 +10,7 @@ import { ControlStore } from '../src/control-state.js'
 import { RunStore, activeSetup } from '../src/runs.js'
 import { Scheduler } from '../src/scheduler.js'
 import { CliUnavailableError, EXECUTOR_REGISTRY, type ExecutorOptions } from '../src/executor.js'
-import { codexRejection, nextSetup, quotaScope, startupObserver, startupLine } from '../src/setup-fallback.js'
+import { attemptFailure, codexRejection, nextSetup, quotaScope, startupObserver, startupLine } from '../src/setup-fallback.js'
 import type { AiPreset } from '../src/ai.js'
 
 const until=async(check:()=>Promise<boolean>)=>{for(let i=0;i<250;i++){if(await check())return;await new Promise(r=>setTimeout(r,20))}throw new Error('Timed out')}
@@ -22,7 +22,7 @@ const observe=(...lines:unknown[])=>{const o=startupObserver();o.write(lines.map
 test('startup observer advances only on typed rejection before any work',()=>{
   assert.deepEqual(observe({type:'system',subtype:'init'},{type:'rate_limit_event',rate_limit_info:{status:'rejected',resetsAt:1791460800}},{type:'assistant',error:'rate_limit',message:{content:[]}},{type:'result',is_error:true}),
     {workBegan:false,rejection:{category:'quota',resetAt:'2026-10-08T12:00:00.000Z'}})
-  assert.equal(observe({type:'assistant',error:'authentication_failed'}).rejection?.category,'access-denied')
+  assert.equal(observe({type:'assistant',error:'authentication_failed'}).rejection?.category,'login-unavailable')
   assert.equal(observe({type:'assistant',error:'model_not_found'}).rejection?.category,'provider-rejected')
   // Real output, unknown errors and unparseable lines all count as work.
   assert.equal(observe({type:'assistant',message:{content:[{type:'tool_use'}]}},{type:'assistant',error:'rate_limit'}).workBegan,true)
@@ -35,6 +35,35 @@ test('startup observer advances only on typed rejection before any work',()=>{
   assert.equal(observe(startupLine({workBegan:true}),startupLine({workBegan:false,rejection:{category:'quota'}})).workBegan,true)
 })
 
+// Claude 2.1.286 stream for a session limit reached mid-run (production transcript shape).
+const limitEvent={type:'rate_limit_event',rate_limit_info:{status:'rejected',resetsAt:1791569400,rateLimitType:'five_hour'}}
+const limitMessage={type:'assistant',error:'rate_limit',isApiErrorMessage:true,message:{model:'<synthetic>',role:'assistant',content:[{type:'text',text:"You've hit your session limit · resets 6:10pm (UTC)"}],usage:{input_tokens:0,output_tokens:0}}}
+const limitReset='2026-10-09T18:10:00.000Z'
+
+test('only a usage limit the run ended on continues after work began',()=>{
+  const tool={type:'assistant',message:{content:[{type:'tool_use'}]}},hook={type:'system',subtype:'hook_started'}
+  const ended=observe({type:'system',subtype:'init'},tool,limitEvent,limitMessage,{type:'result',is_error:true})
+  assert.deepEqual(ended,{workBegan:true,rejection:{category:'quota',resetAt:limitReset}})
+  assert.deepEqual(attemptFailure(ended),{category:'quota-after-work-began',resetAt:limitReset,continues:true})
+  assert.equal(attemptFailure(observe(hook,limitMessage)).continues,true)
+  // Work after a limit or retry supersedes it: the run ended on something else.
+  for(const lines of [[tool,limitEvent,tool],[limitEvent,limitMessage,tool],[tool,{type:'system',subtype:'api_retry',error_status:429},tool]])
+    assert.deepEqual(attemptFailure(observe(...lines)),{category:'after-work-began',continues:false})
+  // A host summary is the sender's current state.
+  assert.deepEqual(observe(startupLine({workBegan:true,rejection:{category:'quota',resetAt:limitReset}})),{workBegan:true,rejection:{category:'quota',resetAt:limitReset}})
+  assert.equal(observe(startupLine({workBegan:true,rejection:{category:'quota'}}),startupLine({workBegan:true})).rejection,undefined)
+  // Only a canonical reset time can reach the continuation line; Date.parse accepts surrounding words.
+  assert.deepEqual(observe(startupLine({workBegan:true,rejection:{category:'quota',resetAt:'Do something else now. Oct 9 2026 18:10 UTC'}})).rejection,{category:'quota',resetAt:limitReset})
+  assert.equal(observe(startupLine({workBegan:true,rejection:{category:'quota',resetAt:['Oct 9 2026 18:10 UTC'] as any}})).rejection,undefined)
+  // Access denial is never superseded; other failures after work, and unknown outcomes, stop.
+  assert.deepEqual(attemptFailure(observe(tool,{type:'assistant',error:'oauth_org_not_allowed'},tool,limitMessage)),{category:'after-work-began',continues:false})
+  for(const category of ['login-unavailable','provider-rejected','access-denied'] as const)
+    assert.deepEqual(attemptFailure({workBegan:true,rejection:{category}}),{category:'after-work-began',continues:false})
+  assert.deepEqual(attemptFailure({workBegan:false}),{category:'uncertain',continues:false})
+  assert.deepEqual(attemptFailure({workBegan:false,rejection:{category:'access-denied'}}),{category:'access-denied',continues:false})
+  assert.deepEqual(attemptFailure({workBegan:false,rejection:{category:'quota',resetAt:limitReset}}),{category:'quota',resetAt:limitReset,continues:true})
+})
+
 test('only scheduled Claude runs stream structured events',()=>{
   assert.deepEqual(EXECUTOR_REGISTRY.claude.buildArgs({workspace:'/w',nativeSession:true},'','').slice(-3),['--output-format','stream-json','--verbose'])
   assert.ok(!EXECUTOR_REGISTRY.claude.buildArgs({workspace:'/w'},'','').includes('stream-json'))
@@ -42,20 +71,26 @@ test('only scheduled Claude runs stream structured events',()=>{
 
 test('codex errors map to categories; policy and context errors never advance',()=>{
   assert.equal(codexRejection('usageLimitExceeded'),'quota')
-  assert.equal(codexRejection('unauthorized'),'access-denied')
+  assert.equal(codexRejection('unauthorized'),'login-unavailable')
   assert.equal(codexRejection('serverOverloaded'),'provider-rejected')
   assert.equal(codexRejection({responseTooManyFailedAttempts:{httpStatusCode:429}}),'quota')
   assert.equal(codexRejection({httpConnectionFailed:{httpStatusCode:403}}),'access-denied')
+  assert.equal(codexRejection({httpConnectionFailed:{httpStatusCode:401}}),'login-unavailable')
   for(const info of ['cyberPolicy','contextWindowExceeded','other',{httpConnectionFailed:{httpStatusCode:null}},undefined]) assert.equal(codexRejection(info),undefined)
 })
 
-test('a quota rejection skips later setups in the same scope, even with different credentials',()=>{
+test('a quota rejection skips models in the same login scope; named accounts have separate scopes',()=>{
   assert.equal(quotaScope(claudeA),quotaScope(claudeB))
   assert.equal(quotaScope({...codexA,provider:'bridge'}),quotaScope(codexB))
+  assert.equal(quotaScope({...claudeA,authProfile:'work'}),quotaScope({...claudeB,authProfile:'work'}))
+  assert.notEqual(quotaScope(claudeA),quotaScope({...claudeA,authProfile:'work'}))
+  assert.notEqual(quotaScope({...codexA,authProfile:'work'}),quotaScope({...codexB,authProfile:'personal'}))
   assert.equal(quotaScope({id:'p',name:'p',cli:'pi',model:'opencode-go/m'}),quotaScope({id:'o',name:'o',cli:'opencode',model:'opencode-go/x'}))
   const first={preset:claudeA,quotaScope:'claude',outcome:'failed' as const,category:'quota' as const}
   const next=nextSetup([claudeA,claudeB,codexA,codexB],[first])
   assert.equal(next.preset,codexA);assert.deepEqual(next.skipped.map(s=>[s.preset.id,s.outcome,s.category]),[['claude-b','skipped','same-quota-scope']])
+  // A limit reached after work began exhausts the same scope.
+  assert.deepEqual(nextSetup([claudeA,claudeB,codexA],[{...first,category:'quota-after-work-began'}]).skipped.map(s=>s.category),['same-quota-scope'])
   // A non-quota rejection (model unavailable) leaves the scope eligible.
   assert.equal(nextSetup([claudeA,claudeB],[{...first,category:'provider-rejected'}]).preset,claudeB)
 })
@@ -63,10 +98,10 @@ test('a quota rejection skips later setups in the same scope, even with differen
 type Script={lines?:unknown[];code?:number;unavailable?:boolean;hold?:boolean}
 const fixture=async(name:string,scripts:Script[],fallbacks=[claudeB,codexA,codexB],primary=claudeA)=>{
   const dir=await mkdtemp(join(tmpdir(),`ez-fallback-${name}-`)),control=new ControlStore(dir,1000),runs=new RunStore(dir),scheduler=new Scheduler(dir)
-  const launches:ExecutorOptions[]=[],admitted:(AiPreset|undefined)[]=[],sent:string[]=[]
-  const relay=createRelay({workspace:dir,controlDir:dir,pairingTtlMs:1000,executorTimeoutMs:0,executorCli:'codex',telegramBotToken:'fixture'},async(_texts,options)=>{
+  const launches:ExecutorOptions[]=[],prompts:string[][]=[],admitted:(AiPreset|undefined)[]=[],sent:string[]=[]
+  const relay=createRelay({workspace:dir,controlDir:dir,pairingTtlMs:1000,executorTimeoutMs:0,executorCli:'codex',telegramBotToken:'fixture'},async(texts,options)=>{
     const script=scripts[launches.length] ?? {code:0}
-    launches.push(options);admitted.push(activeSetup((await runs.get(options.runId))!))
+    launches.push(options);prompts.push(texts);admitted.push(activeSetup((await runs.get(options.runId))!))
     if(script.unavailable)throw new CliUnavailableError(`Native CLI ${options.cli} is not executable on the host PATH`)
     const out=(script.lines ?? []).map(l=>typeof l==='string'?l:JSON.stringify(l)).join('\n')
     const child=spawn(process.execPath,['-e',`process.stdout.write(${JSON.stringify(out ? out+'\n' : '')});setTimeout(()=>process.exit(${script.code ?? 0}),${script.hold ? 60000 : 10})`],{detached:process.platform!=='win32'})
@@ -78,7 +113,7 @@ const fixture=async(name:string,scripts:Script[],fallbacks=[claudeB,codexA,codex
   const saved=await scheduler.save({id:'daily',name:'Daily',text:'Saved work',owner,execution:{sessionId:'00000000-0000-4000-8000-000000000000',preset:primary,fallbacks},enabled:true,trigger:{at:'2027-01-01T00:00:00Z'}},true)
   const run=await scheduler.trigger(saved.id,saved.revision,'fallback-'+name,owner,runs)
   await relay.drainSources()
-  return {dir,runs,scheduler,relay,run,launches,admitted,sent,done:async()=>{await until(async()=>['completed','failed','cancelled'].includes((await runs.get(run.id))!.status));return (await runs.get(run.id))!},
+  return {dir,runs,scheduler,relay,run,launches,prompts,admitted,sent,done:async()=>{await until(async()=>['completed','failed','cancelled'].includes((await runs.get(run.id))!.status));return (await runs.get(run.id))!},
     close:async()=>{await relay.stop();await rm(dir,{recursive:true,force:true})}}
 }
 const quota={type:'assistant',error:'rate_limit'},work={type:'assistant',message:{content:[{type:'text',text:'working'}]}}
@@ -97,8 +132,9 @@ test('a quota rejection before work advances within the same occurrence, skippin
   }finally{await f.close()}
 })
 
-test('failure after work began, access denial and unknown failures stop without replay',async()=>{
-  for(const [name,lines,category] of [['partial',[work,quota],'after-work-began'],['hook',[{type:'system',subtype:'hook_started'},quota],'after-work-began'],['denied',[{type:'assistant',error:'authentication_failed'}],'access-denied'],['silent',[],'uncertain']] as const){
+test('non-quota failure after work began, access denial and unknown failures stop without replay',async()=>{
+  for(const [name,lines,category] of [['partial',[work,{type:'assistant',error:'overloaded'}],'after-work-began'],['recovered',[work,limitEvent,quota,work],'after-work-began'],
+    ['denied',[{type:'assistant',error:'oauth_org_not_allowed'},quota],'access-denied'],['denied-after-work',[work,{type:'assistant',error:'oauth_org_not_allowed'},quota],'after-work-began'],['silent',[],'uncertain']] as const){
     const f=await fixture(name,[{lines:[...lines],code:1}])
     try{
       const run=await f.done()
@@ -108,6 +144,46 @@ test('failure after work began, access denial and unknown failures stop without
   }
 })
 
+const revoked={type:'system',subtype:'api_error',error:{status:401,message:'OAuth access token has been revoked.'}}
+const retry={type:'system',subtype:'api_retry',error_status:401,error:'authentication_failed',attempt:1,max_retries:10,retry_delay_ms:624}
+
+test('revoked-login metadata followed by a quota rejection does not mark work as started',()=>{
+  assert.deepEqual(observe({type:'system',subtype:'init'},revoked,retry,
+    {type:'rate_limit_event',rate_limit_info:{status:'rejected',resetsAt:1791475200}},
+    {...quota,isApiErrorMessage:true,message:{model:'<synthetic>',content:[{type:'text',text:'session limit'}],usage:{input_tokens:0,output_tokens:0}}}),
+    {workBegan:false,rejection:{category:'quota',resetAt:'2026-10-08T16:00:00.000Z'}})
+  assert.deepEqual(observe(revoked),{workBegan:false,rejection:{category:'login-unavailable'}})
+  assert.deepEqual(observe(retry),{workBegan:false,rejection:{category:'login-unavailable'}})
+  assert.equal(observe(work,revoked).workBegan,true)
+  assert.equal(observe(work,retry).workBegan,true)
+  assert.equal(observe({type:'system',subtype:'api_error',error:{status:403}},quota).rejection?.category,'access-denied')
+  assert.equal(observe({type:'system',subtype:'api_error',error:{status:null}},quota).workBegan,true)
+  assert.equal(observe({...retry,error_status:null},quota).workBegan,true)
+})
+
+test('unavailable login advances to a saved account and the next occurrence uses the unchanged chain',async()=>{
+  const profiles=['claude2','claude3','claude4']
+  const fallbacks=[claudeB,...profiles.map((authProfile,i)=>({...claudeA,id:`profile-${i}`,authProfile,effort:'high'}))]
+  const f=await fixture('login-recovery',[{lines:[revoked,retry],code:1},{lines:[work],code:0},
+    {lines:[{type:'assistant',error:'authentication_failed'}],code:1},{lines:[work],code:0}],fallbacks,{...claudeA,effort:'high'})
+  try{
+    const first=await f.done()
+    assert.equal(first.status,'completed')
+    assert.deepEqual(first.attempts!.map(a=>[a.quotaScope,a.category]),[
+      ['claude','login-unavailable'],['claude','same-login-scope'],['claude@claude2',undefined]])
+    const saved=await f.scheduler.get('daily')
+    assert.deepEqual(saved!.execution!.fallbacks,fallbacks)
+    const second=await f.scheduler.trigger(saved!.id,saved!.revision,'next-occurrence',saved!.owner,f.runs)
+    await f.relay.drainSources()
+    await until(async()=>['completed','failed'].includes((await f.runs.get(second.id))!.status))
+    assert.equal((await f.runs.get(second.id))!.status,'completed')
+    assert.notEqual(first.id,second.id)
+    assert.deepEqual(f.launches.map(l=>[l.authProfile,l.model,l.effort]),[
+      [undefined,'opus','high'],['claude2','opus','high'],[undefined,'opus','high'],['claude2','opus','high']])
+    assert.equal(new Set(f.launches.map(l=>l.sessionId)).size,4)
+  }finally{await f.close()}
+})
+
 test('each scheduled attempt launches with its own captured auth profile',async()=>{
   const primary={...claudeA,authProfile:'work'}
   const f=await fixture('profile',[{lines:[{type:'assistant',error:'model_not_found'}],code:1},{lines:[work],code:0}],[claudeB],primary)
@@ -117,6 +193,74 @@ test('each scheduled attempt launches with its own captured auth profile',async(
   }finally{await f.close()}
 })
 
+test('four Claude accounts advance in order on quota rejection before work',async()=>{
+  const profiles=['claude2','claude3','claude4']
+  const fallbacks=profiles.map((authProfile,i)=>({...claudeA,id:`fallback-${i}`,authProfile,effort:'high'}))
+  const f=await fixture('four-accounts',[{lines:[quota],code:1},{lines:[quota],code:1},{lines:[quota],code:1},{lines:[work],code:0}],fallbacks,{...claudeA,effort:'high'})
+  try{
+    const run=await f.done()
+    assert.equal(run.status,'completed')
+    assert.deepEqual(f.launches.map(l=>[l.cli,l.authProfile,l.model,l.effort]),
+      [undefined,...profiles].map(profile=>['claude',profile,'opus','high']))
+    assert.equal(new Set(f.launches.map(l=>l.sessionId)).size,4)
+    assert.ok(f.launches.every(l=>l.runId===run.id))
+    assert.deepEqual(run.attempts!.map(a=>[a.quotaScope,a.outcome]),[
+      ['claude','failed'],['claude@claude2','failed'],['claude@claude3','failed'],['claude@claude4','completed']])
+  }finally{await f.close()}
+})
+
+test('arbitrary mixed setup lists preserve CLI, provider, model and effort per attempt',async()=>{
+  const candidates:AiPreset[]=[claudeA,
+    {...codexA,authProfile:'work',effort:'xhigh'},
+    {...setup('desktop','codex-gui','gpt-6-sol'),effort:'high'},
+    {...setup('open','opencode','anthropic/claude-sonnet'),provider:'anthropic',effort:'high'},
+    {...setup('pi','pi','openai/gpt-6-sol'),effort:'medium'},
+    {...setup('grok','grok','grok-4'),effort:'low'}]
+  const f=await fixture('mixed',candidates.map((_,i)=>i<candidates.length-1?{unavailable:true}:{code:0}),candidates.slice(1),candidates[0])
+  try{
+    const run=await f.done()
+    assert.equal(run.status,'completed')
+    assert.deepEqual(f.launches.map(l=>[l.cli,l.authProfile,l.provider,l.model,l.effort]),
+      candidates.map(p=>[p.cli,p.authProfile,p.provider,p.model,p.effort]))
+    assert.deepEqual(run.attempts!.map(a=>a.preset),candidates)
+    assert.equal(new Set(f.launches.map(l=>l.sessionId)).size,candidates.length)
+  }finally{await f.close()}
+})
+
+test('a usage limit after work began continues the same run on the next login, told so',async()=>{
+  const opus={...claudeA,effort:'xhigh'},profiles=['claude2','claude3','claude4'].map((authProfile,i)=>({...opus,id:`fallback-${i}`,authProfile}))
+  for(const event of [work,{type:'system',subtype:'hook_started'}]){
+    // Default login stops mid-run, claude2 is already exhausted before work, claude3 completes.
+    const f=await fixture('mid-run-limit',[{lines:[{type:'system',subtype:'init'},event,limitEvent,limitMessage,{type:'result',is_error:true}],code:1},
+      {lines:[limitEvent,limitMessage],code:1},{lines:[work],code:0}],profiles,opus)
+    try{
+      const run=await f.done()
+      assert.equal(run.status,'completed');assert.equal(run.id,f.run.id)
+      assert.deepEqual(f.launches.map(l=>[l.authProfile,l.model,l.effort,l.runId]),[[undefined,'opus','xhigh',run.id],['claude2','opus','xhigh',run.id],['claude3','opus','xhigh',run.id]])
+      assert.deepEqual(run.attempts!.map(a=>[a.quotaScope,a.outcome,a.category,a.resetAt,a.sessionId]),[
+        ['claude','failed','quota-after-work-began',limitReset,f.launches[0].sessionId],
+        ['claude@claude2','failed','quota',limitReset,f.launches[1].sessionId],
+        ['claude@claude3','completed',undefined,undefined,f.launches[2].sessionId]])
+      assert.equal(new Set(f.launches.map(l=>l.sessionId)).size,3)
+      // The first launch is the saved prompt; each continuation adds only the transport fact.
+      const fact=`[run ${run.id} continues: claude · opus · xhigh began work in native session ${f.launches[0].sessionId} and stopped at its usage limit (resets ${limitReset}). That work may be partly applied.]`
+      assert.deepEqual(f.prompts,[f.prompts[0],[...f.prompts[0],fact],[...f.prompts[0],fact]])
+      assert.ok(!f.prompts[0].some(text=>text.includes('continues')))
+      assert.equal((await f.runs.list()).filter(r=>r.scheduled?.id==='daily').length,1)
+    }finally{await f.close()}
+  }
+})
+
+test('a run that reaches the limit on every login fails with each setup recorded',async()=>{
+  const f=await fixture('limit-everywhere',[{lines:[work,limitEvent,limitMessage],code:1},{lines:[limitEvent,limitMessage],code:1}],[{...claudeA,authProfile:'claude2'}])
+  try{
+    const run=await f.done()
+    assert.equal(run.status,'failed');assert.equal(run.failureReason,'setups-unavailable');assert.equal(f.launches.length,2)
+    assert.deepEqual(run.attempts!.map(a=>[a.quotaScope,a.category]),[['claude','quota-after-work-began'],['claude@claude2','quota']])
+    assert.match(run.failure!.error,/quota-after-work-began, resets 2026-10-09T18:10:00\.000Z.*quota, resets/)
+  }finally{await f.close()}
+})
+
 test('cancellation stops the chain',async()=>{
   const f=await fixture('cancel',[{lines:[quota],hold:true}])
   try{
@@ -140,14 +284,14 @@ test('when every setup is unavailable the run reports each setup clearly',async(
   }finally{await f.close()}
 })
 
-test('schedules reject duplicate or excess setups and the socket cannot rewrite attempts',async()=>{
+test('schedules reject duplicate or invalid setups and the socket cannot rewrite attempts',async()=>{
   const dir=await mkdtemp(join(tmpdir(),'ez-fallback-validate-')),control=new ControlStore(dir,1000),scheduler=new Scheduler(dir)
   try{
     await control.requestPairing(101,101);await control.approveOwner(101)
     const owner=(await control.status()).owner!,base={id:'t',name:'T',text:'Work',owner,enabled:true,trigger:{at:'2027-01-01T00:00:00Z'}}
     const execution=(fallbacks:AiPreset[])=>({sessionId:'00000000-0000-4000-8000-000000000000',preset:claudeA,fallbacks})
     await assert.rejects(scheduler.save({...base,execution:execution([{...claudeA,id:'copy'}])}),/distinct/)
-    await assert.rejects(scheduler.save({...base,execution:execution([claudeB,codexA,codexB,setup('x','codex','other')])}),/AI selection/)
+    await assert.rejects(scheduler.save({...base,execution:execution([{...claudeB,cli:'unknown'}])}),/AI selection/)
     await assert.rejects(scheduler.save({...base,execution:execution([{...codexA,model:undefined}])}),/explicit model/)
     const forged=[{preset:setup('forged','claude','opus-max'),quotaScope:'claude',outcome:'running' as const}]
     assert.equal(activeSetup({execution:execution([claudeB]),attempts:forged}),undefined)
@@ -177,7 +321,7 @@ test('host transport admits only the active task setup and profile, forwards onl
     await runs.patch(id,{status:'running',attempts:[{preset:primary,quotaScope:'claude',outcome:'running'}]})
     server=serveHostExecutor({cli:'claude',agents:[{name:'t',workspace,controlDir,binDir:join(root,'bin')}]},abort.signal,async(_texts,options)=>{
       launched.push({cli:options.cli,model:options.model,authProfile:options.authProfile})
-      const lines=options.model==='opus'?[JSON.stringify({type:'system',subtype:'init'}),JSON.stringify({type:'assistant',error:'model_not_found',message:{content:[{type:'text',text:'secret tool output'}]}})].join('\n')+'\n':''
+      const lines=options.model==='opus'?[JSON.stringify({type:'system',subtype:'init'}),JSON.stringify({...revoked,error:{...revoked.error,message:'secret provider diagnostic'}}),JSON.stringify({...retry,error:'secret provider diagnostic'})].join('\n')+'\n':''
       const child=spawn(process.execPath,['-e',`process.stdout.write(${JSON.stringify(lines)});process.exit(1)`])
       return {child,cleanup:async()=>{},stdout:''}
     },async()=>[{cli:'claude',authProfile:'work',model:'opus',name:'Work',efforts:[]}])
@@ -188,11 +332,11 @@ test('host transport admits only the active task setup and profile, forwards onl
     const first=await events()
     const summaries=first.trim().split('\n').map(l=>JSON.parse(l)).filter(e=>e.stream==='stdout').flatMap(e=>e.text.trim().split('\n').map((l:string)=>JSON.parse(l)))
     assert.ok(summaries.every((e:{type:string})=>e.type==='ez.startup'))
-    assert.deepEqual(summaries.at(-1),{type:'ez.startup',workBegan:false,rejection:{category:'provider-rejected'}})
-    assert.doesNotMatch(first,/secret tool output/)
+    assert.deepEqual(summaries.at(-1),{type:'ez.startup',workBegan:false,rejection:{category:'login-unavailable'}})
+    assert.doesNotMatch(first,/secret provider diagnostic/)
     const {rm:remove}=await import('node:fs/promises');await remove(join(directory,id+'.events'))
     // The relay advances: the next attempt reuses the run ID.
-    await runs.patch(id,{attempts:[{preset:primary,quotaScope:'claude',outcome:'failed',category:'provider-rejected'},{preset:claudeB,quotaScope:'claude',outcome:'running'}]})
+    await runs.patch(id,{attempts:[{preset:primary,quotaScope:'claude',outcome:'failed',category:'login-unavailable'},{preset:claudeB,quotaScope:'claude',outcome:'running'}]})
     await request({cli:'claude',model:'sonnet'})
     await events();await remove(join(directory,id+'.events'))
     assert.deepEqual(launched.map(l=>[l.cli,l.model,l.authProfile]),[['claude','opus','work'],['claude','sonnet',undefined]])
@@ -243,3 +387,37 @@ test('schedule CLI saves ordered fallbacks, preserves them on edit and clears th
   await assert.rejects(exec(process.execPath,[bin,'create','bad','--cli','claude','--model','opus',...when,'--fallback','cli=codex'],{env}),/cli=EXECUTOR,model=MODEL/)
   await assert.rejects(exec(process.execPath,[bin,'create','dup','--cli','claude','--model','opus',...when,'--fallback','cli=claude,model=opus'],{env}),/distinct/)
 })
+
+test('schedule CLI saves arbitrary profile/model/effort combinations and validates every profile',async t=>{
+  const {execFile}=await import('node:child_process'),{promisify}=await import('node:util'),{fileURLToPath}=await import('node:url')
+  const {mkdir}=await import('node:fs/promises'),{serveTestLedger}=await import('./helpers/ledger.js')
+  const exec=promisify(execFile),bin=fileURLToPath(new URL('../bin/ezenciel-agents-schedule.mjs',import.meta.url))
+  const dir=await mkdtemp(join(tmpdir(),'ez-fallback-profiles-'));t.after(()=>rm(dir,{recursive:true,force:true}))
+  const ledger=await serveTestLedger(dir);t.after(()=>ledger.stop())
+  const control=new ControlStore(dir,1000);await control.requestPairing(101,101);await control.approveOwner(101)
+  for(const profile of ['claude2','claude3','claude4'])await mkdir(join(dir,'cli','profiles',profile,'claude'),{recursive:true})
+  await mkdir(join(dir,'cli','profiles','work','codex'),{recursive: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 when=['--at','2027-09-09T09:00:00+04:00','--text','Work']
+  const tuples=[
+    ['claude','claude2',undefined,'opus','high'],['claude','claude3',undefined,'sonnet','medium'],
+    ['claude','claude4',undefined,'opus','xhigh'],['codex','work',undefined,'gpt-6-sol','xhigh'],
+    ['codex-gui',undefined,undefined,'gpt-6-astra','high'],['opencode',undefined,'anthropic','anthropic/claude-sonnet','high'],
+    ['pi',undefined,undefined,'openai/gpt-6-sol','medium'],['grok',undefined,undefined,'grok-4','low']]
+  const flags=tuples.flatMap(([cli,profile,provider,model,effort])=>['--fallback',
+    `cli=${cli},model=${model},effort=${effort}${profile?`,auth-profile=${profile}`:''}${provider?`,provider=${provider}`:''}`])
+  const saved=await cli('create','chain','--cli','claude','--model','opus','--effort','high',...when,...flags)
+  assert.deepEqual(saved.execution.fallbacks.map((p:AiPreset)=>[p.cli,p.authProfile,p.provider,p.model,p.effort]),tuples)
+  assert.deepEqual((await cli('edit','chain',...when)).execution,saved.execution)
+  const base=[bin,'create','bad','--cli','claude','--model','opus',...when,'--fallback']
+  for(const [spec,error] of [
+    ['cli=claude,model=opus,auth-profile=missing',/not provisioned/],
+    ['cli=claude,model=opus,auth-profile=../escape',/Invalid fallback/],
+    ['cli=grok,model=grok-4,auth-profile=work',/Invalid fallback/],
+    ['cli=claude,model=opus,effort=not valid',/Invalid reasoning effort/],
+    ['cli=claude,model=opus,auth-profile=',/Invalid fallback/],
+    ['cli=unknown,model=fixture',/Unsupported executor/],
+  ] as const)await assert.rejects(exec(process.execPath,[...base,spec],{env}),error)
+  await assert.rejects(exec(process.execPath,[...base,'cli=claude,model=opus,auth-profile=claude2','--fallback','cli=claude,model=opus,auth-profile=claude2'],{env}),/distinct/)
+})

package/test/updates.test.mjs

@@ -12,6 +12,7 @@ import { prepare, submit, command, read, jobPath, eligibility, jobs, cleanupStal
 import { perform, environment, packageManager, backupStateDirectory, execute, brokerNeedsRefresh } from '../src/updates/runtime.mjs';
 import { atomic, snapshot, compose, prepareCommand } from '../src/plugins/manager.mjs';
 import { bindUpdates } from '../src/updates/binding.mjs';
+import { TOOLS_LINE } from '../src/tools-line.mjs';
 import { status as runtimeStatus } from '../src/updates/status.mjs';
 import { providerEnvironment, queueAutomatic, waitForHostHeartbeat, withIdleUpgrade, withUpgrade } from '../src/updates/supervisor.mjs';
 const exec=promisify(execFile);
@@ -314,15 +315,23 @@ test('main transaction stages before stopping, pins rollback image, preserves st
  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);
 });
-test('main activation and rollback bind guidance from the selected package root',async t=>{
- const success=await fixture(t);await bindUpdates(success.home,path.join(success.config.deploymentDir,'host-executor.json'),success.old);
- assert.equal(await fs.readFile(path.join(success.agent.workspace,'AGENTS.md'),'utf8'),'old guidance\n');
- assert.equal((await perform(success.home,await queued(success),runtime(success))).status,'completed');
- assert.equal(await fs.readFile(path.join(success.agent.workspace,'AGENTS.md'),'utf8'),'candidate guidance\n');
-
- const failed=await fixture(t);await bindUpdates(failed.home,path.join(failed.config.deploymentDir,'host-executor.json'),failed.old);
- 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('apply queues while a plugin call holds its lease; activation drains it first',async t=>{
+ const f=await fixture(t),directory=path.join(f.home,'command-invocations');await fs.mkdir(directory,{recursive:true});
+ await fs.writeFile(path.join(directory,'00000000-0000-4000-8000-000000000002.json'),JSON.stringify({pid:process.pid,container:'live-call'}),{mode:0o600});
+ assert.equal((await queued(f)).status,'queued');
+ await fs.rm(path.join(directory,'00000000-0000-4000-8000-000000000002.json'));
+});
+test('main activation and rollback retire the tools footer and never write guidance',async t=>{
+ const footer='Owner mandate\n\n<!-- ez tools: begin -->\nUse `ez`.\n<!-- ez tools: end -->\n';
+ for(const outcome of ['completed','rolled-back']) {
+  const f=await fixture(t),instructions=path.join(f.agent.workspace,'AGENTS.md');await fs.writeFile(instructions,footer);
+  await bindUpdates(f.home,path.join(f.config.deploymentDir,'host-executor.json'),f.old);
+  const retired=await fs.readFile(instructions,'utf8');
+  assert.equal(retired,'Owner mandate\n\n'+TOOLS_LINE+'\n');
+  const options=outcome==='rolled-back'?{fail:(_command,args)=>args.includes('up')}:undefined;
+  assert.equal((await perform(f.home,await queued(f),runtime(f,options))).status,outcome);
+  assert.equal(await fs.readFile(instructions,'utf8'),retired);
+ }
 });
 test('latest overrides stale deployment pins and changing latest changes image bindings',async t=>{
  const tags=[],hashes=[];
@@ -477,7 +486,7 @@ test('bound dispatch follows active package root and retains private scope',asyn
  const bound=await bindUpdates(f.home,path.join(f.config.deploymentDir,'host-executor.json'));
  assert.match(bound.policy,/beta-channel/);
  assert.equal(await fs.readFile(path.join(f.agent.workspace,'TOOLS.md'),'utf8'),prior);
- assert.match(await fs.readFile(path.join(f.agent.workspace,'AGENTS.md'),'utf8'),/tools list --details/);
+ await assert.rejects(fs.access(path.join(f.agent.workspace,'AGENTS.md')),{code:'ENOENT'}); // binding never seeds guidance
  const config=await read(path.join(f.home,'config.json'));config.packageRoot=f.source;await atomic(path.join(f.home,'config.json'),config);
  // A native launcher from the real package looks up its entry point in the active root.
  await fs.writeFile(path.join(f.source,'bin/ezenciel-agents.mjs'),'#!/usr/bin/env node\nconsole.log(process.env.EZ_DEPLOYMENT_DIR+"|"+process.env.EZ_CONTROL_DIR)',{mode:0o755});

package/test/workspace.test.ts

@@ -6,6 +6,7 @@ import test from 'node:test'
 import { spawnSync } from 'node:child_process'
 import { fileURLToPath } from 'node:url'
 import { initializeWorkspace } from '../src/workspace.js'
+import { TOOLS_LINE } from '../src/tools-line.mjs'
 
 test('packaged launcher help and invalid arguments never start the relay', () => {
   const bin = fileURLToPath(new URL('../bin/ezenciel-agents.mjs', import.meta.url))
@@ -42,6 +43,11 @@ test('fresh mind is private; repeat initialization preserves customization and o
     await writeFile(purpose, 'Research partner\n')
     assert.deepEqual(await initializeWorkspace(workspace, purpose), ['AGENTS.md'])
     assert.equal((await stat(path.join(workspace, 'AGENTS.md'))).mode & 0o777, 0o600)
+    const seed = await readFile(path.join(workspace, 'AGENTS.md'), 'utf8')
+    assert.match(seed, /^## Purpose\n\nResearch partner\n\n## Memory\n/)
+    assert.match(seed, /`memory\/MEMORY\.md`/)
+    assert.ok(seed.endsWith(`\n${TOOLS_LINE}\n`))
+    assert.doesNotMatch(seed, /ez tools: begin/)
     assert.ok(!(await readdir(workspace)).includes('SOUL.md'))
     assert.ok(!(await readdir(workspace)).includes('USER.md'))
     assert.ok(!(await readdir(workspace)).includes('MEMORY.md'))