@jc_stack/ez-agents 0.1.0-beta.26 → 0.1.0-beta.28

package/test/intake-relay.test.ts

@@ -14,6 +14,7 @@ import { ApprovalStore } from '../src/approval.js'
 import { Tasks } from '../src/tasks.js'
 import { ownerRun } from './helpers/owner-run.js'
 import { packageVersion } from '../src/version.js'
+import type { Config } from '../src/config.js'
 
 const message = (id: number, text = 'hello'): Update => ({
   update_id: id,
@@ -25,7 +26,7 @@ const message = (id: number, text = 'hello'): Update => ({
     chat: { id: 101, type: 'private', first_name: 'Fixture' },
   },
 })
-const fixture = async () => {
+const fixture = async (overrides: Partial<Config> = {}) => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-intake-relay-'))
   const launched: string[][] = []
   const replies: string[] = []
@@ -40,6 +41,7 @@ const fixture = async () => {
     executorCli: 'grok' as const,
     telegramBotToken: 'fixture',
     geminiApiKey: 'fixture',
+    ...overrides,
   }
   const make = () => {
     const relay = createRelay(config, async (texts) => {
@@ -57,7 +59,7 @@ const fixture = async () => {
     } as typeof relay.bot.botInfo
     relay.bot.api.config.use(async (_previous, method, payload) => {
       if (method === 'getChatMember' && members.get((payload as {user_id: number}).user_id) === 'error') throw new Error('Fixture membership unavailable')
-      if (method === 'sendMessage') replies.push((payload as { text: string }).text)
+      if (method === 'sendMessage' || method === 'editMessageText') replies.push((payload as { text: string }).text)
       const keyboard = (payload as { reply_markup?: { inline_keyboard?: { text: string; callback_data: string }[][] } }).reply_markup?.inline_keyboard
       if (keyboard) keyboards.push(keyboard)
       return {
@@ -191,7 +193,7 @@ test('owner group discovery routes only to the private chat and rechecks identit
     const run = (await new RunStore(f.dir).list())[0]
     assert.equal(run.chatId, 101)
     assert.equal(run.messageId, undefined)
-    assert.match(run.texts[0], /Reply privately/)
+    assert.deepEqual(JSON.parse(run.texts[0]),{event:'owner_message_in_unbound_group',chatId:-101,title:'Family',messageId:3,text:'Hi from the group'})
     assert.match(run.texts[0], /"chatId":-101/)
     assert.equal(f.launched.length, 1)
     await f.relay.bot.handleUpdate(group(4))
@@ -201,7 +203,7 @@ test('owner group discovery routes only to the private chat and rechecks identit
   } finally { await f.close() }
 })
 
-test('four-item menu is owner-only; available AI choices work and forged/stale buttons cannot change settings', async () => {
+test('conversation menu is owner-only and removes the retired settings control', async () => {
   const f = await fixture()
   const callback = (id: number, data: string, user = 101): Update => ({
     update_id: id,
@@ -211,32 +213,53 @@ test('four-item menu is owner-only; available AI choices work and forged/stale b
   try {
     await f.relay.bot.handleUpdate(message(1, '/menu'))
     assert.deepEqual(f.keyboards.at(-1)!.flat().map((b) => b.text),
-      ['New conversation', 'Choose AI', 'Work status', 'Settings'])
-    await f.relay.bot.handleUpdate(message(2, '/ai'))
-    const pick = f.keyboards.at(-1)!.flat()[0].callback_data
+      ['New conversation', 'Conversations', 'Choose AI', 'Work status'])
+    await f.relay.bot.handleUpdate(message(2, '/settings'))
+    assert.match(f.replies.at(-1)!, /Settings was removed.*Use \/ai/)
+    await f.relay.bot.handleUpdate(message(3, '/ai'))
+    const pick = f.keyboards.at(-1)!.flat().find((button) => button.text === 'Refresh available AIs')!.callback_data
     const store = new ControlStore(f.dir, 1000)
-    await f.relay.bot.handleUpdate(callback(3, pick, 202))
-    assert.equal(await store.getActiveSession(), null)
-    await f.relay.bot.handleUpdate(callback(4, 'ai:forged'))
-    assert.equal(await store.getActiveSession(), null)
-    await f.relay.bot.handleUpdate(callback(5, pick))
-    if (!(await store.getActiveSession())) {
-      let useNow = f.keyboards.at(-1)!.flat().find((button) => button.text === 'Use now')?.callback_data
-      if (!useNow) {
-        await f.relay.bot.handleUpdate(callback(6, f.keyboards.at(-1)!.flat()[0].callback_data))
-        useNow = f.keyboards.at(-1)!.flat().find((button) => button.text === 'Use now')!.callback_data
-      }
-      await f.relay.bot.handleUpdate(callback(7, useNow))
-    }
-    assert.ok(await store.getActiveSession())
-    await f.relay.bot.handleUpdate(callback(8, pick))
+    const before = await store.status()
+    const keyboardCount = f.keyboards.length
+    await f.relay.bot.handleUpdate(callback(4, pick, 202))
+    assert.equal(f.keyboards.length, keyboardCount)
+    assert.deepEqual(await store.status(), before)
+    await f.relay.bot.handleUpdate(callback(5, 'ai:forged'))
+    assert.match(f.replies.at(-1)!, /Menu expired/)
+    assert.deepEqual(await store.status(), before)
+    await f.relay.bot.handleUpdate(callback(6, pick))
+    assert.equal(f.keyboards.length, keyboardCount + 1)
+    const refreshed = await store.status()
+    await f.relay.bot.handleUpdate(callback(7, pick))
     assert.match(f.replies.at(-1)!, /Menu expired/)
-    await f.relay.bot.handleUpdate(message(9, '/settings'))
-    assert.match(f.replies.at(-1)!, /Default for new conversations/)
+    assert.deepEqual(await store.status(), refreshed)
     await f.relay.bot.handleUpdate(message(8, '/status'))
     assert.ok(f.keyboards.at(-1)!.flat().some((button) => button.text === 'Scheduled tasks'))
     await f.relay.bot.handleUpdate(callback(9, 'menu:scheduled-tasks'))
-    assert.match(f.replies.at(-1)!, /No scheduled tasks for this owner/)
+    assert.match(f.replies.at(-1)!, /No active scheduled tasks for this owner/)
+    assert.equal(f.launched.length, 0)
+  } finally { await f.close() }
+})
+
+test('application-backed channels keep AI and retired settings controls in the application', async () => {
+  const f = await fixture({ channelBackendUrl: 'http://127.0.0.1:1', channelBackendToken: 'fixture' })
+  try {
+    const store = new ControlStore(f.dir, 1000)
+    const before = await store.status()
+    let id = 1
+    for (const text of ['/ai', '/settings', '/new', '/chats', '/rename Example']) {
+      await f.relay.bot.handleUpdate(message(id++, text))
+      assert.match(f.replies.at(-1)!, /managed in the connected application/)
+    }
+    for (const data of ['menu:ai', 'menu:settings', 'menu:new', 'menu:chats', 'chat:list:0:0', 'chat:open:invalid', 'ai:old-button']) {
+      await f.relay.bot.handleUpdate({ update_id: id, callback_query: {
+        id: String(id), chat_instance: 'fixture', data,
+        from: { id: 101, first_name: 'Fixture', is_bot: false }, message: message(id++).message!,
+      } })
+      assert.match(f.replies.at(-1)!, /managed in the connected application/)
+    }
+    assert.deepEqual(await store.status(), before)
+    assert.equal(f.keyboards.length, 0)
     assert.equal(f.launched.length, 0)
   } finally { await f.close() }
 })
@@ -484,3 +507,124 @@ test('approved family messages enter restricted task runs, never the owner sessi
     await tasks.ownerCall('setup','list',{}).then(()=>assert.fail('completed run cannot change grants'),()=>{})
   } finally {await f.close()}
 })
+
+
+test('Telegram named conversation buttons switch and archive without rerouting accepted messages', async () => {
+  const f = await fixture()
+  try {
+    let id = 1
+    const send = (text: string) => f.relay.bot.handleUpdate(message(id++, text))
+    const click = async (data: string, user = 101) => f.relay.bot.handleUpdate({ update_id: id, callback_query: {
+      id: String(id), chat_instance: 'fixture', data,
+      from: { id: user, first_name: 'Fixture', is_bot: false }, message: message(id++).message!,
+    } })
+    const store = new ControlStore(f.dir, 1000)
+    await send('Client launch')
+    const first = (await store.getActiveSession())!.sessionId
+    await send('/new')
+    await send('Holiday planning')
+    const second = (await store.getActiveSession())!.sessionId
+    await send('/chats')
+    assert.ok(f.keyboards.at(-1)!.flat().some(b => b.text === 'Client launch'))
+    assert.ok(!f.keyboards.at(-1)!.flat().some(b => b.callback_data.startsWith('chat:archive:')))
+    assert.ok(f.keyboards.at(-1)!.every(row => row.filter(b => b.callback_data.startsWith('chat:open:')).length === 0 || row.length === 1))
+    const before = await store.status()
+    await click(`chat:open:${first}`, 202)
+    await click(`chat:archive:${second}`, 202)
+    assert.deepEqual(await store.status(), before)
+    await click(`chat:open:${first}`)
+    assert.equal((await store.getActiveSession())!.sessionId, first)
+    assert.deepEqual(f.keyboards.at(-1)!.flat().filter(b => b.callback_data.startsWith('chat:archive:')), [{text: 'Archive this conversation', callback_data: `chat:archive:${first}`}])
+    await send('/rename@fixture_bot <Client & launch>')
+    assert.equal((await store.getActiveSession())!.title, '<Client & launch>')
+    await click(`chat:archive:${first}`)
+    assert.equal(await store.getActiveSession(), null)
+    await click('chat:list:0:0')
+    assert.ok(!f.keyboards.at(-1)!.flat().some(b => b.callback_data === `chat:open:${first}`))
+    await click('chat:list:1:0')
+    assert.ok(f.keyboards.at(-1)!.flat().some(b => b.text === '<Client & launch>'))
+    await f.restart()
+    await click(`chat:restore:${first}`)
+    await click(`chat:open:${first}`)
+    await send('Continue launch')
+    for (let n = 0; n < 3; n++) await f.relay.drainInbox(true)
+    const runs = await new RunStore(f.dir).list()
+    assert.equal(runs.find(r => r.texts.includes('Holiday planning'))!.execution!.sessionId, second)
+    assert.equal(runs.find(r => r.texts.includes('Continue launch'))!.execution!.sessionId, first)
+    assert.ok(!runs.some(r => r.texts.some(t => t.startsWith('/rename'))))
+    await click('chat:open:../../escape')
+    assert.match(f.replies.at(-1)!, /unavailable/)
+  } finally { await f.close() }
+})
+
+test('conversation menu paginates and stale pages remain usable after archiving', async () => {
+  const f = await fixture()
+  try {
+    const store = new ControlStore(f.dir, 1000)
+    for (let n = 0; n < 10; n++) {
+      await store.captureChoice({ id: 'fixture', name: 'Grok', cli: 'grok' }, `Topic ${n}`)
+      if (n < 9) await store.resetSession()
+    }
+    let id = 1
+    const click = (data: string) => f.relay.bot.handleUpdate({ update_id: id, callback_query: {
+      id: String(id), chat_instance: 'fixture', data,
+      from: { id: 101, first_name: 'Fixture', is_bot: false }, message: message(id++).message!,
+    } })
+    await click('chat:list:0:0')
+    assert.equal(f.keyboards.at(-1)!.flat().filter(b => b.callback_data.startsWith('chat:open:')).length, 8)
+    assert.ok(f.keyboards.at(-1)!.flat().some(b => b.text === 'Next'))
+    await click('chat:list:0:1')
+    assert.equal(f.keyboards.at(-1)!.flat().filter(b => b.callback_data.startsWith('chat:open:')).length, 2)
+    for (const session of await store.listSessions()) await store.archiveSession(session.sessionId, true)
+    await click('chat:list:0:1')
+    assert.equal(f.keyboards.at(-1)!.flat().filter(b => b.callback_data.startsWith('chat:open:')).length, 0)
+  } finally { await f.close() }
+})
+
+
+test('older conversation names come from owner messages and detail keeps archive available when resume fails', async () => {
+  const f = await fixture()
+  try {
+    const store = new ControlStore(f.dir, 1000)
+    const old = await store.ensureActiveSession()
+    await store.markSessionStarted(old.sessionId)
+    const execution = await store.captureChoice({ id: 'grok', name: 'Grok', cli: 'grok' })
+    const runs = new RunStore(f.dir)
+    await runs.create({ chatId: 101, telegramUserId: 101, texts: ['Internal update event'], execution })
+    await runs.create({ chatId: 101, telegramUserId: 101, messageId: 9, texts: [JSON.stringify({event: 'approval_decision', decision: 'approve'})], execution })
+    await runs.create({ chatId: 101, telegramUserId: 101, messageId: 10, texts: ['/start'], execution })
+    await runs.create({ chatId: 101, telegramUserId: 101, messageId: 11, texts: ['Client launch checklist'], execution })
+    await store.captureChoice({ id: 'grok', name: 'Grok', cli: 'grok' }, 'A later message must not relabel old history')
+    assert.equal((await store.getActiveSession())!.title, undefined)
+    await store.resetSession()
+    await f.relay.bot.handleUpdate(message(1, '/chats'))
+    const rows = f.keyboards.at(-1)!
+    assert.ok(rows.flat().some(b => b.text.startsWith('Client launch checklist · ')))
+    assert.ok(!rows.flat().some(b => b.text === '✓ New conversation'))
+    assert.ok(!rows.flat().some(b => b.text.includes(old.sessionId.slice(0, 8))))
+    assert.ok(!rows.flat().some(b => b.callback_data.startsWith('chat:archive:')))
+    await f.relay.bot.handleUpdate({ update_id: 2, callback_query: {
+      id: '2', chat_instance: 'fixture', data: `chat:open:${old.sessionId}`,
+      from: { id: 101, first_name: 'Fixture', is_bot: false }, message: message(2).message!,
+    } })
+    assert.match(f.replies.at(-1)!, /Client launch checklist.*\n.*binding/)
+    assert.deepEqual(f.keyboards.at(-1)![0], [{text: 'Archive this conversation', callback_data: `chat:archive:${old.sessionId}`}])
+  } finally { await f.close() }
+})
+
+
+test('web launcher is private-owner-only and bypasses native intake without replacing controls', async () => {
+  const f=await fixture({webLauncher:{command:'voice',label:'Voice',url:'https://voice.example/'}})
+  try {
+    const stranger=message(1,'/voice');stranger.message!.from!.id=202
+    await f.relay.bot.handleUpdate(stranger)
+    assert.equal(f.keyboards.length,0)
+    await f.relay.bot.handleUpdate(message(2,'/voice'))
+    assert.deepEqual(f.keyboards.at(-1),[[{text:'Voice',web_app:{url:'https://voice.example/'}}]])
+    await f.relay.bot.handleUpdate(message(3,'/menu'))
+    assert.deepEqual(f.keyboards.at(-1)!.flat().map(b=>b.text),['New conversation','Conversations','Choose AI','Work status','Voice'])
+    await f.relay.drainInbox(true);assert.equal(f.launched.length,0)
+    await new ControlStore(f.dir,1000).revokeOwner()
+    const before=f.keyboards.length;await f.relay.bot.handleUpdate(message(4,'/voice'));assert.equal(f.keyboards.length,before)
+  } finally {await f.close()}
+})

package/test/message-history.test.ts

@@ -0,0 +1,127 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { mkdtemp, rm, readFile, writeFile, readdir } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import { promisify } from 'node:util'
+import { execFile } from 'node:child_process'
+import { ownerRun } from './helpers/owner-run.js'
+import { deliveredMessages } from '../src/message-history.js'
+import { RunStore } from '../src/runs.js'
+import { ControlStore } from '../src/control-state.js'
+
+async function fixture(t: test.TestContext) {
+  const dir = await mkdtemp(join(tmpdir(), 'ez-history-'))
+  t.after(() => rm(dir, { recursive: true, force: true }))
+  await ownerRun(dir, 'tg_1')
+  const runs = new RunStore(dir)
+  const patchFixture = async (id: string, patch: Record<string, unknown>) => {
+    const file = join(dir, 'runs', id + '.json')
+    await writeFile(file, JSON.stringify({ ...JSON.parse(await readFile(file, 'utf8')), ...patch }))
+  }
+  const send = async (runId: string, text: string, ids: number[]) => {
+    const item = await runs.enqueueMessage(runId, text)
+    await runs.claimOutbox(item.id)
+    await runs.markOutboxSent(item.id, ids)
+    return join(dir, 'outbox', item.id + '.sent.json')
+  }
+  return { dir, runs, send, patchFixture }
+}
+
+test('CLI retrieves Synopsys delivery from another session without changing sessions or sending', async t => {
+  const { dir, runs, send, patchFixture } = await fixture(t)
+  await ownerRun(dir, 'r_schedule_report')
+  const owner = (await new ControlStore(dir, 1000).status()).owner!
+  await patchFixture('r_schedule_report', { nativeSessionId: 'report_session', scheduled: {
+    id: 's_earnings', revision: 1, dueAt: new Date().toISOString(), pairedAt: owner.pairedAt,
+  } })
+  await send('r_schedule_report', 'Synopsys (SNPS): quarterly results', [10, 11])
+  await runs.patch('r_schedule_report', { status: 'completed' })
+  await patchFixture('tg_1', { texts: ['Why now?'] })
+  await send('tg_1', 'Other report', [12])
+  const before = await readdir(join(dir, 'outbox'))
+  const controlBefore = await new ControlStore(dir, 1000).status()
+  const { stdout } = await promisify(execFile)(process.execPath, ['bin/ezenciel-agents-message.mjs', 'history', '--message-id', '11'], {
+    env: { ...process.env, EZ_CONTROL_DIR: dir, EZ_RUN_ID: 'tg_1' },
+  })
+  const result = JSON.parse(stdout)
+  assert.equal(result.messages.length, 1)
+  assert.equal(result.messages[0].text, 'Synopsys (SNPS): quarterly results')
+  assert.equal(result.messages[0].nativeSessionId, 'report_session')
+  assert.equal(result.messages[0].scheduleId, 's_earnings')
+  assert.deepEqual(result.messages[0].messageIds, [10, 11])
+  assert.deepEqual(await new ControlStore(dir, 1000).status(), controlBefore)
+  assert.deepEqual(await readdir(join(dir, 'outbox')), before)
+  const latest = await deliveredMessages(dir, 'tg_1', { limit: 1 })
+  assert.equal(latest.messages[0].text, 'Other report')
+  assert.equal(latest.hasMore, true)
+})
+
+test('only confirmed deliveries in current owner binding are exposed', async t => {
+  const { dir, runs, send, patchFixture } = await fixture(t)
+  await send('tg_1', 'included', [1])
+  await runs.enqueueMessage('tg_1', 'pending')
+  const failed = await runs.enqueueMessage('tg_1', 'uncertain')
+  await runs.claimOutbox(failed.id)
+  await runs.failOutbox(failed.id, 'unknown', true)
+  await writeFile(join(dir, 'outbox', 'corrupt.sent.json'), '{')
+  await writeFile(join(dir, 'outbox', 'null.sent.json'), 'null')
+  const invalid = await send('tg_1', 'invalid receipt', [2])
+  const record = JSON.parse(await readFile(invalid, 'utf8'))
+  record.receipt.messageIds = []
+  await writeFile(invalid, JSON.stringify(record))
+  for (const [id, patch] of [
+    ['r_other_chat', { chatId: 202 }],
+    ['r_other_owner', { telegramUserId: 202 }],
+    ['r_old', { createdAt: '2000-01-01T00:00:00.000Z' }],
+    ['r_external', { external: { sourceId: 'test', bindingId: 'binding', eventIds: ['1'] } }],
+  ] as const) {
+    await ownerRun(dir, id)
+    await patchFixture(id, patch)
+    await send(id, 'excluded', [3])
+  }
+  assert.deepEqual((await deliveredMessages(dir, 'tg_1')).messages.map(m => m.text), ['included'])
+  await writeFile(join(dir, 'runs', 'broken.json'), '{')
+  assert.equal((await deliveredMessages(dir, 'tg_1')).messages.length, 1)
+})
+
+test('unauthorized callers and invalid arguments fail closed', async t => {
+  const { dir, runs, patchFixture } = await fixture(t)
+  for (const limit of [0, 51, NaN, 1.5]) await assert.rejects(deliveredMessages(dir, 'tg_1', { limit }), /Limit/)
+  await assert.rejects(deliveredMessages(dir, 'tg_1', { messageId: -1 }), /Message ID/)
+  await assert.rejects(deliveredMessages(dir, '../tg_1'), /identifier/)
+  await assert.rejects(deliveredMessages(dir, 'missing'), /No active/)
+  await ownerRun(dir, 'r_external', { sourceId: 'test', bindingId: 'binding', eventIds: ['1'] })
+  await assert.rejects(deliveredMessages(dir, 'r_external'), /blocked/)
+  await patchFixture('tg_1', { telegramUserId: 202 })
+  await assert.rejects(deliveredMessages(dir, 'tg_1'), /owner-mismatch/)
+  await patchFixture('tg_1', { telegramUserId: 101, status: 'completed' })
+  await assert.rejects(deliveredMessages(dir, 'tg_1'), /No active/)
+  await runs.patch('tg_1', { status: 'running' })
+  await new ControlStore(dir, 1000).revokeOwner()
+  await assert.rejects(deliveredMessages(dir, 'tg_1'), /owner-mismatch/)
+})
+
+test('approval messages retain the content delivered to Telegram', async t => {
+  const { dir, send } = await fixture(t)
+  const file = await send('tg_1', 'placeholder', [20])
+  const item = JSON.parse(await readFile(file, 'utf8'))
+  delete item.text
+  item.type = 'approval'
+  item.approvalPrompt = 'Approve this messaging task?'
+  await writeFile(file, JSON.stringify(item))
+  assert.equal((await deliveredMessages(dir, 'tg_1')).messages[0].text, item.approvalPrompt)
+})
+
+test('CLI flushes complete long reports and rejects send options in history mode', async t => {
+  const { dir, send } = await fixture(t)
+  const text = 'Report evidence. '.repeat(8000)
+  await send('tg_1', text, [30])
+  const env = { ...process.env, EZ_CONTROL_DIR: dir, EZ_RUN_ID: 'tg_1' }
+  const cli = [ 'bin/ezenciel-agents-message.mjs', 'history' ]
+  const { stdout } = await promisify(execFile)(process.execPath, cli, { env })
+  assert.equal(JSON.parse(stdout).messages[0].text, text)
+  const before = await readdir(join(dir, 'outbox'))
+  await assert.rejects(promisify(execFile)(process.execPath, [...cli, '--text', 'do not send'], { env }), /Unknown option/)
+  assert.deepEqual(await readdir(join(dir, 'outbox')), before)
+})

package/test/model-policy.test.ts

@@ -11,56 +11,31 @@ import { taskArguments } from '../src/task-executor.js'
 import { runCodexSession } from '../src/codex-session.js'
 import { runDesktopTurn } from '../src/desktop-bridge.js'
 
-test('all non-Luna model selections and launches reject effort above high before spawning', async () => {
-  for (const cli of ['codex', 'codex-gui', 'grok', 'claude', 'opencode', 'agy']) {
-    for (const effort of ['xhigh', 'max', 'ultra', 'unknown']) {
-      const preset = { id:'blocked', name:'Blocked', cli, model:'any-model', effort }
-      await assert.rejects(validateSelection(preset, [], async () => true), /capped at high/)
-      await assert.rejects(startExecutorJob([], { cli, effort, runId:'unused', controlDir:'/unused', workspace:'/unused', binDir:'/unused', timeoutMs:1 }), /capped at high/)
-    }
-  }
-  await assert.rejects(runCodexSession({workspace:'/unused',controlDir:'/unused',prompt:'',goal:false,effort:'max'}), /capped at high/)
-  await assert.rejects(runDesktopTurn({workspace:'/unused',controlDir:'/unused',binDir:'/unused',runId:'unused',prompt:'',effort:'ultra'}), /capped at high/)
-})
-
-test('Codex Luna accepts xhigh and max while every other model and CLI remains capped', async () => {
-  for (const effort of ['xhigh', 'max']) {
-    const luna = { id:'luna', name:'Luna', cli:'codex', model:'gpt-5.6-luna', effort }
-    await validateSelection(luna, [{ cli:'codex', model:'gpt-5.6-luna', name:'Luna', efforts:['high','xhigh','max'] }], async () => true)
-    assert.deepEqual(executionDefaults('codex', { model:'gpt-5.6-luna', effort }), { model:'gpt-5.6-luna', effort })
-    assert.throws(() => executionDefaults('grok', { model:'gpt-5.6-luna', effort }), /capped at high/)
-    assert.throws(() => executionDefaults('codex', { model:'gpt-5.6-terra', effort }), /capped at high/)
-  }
+test('engine defaults stay omitted and explicit native settings survive every adapter', async () => {
+ for(const cli of ['codex','codex-gui','grok','claude','opencode','agy']) {
+  assert.deepEqual(executionDefaults(cli,{}),{})
+  const preset={id:'chosen',name:'Chosen',cli,model:'native-model',effort:'ultra'}
+  assert.deepEqual(executionDefaults(cli,preset),preset)
+  await validateSelection(preset,[{cli,model:'native-model',name:'Native',efforts:['ultra']}],async()=>true)
+  await assert.rejects(validateSelection({...preset,effort:'unsupported'},[{cli,model:'native-model',name:'Native',efforts:['ultra']}],async()=>true),/installed client catalog/)
+  assert.throws(()=>executionDefaults(cli,{effort:'bad option'}),/Invalid reasoning effort/)
+ }
+ assert.deepEqual(executionOverrides('codex',{model:'old',effort:'max'},'new'),{model:'new',effort:undefined})
+ const saved={id:'saved',name:'Saved',cli:'codex',model:'chosen',effort:'max'}
+ assert.deepEqual(persistedPreset(saved),saved)
+ const args=taskArguments('/unused',['broker'],'--literal')
+ assert.equal(args.at(-1),'-');assert(!args.includes('--model'));assert(!args.some(s=>s.includes('model_reasoning_effort')))
+ const explicit=taskArguments('/unused',['broker'],'text',undefined,saved)
+ assert(explicit.includes('chosen'));assert(explicit.includes('model_reasoning_effort="max"'))
 })
 
-test('restricted tasks pin Luna max, preserve explicit choices and reject higher effort', () => {
-  const args = taskArguments('/unused', ['broker'], 'prompt')
-  assert.equal(args[args.indexOf('--model')+1], 'gpt-5.6-luna')
-  assert.ok(args.includes('model_reasoning_effort="max"'))
-  const custom = taskArguments('/unused', ['broker'], 'prompt', undefined, {model:'custom-model',effort:'low'})
-  assert.equal(custom[custom.indexOf('--model')+1], 'custom-model')
-  assert.ok(custom.includes('model_reasoning_effort="low"'))
-  assert.throws(() => taskArguments('/unused', ['broker'], 'prompt', undefined, {effort:'xhigh'}), /capped at high/)
-  assert.deepEqual(executionDefaults('codex', {model:'custom-model',effort:'medium'}), {model:'custom-model',effort:'medium'})
-  assert.deepEqual(executionDefaults('codex', {model:'gpt-6-astra'}), {model:'gpt-6-astra',effort:'high'})
-  assert.deepEqual(executionDefaults('codex', {model:'gpt-5.6-terra'}), {model:'gpt-5.6-terra',effort:'high'})
-  assert.deepEqual(executionDefaults('codex', {model:'gpt-5.6-luna'}), {model:'gpt-5.6-luna',effort:'max'})
-  assert.deepEqual(executionDefaults('codex', {}), {model:'gpt-5.6-luna',effort:'max'})
-  assert.deepEqual(executionOverrides('codex', {model:'gpt-5.6-luna',effort:'max'}, 'gpt-6-astra'), {model:'gpt-6-astra',effort:'high'})
-  assert.deepEqual(executionOverrides('codex', {model:'gpt-5.6-luna',effort:'max'}, 'gpt-5.6-luna'), {model:'gpt-5.6-luna',effort:'max'})
-  const stored = persistedPreset({id:'luna',name:'Luna',cli:'codex',model:'gpt-5.6-luna',effort:'max'})
-  assert.equal(stored.effort, undefined)
-  assert.deepEqual(executionDefaults('codex', stored), {id:'luna',name:'Luna',cli:'codex',model:'gpt-5.6-luna',effort:'max'})
-})
-
-test('preset persistence rejects above-high choices without changing current settings', async () => {
-  const dir = await mkdtemp(join(tmpdir(), 'ez-effort-'))
-  try {
-    const control = new ControlStore(dir, 1000)
-    const before = await control.aiState(initialPreset('codex'))
-    await assert.rejects(control.savePreset({id:'bad',name:'Bad',cli:'codex',model:'any',effort:'max'}), /capped at high/)
-    assert.deepEqual(await control.aiState(initialPreset('codex')), before)
-  } finally { await rm(dir,{recursive:true,force:true}) }
+test('invalid setting syntax never mutates a saved choice', async () => {
+ const dir=await mkdtemp(join(tmpdir(),'ez-native-setting-'))
+ try {
+  const control=new ControlStore(dir,1000),before=await control.aiState(initialPreset('codex'))
+  await assert.rejects(control.savePreset({id:'bad',name:'Bad',cli:'codex',effort:'bad option'}),/Invalid AI preset/)
+  assert.deepEqual(await control.aiState(initialPreset('codex')),before)
+ }finally{await rm(dir,{recursive:true,force:true})}
 })
 
 test('non-Codex catalog defaults survive executor normalization and host revalidation', async () => {

package/test/native-tasks.test.ts

@@ -0,0 +1,36 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import * as fs from 'node:fs/promises'
+import path from 'node:path'
+import os from 'node:os'
+import { nativeTaskBinding,nativeTasks } from '../src/plugins/native-tasks.mjs'
+import { ControlStore } from '../src/control-state.js'
+
+test('native tasks use verified control binding, sanitized environment and unchanged scheduler',async()=>{
+  const root=await fs.realpath(await fs.mkdtemp(path.join(os.tmpdir(),'ez-native-tasks-'))),home=path.join(root,'tools'),workspace=path.join(root,'mind'),controlDir=path.join(root,'control'),hostConfig=path.join(root,'host-executor.json')
+  try {
+    for(const dir of [home,workspace,controlDir])await fs.mkdir(dir)
+    await fs.writeFile(path.join(home,'config.json'),JSON.stringify({schemaVersion:1,workspace,hostConfig}))
+    const host={cli:'grok',agents:[{toolsHome:home,workspace,controlDir}]}
+    await fs.writeFile(hostConfig,JSON.stringify(host))
+    const binding=await nativeTaskBinding(home,{HOME:root,PATH:process.env.PATH,TELEGRAM_BOT_TOKEN:'secret',EZ_RUN_ID:'forged',NODE_OPTIONS:'injection',EZ_CONTROL_DIR:'/wrong'})
+    assert.equal(binding.cwd,workspace);assert.equal(binding.env.EZ_CONTROL_DIR,controlDir);assert.equal(binding.env.EZ_EXECUTOR_CLI,'grok')
+    for(const key of ['TELEGRAM_BOT_TOKEN','EZ_RUN_ID','NODE_OPTIONS'])assert.equal(binding.env[key],undefined)
+    assert.match((await nativeTasks(home,['--help'])).stdout,/durable, asynchronous CLI task/)
+    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 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)
+    await assert.rejects(nativeTasks(home,['--help'],{signal:AbortSignal.abort()}),/cancelled/)
+    await assert.rejects(nativeTasks(home,['bad\0argument']),/literal/)
+    for(const input of [['--text-file','/private/secret'],['--text-file=/private/secret']])
+      await assert.rejects(nativeTasks(home,['create','--now',...input]),/inline --text/)
+    await fs.writeFile(hostConfig,JSON.stringify({...host,agents:[{...host.agents[0],workspace:root}]}))
+    await assert.rejects(nativeTaskBinding(home),/does not match/)
+    await fs.writeFile(path.join(home,'config.json'),JSON.stringify({schemaVersion:1,workspace}))
+    await assert.rejects(nativeTasks(home,['--help']),/standalone/)
+  }finally{await fs.rm(root,{recursive:true,force:true})}
+})