@jc_stack/ez-agents 0.1.0-beta.13 → 0.1.0-beta.18

package/test/agent-guidance.test.ts

@@ -0,0 +1,110 @@
+import assert from 'node:assert/strict'
+import { execFile } from 'node:child_process'
+import { randomUUID } from 'node:crypto'
+import { mkdir, readFile, rm, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import path from 'node:path'
+import { fileURLToPath, pathToFileURL } from 'node:url'
+import { promisify } from 'node:util'
+import test from 'node:test'
+import { desktopJobPrompt } from '../src/desktop-bridge.js'
+import { executorJobPrompt } from '../src/executor.js'
+import { taskArguments } from '../src/task-executor.js'
+import { initializeWorkspace } from '../src/workspace.js'
+
+const sharedGuidancePath = fileURLToPath(new URL('../templates/agent-guidance.md', import.meta.url))
+const sharedLoaderPath = fileURLToPath(new URL('../src/agent-guidance.ts', import.meta.url))
+const tsxLoaderPath = fileURLToPath(new URL('../node_modules/tsx/dist/loader.mjs', import.meta.url))
+const execFileAsync = promisify(execFile)
+const runNode = (code: string, cwd: string) => execFileAsync(process.execPath, [
+  '--import', tsxLoaderPath, '--input-type=module', '-e', code,
+], { cwd, encoding: 'utf8' })
+
+test('CLI and desktop prompt builders use current package guidance', async () => {
+  const shared = (await readFile(sharedGuidancePath, 'utf8')).trim()
+  const prompts = [
+    ['CLI', executorJobPrompt('tg_owner', ['owner request'])],
+    ['desktop', desktopJobPrompt('tg_owner_gui', ['owner request'], undefined, '/tmp/bin', '/tmp/control')],
+  ] as const
+  for (const [kind, prompt] of prompts)
+    assert.ok(prompt.includes(shared), `${kind} prompt is missing the current package guidance`)
+})
+
+test('package guidance resolution ignores a workspace shadow file', async () => {
+  const root = path.join(tmpdir(), `ez-guidance-${randomUUID()}`)
+  await mkdir(root, { recursive: true })
+  const workspace = path.join(root, 'agent')
+  const workspaceMarker = 'WORKSPACE_GUIDANCE_MUST_NOT_BE_IMPORTED'
+  try {
+    await mkdir(path.join(workspace, 'templates'), { recursive: true })
+    await writeFile(path.join(workspace, 'templates', 'agent-guidance.md'), workspaceMarker)
+    const result = await runNode(
+      `import { agentGuidance } from ${JSON.stringify(pathToFileURL(sharedLoaderPath).href)}; process.stdout.write(agentGuidance())`,
+      workspace,
+    )
+    assert.ok(result.stdout.includes((await readFile(sharedGuidancePath, 'utf8')).trim()))
+    assert.ok(!result.stdout.includes(workspaceMarker))
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('workspace initialization preserves a customized AGENTS.md', async () => {
+  const root = path.join(tmpdir(), `ez-guidance-workspace-${randomUUID()}`)
+  const workspace = path.join(root, 'agent')
+  try {
+    await initializeWorkspace(workspace)
+    const custom = '# Workspace-specific purpose\nKeep this local guidance unchanged.\n'
+    await writeFile(path.join(workspace, 'AGENTS.md'), custom)
+    await initializeWorkspace(workspace)
+    assert.equal(await readFile(path.join(workspace, 'AGENTS.md'), 'utf8'), custom)
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})
+
+test('restricted task arguments retain bounded permissions and do not receive owner guidance', () => {
+  const directory = '/tmp/ez-restricted-task/workspace'
+  const args = taskArguments(directory, ['node', 'broker'], 'approved task')
+  assert.ok(args.includes('default_permissions="ez-task"'))
+  assert.ok(args.includes(`permissions.ez-task.filesystem={":root"="deny",":minimal"="read",${JSON.stringify(directory)}="write"}`))
+  assert.ok(args.includes('permissions.ez-task.network.enabled=false'))
+  assert.ok(args.includes('--disable') && args.includes('shell_tool'))
+  assert.ok(!args.some((arg) => arg.includes('# Shared Ez guidance')))
+})
+
+test('copied package guidance refreshes on each call and missing guidance fails visibly', async () => {
+  const root = path.join(tmpdir(), `ez-guidance-loader-${randomUUID()}`)
+  const source = path.join(root, 'src')
+  const templates = path.join(root, 'templates')
+  const loaderPath = path.join(source, 'agent-guidance.ts')
+  const guidancePath = path.join(templates, 'agent-guidance.md')
+  await mkdir(source, { recursive: true })
+  await mkdir(templates, { recursive: true })
+  try {
+    await writeFile(path.join(root, 'package.json'), JSON.stringify({ type: 'module' }))
+    await writeFile(loaderPath, await readFile(sharedLoaderPath, 'utf8'))
+    await writeFile(guidancePath, 'fixture guidance one')
+    const code = `
+      import { renameSync, writeFileSync } from 'node:fs'
+      import { agentGuidance } from ${JSON.stringify(pathToFileURL(loaderPath).href)}
+      const guidancePath = ${JSON.stringify(guidancePath)}
+      if (agentGuidance() !== 'fixture guidance one') throw new Error('initial fixture was not loaded')
+      writeFileSync(guidancePath, 'fixture guidance two')
+      if (agentGuidance() !== 'fixture guidance two') throw new Error('guidance was cached')
+      renameSync(guidancePath, guidancePath + '.missing')
+      agentGuidance()
+    `
+    await assert.rejects(
+      () => runNode(code, root),
+      (error: any) => {
+        assert.notEqual(error.code, 0)
+        assert.match(error.stderr, /ENOENT/)
+        assert.match(error.stderr, /agent-guidance\.md/)
+        return true
+      },
+    )
+  } finally {
+    await rm(root, { recursive: true, force: true })
+  }
+})

package/test/ai-cli.test.ts

@@ -11,18 +11,19 @@ import {initialPreset} from '../src/ai.js'
 test('explicit CLI/model selection preserves installation default and rejects unavailable choices',async()=>{
  const root=await mkdtemp(path.join(tmpdir(),'ez-ai-cli-'))
  try{
-  await mkdir(path.join(root,'.codex'));await mkdir(path.join(root,'bin'))
+  const controlDir=path.join(root,'control')
+  await mkdir(path.join(controlDir,'cli','codex'),{recursive:true});await mkdir(path.join(root,'bin'))
   await writeFile(path.join(root,'bin/codex'),'#!/bin/sh\nexit 0\n',{mode:0o700})
-  await writeFile(path.join(root,'.codex/models_cache.json'),JSON.stringify({models:[{slug:'test-model',visibility:'list',supported_reasoning_levels:[{effort:'high'}]}]}))
-  const control=new ControlStore(path.join(root,'control'),900000);await control.aiState(initialPreset('grok'))
-  const env={...process.env,HOME:root,PATH:path.join(root,'bin')+path.delimiter+process.env.PATH,EZ_CONTROL_DIR:path.join(root,'control')}
+  await writeFile(path.join(controlDir,'cli','codex','models_cache.json'),JSON.stringify({models:[{slug:'test-model',visibility:'list',supported_reasoning_levels:[{effort:'high'}]}]}))
+  const store=new ControlStore(controlDir,900000);await store.aiState(initialPreset('grok'))
+  const env={...process.env,HOME:root,PATH:path.join(root,'bin')+path.delimiter+process.env.PATH,EZ_CONTROL_DIR:controlDir}
   const bin=fileURLToPath(new URL('../bin/ezenciel-agents-ai.mjs',import.meta.url))
   const call=(model:string)=>spawnSync(process.execPath,[bin,'select','--cli','codex','--model',model,'--effort','high'],{env,encoding:'utf8'})
   const result=call('test-model');assert.equal(result.status,0,result.stderr)
-  const state=await control.status();assert.equal(state.ai?.defaultId,'initial')
+  const state=await store.status();assert.equal(state.ai?.defaultId,'initial')
   assert.equal(state.ai?.presets.find(p=>p.id===state.ai?.selectedId)?.cli,'codex')
   assert.equal(state.activeSession?.cli,'codex')
   assert.notEqual(call('unavailable').status,0)
-  assert.deepEqual(await control.status(),state)
+  assert.deepEqual(await store.status(),state)
  }finally{await rm(root,{recursive:true,force:true})}
 })

package/test/ai.test.ts

@@ -89,6 +89,23 @@ test('model catalog projects native metadata only, excluding hidden entries and
   } finally { await rm(home, { recursive: true, force: true }) }
 })
 
+test('model catalog can read an agent-bound Codex home', async () => {
+  const home = await mkdtemp(join(tmpdir(), 'ez-catalog-home-'))
+  const codexHome = await mkdtemp(join(tmpdir(), 'ez-catalog-codex-'))
+  try {
+    await writeFile(join(codexHome, 'models_cache.json'), JSON.stringify({ models: [
+      { 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), [
+      { cli: 'codex', model: 'gpt-6-astra', name: 'GPT-6 Astra', efforts: ['low'] },
+    ])
+  } finally {
+    await rm(home, { recursive: true, force: true })
+    await rm(codexHome, { recursive: true, force: true })
+  }
+})
+
 test('native executor flags carry the exact model and effort; only structured metadata binds sessions', () => {
   const opts = { workspace: '/tmp/fixture', sessionId: crypto.randomUUID(), isResume: true,
     model: 'fixture-model', effort: 'medium' }
@@ -103,3 +120,27 @@ test('native executor flags carry the exact model and effort; only structured me
   assert.equal(nativeSessionId('codex', JSON.stringify({ type: 'text', thread_id: opts.sessionId })), undefined)
   assert.equal(nativeSessionId('codex', 'Please resume this other session'), undefined)
 })
+
+for (const cli of ['codex', 'codex-gui']) {
+  test(`${cli} initializes Terra high ahead of host defaults and preserves saved choices`, async () => {
+    const dir = await mkdtemp(join(tmpdir(), 'ez-ai-default-'))
+    try {
+      const store = new ControlStore(dir, 1000)
+      const initial = initialPreset(cli)
+      const discovered = [{ id: 'detected_codex', name: 'Host default', cli,
+        model: 'host-model', effort: 'low' }]
+      await store.syncClientPresets(initial, discovered)
+      const first = await store.captureChoice(initial)
+      assert.equal(first.preset.model, 'gpt-5.6-terra')
+      assert.equal(first.preset.effort, 'high')
+      assert.equal(first.preset.cli, cli)
+      const saved = { id: 'custom', name: 'Custom', cli, model: 'custom-model', effort: 'medium' }
+      await store.savePreset(saved)
+      await store.defaultPreset(saved.id)
+      await store.resetSession()
+      const restarted = new ControlStore(dir, 1000)
+      await restarted.syncClientPresets(initial, discovered)
+      assert.deepEqual((await restarted.captureChoice(initial)).preset, saved)
+    } finally { await rm(dir, { recursive: true, force: true }) }
+  })
+}

package/test/busy-reply-relay.test.ts

@@ -0,0 +1,41 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm } from 'node:fs/promises'
+import { join } from 'node:path'
+import { tmpdir } from 'node:os'
+import { spawn } from 'node:child_process'
+import { once } from 'node:events'
+import { createRelay } from '../src/index.js'
+import { ControlStore } from '../src/control-state.js'
+import { RunStore } from '../src/runs.js'
+import type { Update } from 'grammy/types'
+const until=async(check:()=>Promise<boolean>)=>{for(let n=0;n<150;n++){if(await check())return;await new Promise(r=>setTimeout(r,20))}throw new Error('Timed out')}
+test('busy owner replies serialize independently of the writer and reject other senders',async()=>{
+ const root=await mkdtemp(join(tmpdir(),'ez-busy-relay-')),runs=new RunStore(root),control=new ControlStore(root,1000),children:ReturnType<typeof spawn>[]=[]
+ const relay=createRelay({workspace:root,controlDir:root,pairingTtlMs:1000,executorTimeoutMs:0,executorCli:'codex',telegramBotToken:'fixture'},async(_texts,opts)=>{
+  const child=spawn(process.execPath,['-e','setInterval(()=>{},1000)'],{detached:true});children.push(child);await once(child,'spawn')
+  return {child,stdout:'',cleanup:async()=>{}}
+ })
+ relay.bot.botInfo={id:999,is_bot:true,first_name:'Fixture',username:'fixture_bot'} as any
+ relay.bot.api.config.use(async()=>({ok:true,result:true}) as any)
+ const message=(id:number,from=101,type='private'):Update=>({update_id:id,message:{message_id:id,date:0,text:'status',from:{id:from,is_bot:false,first_name:'Fixture'},chat:{id:from,type}}} as Update)
+ try{
+  await control.requestPairing(101,101);await control.approveOwner(101)
+  await relay.bot.handleUpdate(message(1));await relay.drainInbox(true)
+  await relay.bot.handleUpdate(message(2));await relay.drainInbox(true)
+  await relay.bot.handleUpdate(message(3));await relay.drainInbox(true)
+  assert.equal((await runs.get('tg_2'))?.replyOnly,true)
+  assert.equal((await runs.get('tg_3'))?.status,'queued')
+  assert.equal(children.length,2)
+  await relay.bot.handleUpdate(message(4,202));await relay.drainInbox(true)
+  await relay.bot.handleUpdate(message(5,-42,'group'));await relay.drainInbox(true)
+  assert.equal(children.length,2)
+  children[1].kill()
+  await until(async()=>children.length===3)
+  assert.equal(children[0].exitCode,null)
+  assert.equal(children[0].signalCode,null)
+  assert.equal((await runs.get('tg_3'))?.replyOnly,true)
+  await relay.bot.handleUpdate({...message(6),message:{...message(6).message!,text:'/stop'}} as Update)
+  await until(async()=>children.every(c=>c.exitCode!==null || c.signalCode!==null))
+ }finally{await relay.stop();for(const c of children)c.kill();await until(async()=>!(await runs.list()).some(r=>r.status==='running'));await rm(root,{recursive:true,force:true})}
+})

package/test/client-defaults.test.ts

@@ -3,9 +3,9 @@ import assert from 'node:assert/strict'
 import { mkdtemp, mkdir, writeFile, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { discoverDefaults, grokSettings } from '../src/client-defaults.js'
+import { discoverDefaults, grokSettings, resolvedCodexDefaults } from '../src/client-defaults.js'
 import { ControlStore } from '../src/control-state.js'
-import { initialPreset } from '../src/ai.js'
+import { initialPreset, statusPreset } from '../src/ai.js'
 
 test('discovery projects configured choices only; no credentials or guessed wrapper defaults', async () => {
   const home = await mkdtemp(join(tmpdir(), 'ez-defaults-'))
@@ -15,8 +15,11 @@ test('discovery projects configured choices only; no credentials or guessed wrap
     await mkdir(join(home, '.claude'))
     await writeFile(join(home, '.claude/settings.json'), JSON.stringify({ model: 'fixture-claude', effortLevel: 'medium', apiKey: 'fixture-secret' }))
     const choices = await discoverDefaults(home, {
-      home, available: async () => true,
-      codex: async () => ({ model: 'fixture-codex', effort: 'low', apiKey: 'fixture-secret' }),
+      home, codexHome: '/agent/control/cli/codex', available: async () => true,
+      codex: async (_cwd, codexHome) => {
+        assert.equal(codexHome, '/agent/control/cli/codex')
+        return { model: 'fixture-codex', effort: 'low', apiKey: 'fixture-secret' }
+      },
       run: async () => JSON.stringify({ model: 'fixture/provider', token: 'fixture-secret' }),
     })
     assert.deepEqual(choices.map(({ cli, model, effort }) => ({ cli, model, effort })), [
@@ -24,13 +27,32 @@ test('discovery projects configured choices only; no credentials or guessed wrap
       { cli: 'codex', model: 'fixture-codex', effort: 'low' },
       { cli: 'claude', model: 'fixture-claude', effort: 'medium' },
       { cli: 'opencode', model: 'fixture/provider', effort: undefined },
-      { cli: 'codex-gui', model: 'fixture-codex', effort: 'low' },
+      { cli: 'codex-gui', model: undefined, effort: undefined },
     ])
     assert.ok(!JSON.stringify(choices).includes('fixture-secret'))
     assert.ok(choices.every((p) => /^detected_[a-z0-9]+$/.test(p.id)))
   } finally { await rm(home, { recursive: true, force: true }) }
 })
 
+test('Codex config defaults fall back to its native default-model catalog', () => {
+  const catalog = [
+    { id: 'fast', model: 'gpt-fast', defaultReasoningEffort: 'low' },
+    { id: 'default', model: 'gpt-default', defaultReasoningEffort: 'medium', isDefault: true },
+  ]
+  assert.deepEqual(resolvedCodexDefaults({}, catalog), { model: 'gpt-default', effort: 'medium' })
+  assert.deepEqual(resolvedCodexDefaults({ model: 'gpt-fast' }, catalog), { model: 'gpt-fast', effort: 'low' })
+  assert.deepEqual(resolvedCodexDefaults({ model: 'custom', model_reasoning_effort: 'high' }, catalog),
+    { model: 'custom', effort: 'high' })
+})
+
+test('native Codex fallback is opt-in so setup does not pin a client default', async () => {
+  const codex = async (_cwd: string, _home?: string, nativeFallback = false) =>
+    nativeFallback ? { model: 'native-default', effort: 'medium' } : {}
+  const options = { available: async (cli: string) => cli === 'codex', codex }
+  assert.equal((await discoverDefaults('/tmp', options))[0]?.model, undefined)
+  assert.equal((await discoverDefaults('/tmp', { ...options, nativeCodexFallback: true }))[0]?.model, 'native-default')
+})
+
 test('missing clients are excluded; unavailable metadata stays client default', async () => {
   const choices = await discoverDefaults('/tmp', { available: async (cli) => cli === 'opencode',
     run: async () => { throw new Error('No metadata') } })
@@ -41,6 +63,16 @@ test('missing clients are excluded; unavailable metadata stays client default',
   assert.deepEqual(grokSettings('[models]\ndefault="fixture" # comment\n'), { model: 'fixture', effort: undefined })
 })
 
+test('status projects the native client default without pinning the seed', () => {
+  const initial = { ...initialPreset('codex'), model: undefined, effort: undefined }
+  const discovered = { id: 'detected_codex', name: 'codex · fixture', cli: 'codex', model: 'fixture-codex', effort: 'medium' }
+  assert.deepEqual(statusPreset(initial, [discovered]), discovered)
+  assert.deepEqual(statusPreset({ ...initial, id: 'detected_empty' }, [discovered]), discovered)
+  const explicit = { ...discovered, id: 'saved', model: 'chosen-codex', effort: 'high' }
+  assert.equal(statusPreset(explicit, [discovered]), explicit)
+  assert.equal(statusPreset(initialPreset('codex-gui'), [{ ...discovered, cli: 'codex-gui' }]).model, 'gpt-5.6-terra')
+})
+
 test('seed uses the configured executor; repeated refresh preserves current/default and queued snapshots', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-seed-'))
   try {

package/test/codex-context.test.ts

@@ -41,6 +41,7 @@ test('scheduled Codex sessions isolate native state and snapshot only agent conf
   await mkdir(path.join(root,'.codex'));await mkdir(bin);await mkdir(path.join(controlDir,'cli/codex'),{recursive:true})
   await writeFile(path.join(root,'.codex/auth.json'),'{}');await writeFile(path.join(root,'.codex/config.toml'),'# personal configuration')
   await writeFile(path.join(controlDir,'cli/codex/config.toml'),'# agent configuration')
+  await writeFile(path.join(controlDir,'cli/codex/auth.json'),'{"private_agent_fixture":true}')
   await writeFile(path.join(bin,'codex'),`#!${process.execPath}
 const fs=require('fs');fs.writeFileSync(process.env.CODEX_HOME+'/observed.json',JSON.stringify({home:process.env.CODEX_HOME,secret:process.env.TELEGRAM_BOT_TOKEN}));
 const send=x=>console.log(JSON.stringify(x));require('readline').createInterface({input:process.stdin}).on('line',line=>{const q=JSON.parse(line);if(!q.id)return;
@@ -50,6 +51,7 @@ send({id:q.id,result:q.method==='thread/goal/get'?{goal:null}:{}});});setInterva
 `,{mode:0o700})
   process.env.HOME=root;process.env.PATH=bin+path.delimiter+priorPath
   await assert.rejects(startExecutorJob(['test'],{workspace:root,controlDir,binDir:bin,cli:'codex',runId:'r_schedule_/../../escape',timeoutMs:0}),/Invalid native task run ID/)
+  await ownerRun(controlDir, 'r_pair_fixture')
   await Promise.all(['r_schedule_one','r_schedule_two'].map(async runId=>{
    await ownerRun(controlDir, runId)
    const job=await startExecutorJob(['test'],{workspace:root,controlDir,binDir:bin,cli:'codex',runId,timeoutMs:0})
@@ -57,9 +59,10 @@ send({id:q.id,result:q.method==='thread/goal/get'?{goal:null}:{}});});setInterva
    const home=path.join(controlDir,'cli/codex/tasks',runId)
    assert.equal(JSON.parse(await readFile(path.join(home,'observed.json'),'utf8')).home,home)
    assert.equal(await readFile(path.join(home,'config.toml'),'utf8'),'# agent configuration')
-   assert.equal(await readlink(path.join(home,'auth.json')),path.join(root,'.codex/auth.json'))
+   assert.equal(await readlink(path.join(home,'auth.json')),path.join(controlDir,'cli/codex/auth.json'))
+   assert.equal(await readFile(path.join(home,'auth.json'),'utf8'),'{"private_agent_fixture":true}')
   }))
-  assert.deepEqual((await readdir(path.join(controlDir,'cli/codex'))).sort(),['config.toml','tasks'])
+  assert.deepEqual((await readdir(path.join(controlDir,'cli/codex'))).sort(),['auth.json','config.toml','tasks'])
  }finally{
   if(priorHome===undefined)delete process.env.HOME;else process.env.HOME=priorHome
   if(priorPath===undefined)delete process.env.PATH;else process.env.PATH=priorPath

package/test/codex-session.test.ts

@@ -33,14 +33,16 @@ if(q.method==='thread/goal/get'){
  }
 }
 });setInterval(()=>{},1000);`
+  let threadConfig:any
   const launch=()=>{
     const child=spawn(process.execPath,['-e',program],{stdio:['pipe','pipe','pipe'],detached:process.platform!=='win32'})
     const write=child.stdin.write.bind(child.stdin)
-    child.stdin.write=((chunk:any,...args:any[])=>{try{requests.push(JSON.parse(String(chunk)).method)}catch{};return (write as any)(chunk,...args)}) as typeof child.stdin.write
+    child.stdin.write=((chunk:any,...args:any[])=>{try{requests.push(JSON.parse(String(chunk)).method);if(JSON.parse(String(chunk)).method==='thread/start')threadConfig=JSON.parse(String(chunk)).params.config}catch{};return (write as any)(chunk,...args)}) as typeof child.stdin.write
     return child
   }
   const plain=['plain','tool-goal'].includes(mode)
-  const result=await runCodexSession({workspace:'/tmp',controlDir:'/tmp/control',prompt:'test',goal:!plain},{launch,emit:line=>output.push(line)})
+  const result=await runCodexSession({workspace:'/tmp',controlDir:'/tmp/control',sharedWorkspace:'/canonical',prompt:'test',goal:!plain},{launch,emit:line=>output.push(line)})
+  assert.ok(threadConfig['sandbox_workspace_write.writable_roots'].includes('/canonical'))
   assert.equal(result,['plain','goal','tool-goal'].includes(mode)?0:1)
   assert.equal(requests.filter(x=>x==='turn/start').length,plain?1:0,'transport must not send goal continuation prompts')
   assert.equal(requests.filter(x=>x==='thread/goal/set').length,plain?0:1)

package/test/config.test.ts

@@ -30,3 +30,32 @@ test('loads executor CLI configuration with agy fallback', () => {
   const customConfig = loadConfig({ TELEGRAM_BOT_TOKEN: 'test', EZ_EXECUTOR_CLI: 'claude' })
   assert.equal(customConfig.executorCli, 'claude')
 })
+
+test('Codex context limit is configurable and rejects invalid values', () => {
+  assert.equal(loadConfig({TELEGRAM_BOT_TOKEN:'test'}).codexAutoCompactTokens,64000)
+  assert.equal(loadConfig({TELEGRAM_BOT_TOKEN:'test',EZ_CODEX_AUTO_COMPACT_TOKENS:'32000'}).codexAutoCompactTokens,32000)
+  for(const value of ['0','-1','bad','1.5','9007199254740992'])
+    assert.throws(()=>loadConfig({TELEGRAM_BOT_TOKEN:'test',EZ_CODEX_AUTO_COMPACT_TOKENS:value}),/positive integer/)
+})
+
+test('PagerDuty Stocks monitoring requires a routing key and validates its target', () => {
+  assert.throws(
+    () => loadConfig({ TELEGRAM_BOT_TOKEN: 'test', EZ_PAGERDUTY_STOCKS_HEALTH_URL: 'http://stocks.test/health/critical' }),
+    /PAGERDUTY_ROUTING_KEY is required/,
+  )
+  assert.throws(
+    () => loadConfig({ TELEGRAM_BOT_TOKEN: 'test', PAGERDUTY_ROUTING_KEY: 'key', EZ_PAGERDUTY_STOCKS_HEALTH_URL: 'file:///private/health' }),
+    /absolute HTTP\(S\) URL/,
+  )
+  const config = loadConfig({
+    TELEGRAM_BOT_TOKEN: 'test',
+    PAGERDUTY_ROUTING_KEY: 'pagerduty-key',
+    EZ_PAGERDUTY_STOCKS_HEALTH_URL: 'http://stocks.test/health/critical',
+    EZ_PAGERDUTY_POLL_SECONDS: '45',
+    EZ_PAGERDUTY_FAILURE_THRESHOLD: '4',
+  })
+  assert.equal(config.pagerDutyRoutingKey, 'pagerduty-key')
+  assert.equal(config.pagerDutyStocksHealthUrl, 'http://stocks.test/health/critical')
+  assert.equal(config.pagerDutyPollMs, 45_000)
+  assert.equal(config.pagerDutyFailureThreshold, 4)
+})

package/test/executor.test.ts

@@ -64,9 +64,10 @@ test('Telegram replies are split within the configured message limit', () => {
 })
 
 test('the executor receives a deliberately small environment', () => {
-  const environment = executorEnvironment({ PATH: '/bin', HOME: '/tmp/home', TELEGRAM_BOT_TOKEN: 'secret', AWS_SECRET_ACCESS_KEY: 'secret' })
+  const environment = executorEnvironment({ PATH: '/bin', HOME: '/tmp/home', TELEGRAM_BOT_TOKEN: 'secret', PAGERDUTY_ROUTING_KEY: 'secret', AWS_SECRET_ACCESS_KEY: 'secret' })
   assert.deepEqual(environment, { PATH: '/bin', HOME: '/tmp/home' })
   assert.ok(!('TELEGRAM_BOT_TOKEN' in environment))
+  assert.ok(!('PAGERDUTY_ROUTING_KEY' in environment))
 })
 
 test('the Grok job env binds the run and still strips the bot token', () => {
@@ -174,3 +175,12 @@ test('Codex plugin access stays scoped to the explicitly bound registry', () =>
   assert.equal(args[args.indexOf('--sandbox')+1],'workspace-write')
   assert.ok(!EXECUTOR_REGISTRY.codex.buildArgs({workspace:'/agent/mind'},'','hello').includes('sandbox_workspace_write.network_access=true'))
 })
+
+test('Codex compaction preserves native resume and validates transported options',()=>{
+ const args=EXECUTOR_REGISTRY.codex.buildArgs({workspace:'/agent',sessionId:'native-id',isResume:true,codexAutoCompactTokens:32000},'', 'hello')
+ assert.ok(args.includes('model_auto_compact_token_limit=32000'))
+ assert.deepEqual(args.slice(-3),['resume','native-id','hello'])
+ assert.ok(EXECUTOR_REGISTRY.codex.buildArgs({workspace:'/agent'},'','hello').includes('model_auto_compact_token_limit=64000'))
+ for(const value of [0,-1,NaN,1.5]) assert.throws(()=>EXECUTOR_REGISTRY.codex.buildArgs({workspace:'/agent',codexAutoCompactTokens:value},'','hello'),/compaction/)
+ assert.ok(!EXECUTOR_REGISTRY.claude.buildArgs({workspace:'/agent',codexAutoCompactTokens:32000},'','hello').some(arg=>arg.includes('compact')))
+})