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

package/src/schedule-cli.ts

@@ -16,12 +16,13 @@ import { type Trigger } from './schedule-time.js'
 async function main() {
   const { values:v, positionals:[action='list',id] } = parseArgs({allowPositionals:true,options:{
     cli:{type:'string'}, model:{type:'string'}, effort:{type:'string'},
-    all:{type:'boolean'}, limit:{type:'string'}, when:{type:'string'}, status:{type:'string'}, diagnosis:{type:'string'}, recovery:{type:'string'}, outcome:{type:'string'}, 'failed-at':{type:'string'},
+    all:{type:'boolean'}, limit:{type:'string'}, key:{type:'string'}, when:{type:'string'}, status:{type:'string'}, diagnosis:{type:'string'}, recovery:{type:'string'}, outcome:{type:'string'}, 'failed-at':{type:'string'},
     name:{type:'string'}, text:{type:'string'}, 'text-file':{type:'string'}, at:{type:'string'}, now:{type:'boolean'},
     cron:{type:'string'}, timezone:{type:'string'}, 'every-seconds':{type:'string'}, start:{type:'string'}, until:{type:'string'}, help:{type:'boolean'},
   }})
   if(v.help){console.log(`ezenciel-agents-schedule list | runs | show ID | pause ID | resume ID | remove ID | cancel RUN_ID
   failures [--all] [--limit N] | run RUN_ID | context
+  trigger SCHEDULE_ID --key REQUEST_KEY
   review RUN_ID --failed-at ISO --status resolved|attention --diagnosis TEXT --recovery TEXT --outcome TEXT
   create [ID] | edit ID --name NAME (--text TEXT | --text-file FILE)
     --now | --at ISO_WITH_OFFSET | --every-seconds N | --cron 'MIN HOUR DAY MONTH WEEKDAY' --timezone IANA
@@ -30,7 +31,9 @@ async function main() {
 Context reads the current run only.
 Failures default to unreviewed owner runs. Review records a diagnosis; it never changes execution status or retries work.
 A conditional review schedule consumes no model run when there are no unreviewed failures.
-New tasks inherit the selected engine settings. Omitted model/effort uses native defaults; edit preserves existing settings unless overridden.
+New tasks capture the selected engine settings; edit preserves existing settings unless overridden.
+Every task requires a concrete saved model. Supply --model if the selected settings have none; existing tasks never fall back to chat or client defaults.
+Trigger runs an existing task once with its saved instructions, AI and delivery binding in a fresh session. Reuse the request key after an uncertain result; the regular schedule is unchanged.
 Creates a scheduled task. Instructions are text, never shell commands.
 Use --now to run once. Run completion is not delivery proof.
 Edit replaces the full schedule. Pause/remove affect future work; cancel stops a particular run.
@@ -95,7 +98,13 @@ Cron uses numeric five-field syntax, lists/ranges/steps, and traditional day/wee
     }
   }else if(action==='list')result=await Promise.all((await scheduler.list()).filter(owned).map(show))
   else if(action==='runs')result=(await runs.list()).filter(r=>r.scheduled && r.scheduled.pairedAt===owner.pairedAt && ownsRun(owner,r))
-  else if(action==='create' || action==='edit'){
+  else if(action==='trigger'){
+    if(!id || !v.key)throw new Error('Trigger requires SCHEDULE_ID and --key REQUEST_KEY')
+    if(Object.keys(v).some(key=>key!=='key'))throw new Error('Trigger uses saved task settings; overrides are not allowed')
+    const schedule=await scheduler.get(id)
+    if(!owned(schedule))throw new Error('Schedule ownership mismatch')
+    result=await callDeliverySocket(socketPath,{op:'triggerSchedule',payload:{scheduleId:id,revision:schedule.revision,key:v.key,...(caller ? {callerRunId:caller.id} : {})}})
+  }else if(action==='create' || action==='edit'){
     if(action==='edit' && (!id || !owned(await scheduler.get(id))))throw new Error('Unknown schedule')
     if(action==='create' && id && (await scheduler.list()).some(s=>s.id===id))throw new Error('Schedule exists; use edit')
     if([v.now,v.at,v.cron,v['every-seconds']].filter(Boolean).length!==1)throw new Error('Choose exactly one trigger')

package/src/scheduler.ts

@@ -1,4 +1,4 @@
-import { assertEffort } from './model-policy.js'
+import { assertEffort, assertScheduledModel } from './model-policy.js'
 import { needsFailureReview } from './failure.js'
 import { mkdir, readFile, readdir, writeFile, rename, link, rm } from 'node:fs/promises'
 import { randomUUID, createHash } from 'node:crypto'
@@ -112,6 +112,7 @@ export class Scheduler {
     if (input.when !== undefined && input.when !== 'unreviewed-failures') throw new Error('Unknown schedule condition')
     const execution: ExecutionChoice = {...input.execution, preset: persistedPreset(input.execution.preset)}
     if (!input.name || !input.text?.trim() || !isExecutionChoice(execution)) throw new Error('Schedule needs name, text and an AI selection')
+    assertScheduledModel(execution.preset.model)
     assertEffort(execution.preset.effort, execution.preset.model, execution.preset.cli)
     const s: Schedule = {...input, execution, trigger:validateTrigger(input.trigger),version:1,revision:randomUUID()}
     const now = Date.now()
@@ -159,6 +160,29 @@ export class Scheduler {
     try { await readFile(join(this.dir,assertId(runId)+'.cancel')); return true }
     catch (e) { if ((e as NodeJS.ErrnoException).code === 'ENOENT') return false; throw e }
   }
+  async trigger(id: string, revision: string, key: string, owner: Owner, runs: RunStore): Promise<RunRecord> {
+    const s=await this.get(id)
+    if (!sameOwner(s.owner,owner) || !s.enabled || s.revision !== revision) throw new Error('Schedule is disabled, changed or outside this owner binding')
+    assertScheduledModel(s.execution.preset.model)
+    if (s.delivery) {
+      const binding=(await new ApplicationBindings(this.controlDir).list()).find(b=>b.bindingId===s.delivery!.bindingId)
+      if (!binding || !sameOwner(binding.owner,owner)) throw new Error('Schedule delivery binding is unavailable')
+    } else if (!owner.telegramChatId || owner.telegramChatId !== s.owner.telegramChatId || owner.telegramUserId !== s.owner.telegramUserId || (owner.telegramLinkedAt ?? owner.pairedAt) !== (s.owner.telegramLinkedAt ?? s.owner.pairedAt)) throw new Error('Schedule Telegram binding is unavailable')
+    const runId='r_schedule_manual_'+createHash('sha256').update(JSON.stringify([s.id,ownerId(owner),ownerEpoch(owner),assertId(key)])).digest('hex')
+    const existing=await runs.get(runId)
+    if (existing) {
+      if (!ownsRun(owner,existing) || existing.scheduled?.revision !== s.revision) throw new Error('Request key belongs to a different task revision or owner')
+      return existing
+    }
+    const all=await runs.list()
+    if (all.some(r=>holdsSchedule(s,r))) throw new Error('Inspect the held occurrence and edit the schedule before retrying')
+    if (s.when === 'unreviewed-failures' && !all.some(r=>needsFailureReview(r) && ownsRun(owner,r) && (!r.scheduled || r.scheduled.pairedAt===owner.pairedAt))) throw new Error('Schedule condition is not met')
+    const dueAt=new Date().toISOString()
+    return runs.create({id:runId,ownerId:ownerId(owner),ownerEpoch:ownerEpoch(owner),
+      ...(s.delivery ? {delivery:s.delivery} : {chatId:s.owner.telegramChatId,telegramUserId:s.owner.telegramUserId,telegramEpoch:s.owner.telegramLinkedAt ?? s.owner.pairedAt}),
+      texts:[`[schedule ${s.id} due ${dueAt}]`,s.text],execution:{...s.execution,sessionId:randomUUID()},
+      scheduled:{id:s.id,revision:s.revision,dueAt,pairedAt:s.owner.pairedAt,...(s.originRunId ? {originRunId:s.originRunId} : {})}},true)
+  }
   async recover(runs: RunStore) {
     for (const run of await runs.list()) {
       if (!run.scheduled || run.status !== 'running') continue
@@ -180,6 +204,7 @@ export class Scheduler {
       try {
         const next = await this.pendingOccurrence(s)
         if (next === null || next > now) continue
+        assertScheduledModel(s.execution.preset.model)
         // One occurrence at a time. A failed reviewer stops this revision just like
         // interrupted work: retain its receipt until an explicit schedule edit.
         if ((await runs.list()).some(r => r.scheduled?.id === s.id &&
@@ -193,10 +218,10 @@ export class Scheduler {
           ownerId:ownerId(owner),ownerEpoch:ownerEpoch(owner),
           ...(s.delivery ? {delivery:s.delivery} : {chatId:s.owner.telegramChatId,telegramUserId:s.owner.telegramUserId,telegramEpoch:s.owner.telegramLinkedAt ?? s.owner.pairedAt}),
           texts:[`[schedule ${s.id} due ${dueAt}]`, s.text],execution:s.execution,
-          scheduled:{id:s.id,revision:s.revision,dueAt,pairedAt:s.owner.pairedAt,...(s.originRunId?{originRunId:s.originRunId}:{})}})
+          scheduled:{id:s.id,revision:s.revision,dueAt,pairedAt:s.owner.pairedAt,...(s.originRunId?{originRunId:s.originRunId}:{})}},true)
         // A restart between run creation and this cursor write sees the same occurrence ID.
         await atomic(cursor,{next:future})
-      } catch { console.error('Schedule dispatch failed',s.id) }
+      } catch (error) { console.error('Schedule dispatch failed',s.id,error instanceof Error ? error.message : 'Unknown error') }
     }
   }
 }

package/src/task-executor.ts

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

package/src/updates/control.mjs

@@ -10,8 +10,9 @@ export const missing = error => {if(error.code!=='ENOENT')throw error;return nul
 export const targetId = value => {if(value!=='main'&&!/^[a-z][a-z0-9-]{0,39}$/.test(value))throw Error('Invalid update target');return value;};
 const jobId=/^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/;
 const compatibilityBuild=/^(.+)\.compat\.\d+$/;
+const qaBuild=/^(\d+\.\d+\.\d+-beta\.\d+)\.(?:rc|qa)\.[1-9]\d*$/;
 const upgradeable=(candidate,installed)=>{
-  const match=compatibilityBuild.exec(installed);
+  const match=compatibilityBuild.exec(installed)||qaBuild.exec(installed);
   return newer(candidate,installed)||Boolean(match&&match[1]===candidate);
 };
 export const updateHome = home => path.join(home,'updates');

package/src/updates/runtime.mjs

@@ -1,3 +1,4 @@
+import { latestCodexVersion } from '../install-tools.mjs';
 import { sharedIdentity } from '../plugins/shared.mjs';
 import * as fs from 'node:fs/promises';
 import { createWriteStream } from 'node:fs';
@@ -61,6 +62,10 @@ export async function relayServices(config) {
   const env = await fs.readFile(path.join(config.deploymentDir,'docker.env'),'utf8').catch(() => '');
   return parseEnv(env).EZ_EXECUTOR_TRANSPORT === 'local' ? ['relay','plugin-broker'] : ['relay'];
 }
+async function refreshBroker(config, run) {
+  if ((await relayServices(config)).includes('plugin-broker'))
+    await run('docker', [...relayArgs(config), 'restart', 'plugin-broker']);
+}
 const healthCodes = new Set(['RELAY_UNREADABLE','RELAY_NOT_POLLING','RELAY_STALE','HOST_UNREADABLE','HOST_STALE','PLUGIN_BROKER_UNREADABLE']);
 async function healthEvidence(config,run) {
   const id=(await run('docker',[...relayArgs(config),'ps','-q','relay'])).trim();
@@ -109,13 +114,15 @@ export async function perform(home,job,hooks) {
       await run(process.execPath,['--import',path.join(root,'node_modules/tsx/dist/loader.mjs'),path.join(root,'bin/ezenciel-agents.mjs'),'--version'],{cwd:root});
       try { await replaceGuidance(root, config.workspace, run); }
       catch(error) { console.error(`Workspace guidance replacement failed; upgrade continues: ${error.message}`); }
-      // Preserve operator-owned native CLI pins from the effective deployment.
-      // Building only the package defaults silently downgrades those clients.
+      // Resolve managed Codex at activation; old deployment pins cannot override latest.
+      // Preserve unrelated operator build arguments.
       const deployment=JSON.parse(await run('docker',[...relayArgs(config),'config','--format','json'],{stdoutOnly:true}));
       const args=deployment.services?.relay?.build?.args||{};
       if(typeof args!=='object'||Array.isArray(args))throw Error('Invalid relay build arguments');
-      const buildArgs=Object.keys(args).sort().flatMap(key=>{
-        const value=args[key];
+      job.codexVersion=await latestCodexVersion(run,job.packageManager);await save();
+      const effective={...args,CODEX_CLI_VERSION:job.codexVersion};
+      const buildArgs=Object.keys(effective).sort().flatMap(key=>{
+        const value=effective[key];
         if(!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key)||typeof value!=='string'||value.includes('\0'))throw Error('Unresolved relay build argument');
         return ['--build-arg',`${key}=${value}`];
       });
@@ -145,8 +152,8 @@ export async function perform(home,job,hooks) {
       await checkFolders(config,candidate,home);
       const stage={...candidate,compose:path.join(dir,'compose.json')};await atomic(stage.compose,await compose(config,stage,secrets,home));
       for(const [service,spec] of Object.entries(stage.deployment.services))await run('docker',[...pluginArgs(stage),spec.image?'pull':'build',service]);
-      const running=Boolean((await run('docker',[...pluginArgs(old),'ps','-q'])).trim());
-      job.rollback={record:old,registry:r,compose:await read(old.compose),running};await save();
+      const running=Boolean((await run('docker',[...pluginArgs(old),'ps','--status','running','-q'])).trim());
+      job.rollback={record:old,registry:structuredClone(r),compose:await read(old.compose),running};await save();
       await run('docker',[...pluginArgs(old),'stop']);
       const backup=path.join(dir,'backup');await fs.mkdir(backup,{mode:0o700});
       const volumes=new Set(Object.values(old.deployment.services).flatMap(s=>Object.keys(s.volumes||{})));
@@ -156,6 +163,7 @@ export async function perform(home,job,hooks) {
       r.plugins[job.target]=candidate;
       for(const alias of Object.keys(candidate.manifest.commands))r.commands[alias]=job.target;
       await atomic(path.join(home,'registry.json'),r);
+      await refreshBroker(config,run);
       job.runtimeVerified=running;
     }
     job.status='completed';job.endedAt=new Date().toISOString();await save();
@@ -192,6 +200,7 @@ export async function recover(home,job,hooks) {
         const b=job.rollback;
         await run('docker',[...pluginArgs(b.record),'stop']);
         await atomic(b.record.compose,b.compose);await atomic(path.join(home,'registry.json'),b.registry);
+        await refreshBroker(config,run);
         if(b.running)await run('docker',[...pluginArgs(b.record),'up','-d','--wait','--wait-timeout','90','--no-build']);
       }
       job.status='rolled-back';

package/src/updates/supervisor.mjs

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

package/test/ai.test.ts

@@ -4,13 +4,49 @@ import { mkdtemp, mkdir, writeFile, readFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
 import { ControlStore } from '../src/control-state.js'
-import { initialPreset, chatPreset, readModels, isPreset, readOpencodeModels, readCuratedModels, validateSelection, opencodeProviderAllowlist } from '../src/ai.js'
+import { initialPreset, chatPreset, readModels, readCodexCatalog, isPreset, readOpencodeModels, readCuratedModels, validateSelection, opencodeProviderAllowlist } from '../src/ai.js'
 import { createAiMenu } from '../src/menu.js'
 import { EXECUTOR_REGISTRY, nativeSessionId } from '../src/executor.js'
 import { InboxStore } from '../src/inbox.js'
 import { executionDefaults } from '../src/model-policy.js'
 import type { Update } from 'grammy/types'
 
+const noCodex = async (): Promise<string> => { throw new Error('Native discovery unavailable') }
+
+test('Codex discovery refreshes through the bound native CLI without curated overrides or a turn', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'ez-native-catalog-'))
+  const previousToken = process.env.TELEGRAM_BOT_TOKEN
+  try {
+    process.env.TELEGRAM_BOT_TOKEN = 'must-not-reach-native-client'
+    await writeFile(join(home, 'models_cache.json'), JSON.stringify({ models: [
+      { slug: 'old-model', visibility: 'list' },
+    ] }))
+    const calls: string[][] = []
+    const run = async (args: string[], env: NodeJS.ProcessEnv) => {
+      calls.push(args)
+      assert.equal(env.CODEX_HOME, home)
+      assert.equal(env.TELEGRAM_BOT_TOKEN, undefined)
+      return JSON.stringify({ models: [
+        { slug: 'new-model', display_name: 'New model', visibility: 'list',
+          supported_reasoning_levels: [{ effort: 'ultra' }], model_messages: 'untrusted', api_key: 'secret' },
+        { slug: 'hidden-model', visibility: 'hide' },
+      ] })
+    }
+    assert.deepEqual(await readModels(home, async cli => cli === 'codex', home,
+      undefined, undefined, undefined, undefined, run), [
+      { cli: 'codex', model: 'new-model', name: 'New model', efforts: ['ultra'] },
+    ])
+    assert.deepEqual(calls, [['debug', 'models']])
+    for (const unavailable of [noCodex, async () => 'not json', async () => '{"models":[]}']) {
+      assert.deepEqual(await readCodexCatalog(home, unavailable), { models: [{ slug: 'old-model', visibility: 'list' }] })
+    }
+  } finally {
+    if (previousToken === undefined) delete process.env.TELEGRAM_BOT_TOKEN
+    else process.env.TELEGRAM_BOT_TOKEN = previousToken
+    await rm(home, { recursive: true, force: true })
+  }
+})
+
 test('same-client model and default changes preserve history; provider changes require a fresh conversation', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-ai-model-switch-'))
   try {
@@ -173,7 +209,7 @@ test('model catalog projects native metadata only, excluding hidden entries and
         supported_reasoning_levels: [{ effort: 'high' }, { effort: 'xhigh' }, { effort: 'max' }] },
       { slug: 'hidden-model', visibility: 'hide' },
     ] }))
-    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex'), [
+    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex', undefined, undefined, undefined, undefined, undefined, noCodex), [
       { cli: 'codex', model: 'fixture-model', name: 'Fixture', efforts: ['medium'] },
       { cli: 'codex', model: 'gpt-5.6-luna', name: 'Luna', efforts: ['high', 'xhigh', 'max'] },
     ])
@@ -258,7 +294,7 @@ test('model catalog can read an agent-bound Codex home', async () => {
       { slug: 'gpt-6-astra', display_name: 'GPT-6 Astra', visibility: 'list',
         supported_reasoning_levels: [{ effort: 'low' }] },
     ] }))
-    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex', codexHome), [
+    assert.deepEqual(await readModels(home, async (cli) => cli === 'codex', codexHome, undefined, undefined, undefined, undefined, noCodex), [
       { cli: 'codex', model: 'gpt-6-astra', name: 'GPT-6 Astra', efforts: ['low'] },
     ])
   } finally {
@@ -270,7 +306,10 @@ test('model catalog can read an agent-bound Codex home', async () => {
 test('Choose AI lists the agent-bound Codex home instead of only the desktop fallback', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-ai-menu-codex-home-'))
   const codexHome = await mkdtemp(join(tmpdir(), 'ez-ai-menu-cache-'))
+  const previousPath = process.env.PATH
   try {
+    await writeFile(join(codexHome, 'codex'), '#!/bin/sh\nexit 1\n', { mode: 0o700 })
+    process.env.PATH = `${codexHome}:${previousPath ?? ''}`
     await writeFile(join(codexHome, 'models_cache.json'), JSON.stringify({ models: [
       { slug: 'fixture-bound-model', display_name: 'Bound Fixture', visibility: 'list',
         supported_reasoning_levels: [{ effort: 'medium' }] },
@@ -298,6 +337,7 @@ test('Choose AI lists the agent-bound Codex home instead of only the desktop fal
     await menu.handle(context(client.callback_data) as never)
     assert.deepEqual(replies.at(-1)!.buttons.map((button) => button.text), ['Bound Fixture', 'Back to clients'])
   } finally {
+    process.env.PATH = previousPath
     await rm(dir, { recursive: true, force: true })
     await rm(codexHome, { recursive: true, force: true })
   }
@@ -522,7 +562,7 @@ test('model catalog merges user-curated entries ahead of discovered ones', async
     const installedOnly = async (cli: string) => cli === 'codex' || cli === 'pi'
     const noRunner = async (_args: string[]): Promise<string> => { throw new Error('no native CLI in test') }
     const catalog = await readModels(home, installedOnly, join(home, '.codex'),
-      noRunner, undefined, undefined, control)
+      noRunner, undefined, undefined, control, noCodex)
     assert.deepEqual(catalog.filter((m) => m.cli === 'pi'), [
       { cli: 'pi', model: 'opencode-go/muse-spark-1.3-contributor', name: 'Pi · Muse Spark 1.3', efforts: ['xhigh'] },
       { cli: 'pi', name: 'Pi · client default', efforts: [] },
@@ -538,7 +578,7 @@ test('model catalog merges user-curated entries ahead of discovered ones', async
     assert.deepEqual(await readCuratedModels(join(control, 'missing-dir')), [])
     await writeFile(join(control, 'ai-models.json'), 'not json')
     assert.deepEqual(await readModels(home, async (cli) => cli === 'codex', join(home, '.codex'),
-      noRunner, undefined, undefined, control), [
+      noRunner, undefined, undefined, control, noCodex), [
       { cli: 'codex', model: 'fixture-model', name: 'Fixture', efforts: ['medium'] },
     ])
   } finally {

package/test/application-controls.test.ts

@@ -8,6 +8,7 @@ import { ApplicationChannel, applicationScope } from '../src/application-channel
 import { ControlStore } from '../src/control-state.js'
 import { createAiMenu } from '../src/menu.js'
 import { RunStore } from '../src/runs.js'
+import { softwareStatus } from '../src/software-status.js'
 
 test('shared controls validate detected host presets against the host catalog', async t => {
   const root = await mkdtemp(join(tmpdir(), 'ez-host-controls-'))
@@ -67,6 +68,8 @@ test('private scope reset and model controls preserve running sessions and share
     ...(body===undefined?{}:{body:JSON.stringify(body)}),
   })
   const before = await (await call()).json() as any
+  assert.deepEqual(before.software,await softwareStatus(root))
+  assert.match(before.software[0],/^Relay: running · /)
   assert.equal(before.activeSessionId,run.execution!.sessionId)
   assert.equal(JSON.stringify(before).includes('native-private'),false)
   assert.equal((await channel.scopeControls(second.bindingId,'exercise')).activeSessionId,null)

package/test/channel-owner.test.ts

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

package/test/desktop-bridge.test.ts

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

package/test/failure.test.ts

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

package/test/host-executor.test.ts

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

package/test/install-tools.test.mjs

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

package/test/native-tasks.test.ts

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

package/test/plugin-manager.test.mjs

@@ -46,6 +46,21 @@ async function fixture(t) {
  const call=(...args)=>exec(process.execPath,[bin,'--home',home,...args],{env});
  return {root,source,home,deploymentDir,workspace,control,hostConfig,fake,log,manifest,deployment,env,call};
 }
+test('install preserves reviewed package modes under a restrictive umask',async t=>{
+ const f=await fixture(t);
+ await fs.mkdir(path.join(f.source,'nested'));await fs.writeFile(path.join(f.source,'nested','note.md'),'Synthetic');
+ const pkg=JSON.parse(await fs.readFile(path.join(f.source,'package.json'),'utf8'));pkg.files.push('nested');
+ await fs.writeFile(path.join(f.source,'package.json'),JSON.stringify(pkg));await fs.chmod(path.join(f.source,'client.mjs'),0o755);
+ const p=await snapshot(f.source);await init(f.home,f.workspace);
+ const argv=['--home',f.home,'plugins','install','sample','--source',f.source,'--revision',p.revision];
+ const script=`process.umask(0o077);const m=await import(${JSON.stringify(new URL('../src/plugins/manager.mjs',import.meta.url).href)});await m.main(${JSON.stringify(argv)});`;
+ await exec(process.execPath,['--input-type=module','-e',script],{env:f.env});
+ const record=JSON.parse(await fs.readFile(path.join(f.home,'registry.json'),'utf8')).plugins.sample;
+ for(const [relative,file]of p.files)assert.equal((await fs.stat(path.join(record.source,relative))).mode&0o777,file.mode,relative);
+ assert.equal((await fs.stat(path.join(record.source,'nested'))).mode&0o777,0o755);
+ assert.equal((await fs.stat(record.source)).mode&0o777,0o700);
+ assert.equal((await snapshot(record.source)).revision,p.revision);
+});
 test('persistent connection reuses one container and releases registry lock between frames',async t=>{
  const f=await fixture(t),p=await snapshot(f.source);await init(f.home,f.workspace);await f.call('plugins','install','sample','--source',f.source,'--revision',p.revision);
  await fs.writeFile(path.join(f.fake,'docker'),`#!${process.execPath}\nif(process.argv[2]==='container')process.exit(0);require('readline').createInterface({input:process.stdin}).on('line',line=>{const f=JSON.parse(line);console.log(JSON.stringify(f.coreResponse?{reply:f.coreResponse}:{coreRequest:{id:f.id,method:'tools.list',params:{}}}));});`,{mode:0o700});