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

package/test/plugin-manager.test.mjs

@@ -7,6 +7,7 @@ import {execFile,spawn} from 'node:child_process';
 import {once} from 'node:events';
 import {promisify} from 'node:util';
 import {snapshot,init as initManager,validate,compose,locked,bindToolDiscovery,prepareCommand} from '../src/plugins/manager.mjs';
+import {TOOLS_LINE} from '../src/tools-line.mjs';
 import { ControlStore, ownerId, ownerEpoch } from '../src/control-state.js';
 import { ApplicationBindings } from '../src/application-channel.js';
 import { RunStore } from '../src/runs.js';
@@ -33,6 +34,16 @@ for(const cleanup of ['success','failure','already-removed']) test(`cancel remov
  if(cleanup==='failure')assert.match(stderr,/cleanup failed/);
  assert.deepEqual((await fs.readFile(log,'utf8')).trim().split('\n').map(JSON.parse),[['run'],['container','rm','--force','exact-test-container']]);
 });
+// Compose --rm only removes a container that ran. Compose dying between create
+// and start (signal, broken output pipe, error) must not strand it in Created.
+for(const exit of ['signal','failure','success']) test(`compose exit by ${exit} without manager cancellation ${exit==='success'?'leaves no cleanup call':'removes its created container'}`,async t=>{
+ const root=await fs.mkdtemp(path.join(tmpdir(),'ez-exit-'));t.after(()=>fs.rm(root,{recursive:true,force:true}));
+ const log=path.join(root,'calls.jsonl');
+ await fs.writeFile(path.join(root,'docker'),`#!${process.execPath}\nconst fs=require('fs'),a=process.argv.slice(2);fs.appendFileSync(${JSON.stringify(log)},JSON.stringify(a)+'\\n');if(a[0]==='container')process.exit(0);console.error('Container exact-test-container Created');${exit==='signal'?"process.kill(process.pid,'SIGKILL')":exit==='failure'?'process.exit(1)':'process.exit(0)'}\n`,{mode:0o700});
+ const {stdout}=await exec(process.execPath,['--input-type=module','-e',`import {run} from ${JSON.stringify(new URL('../src/plugins/manager.mjs',import.meta.url).href)};console.log((await run(['run'],{container:'exact-test-container',capture:true})).code)`],{env:{...process.env,PATH:root+path.delimiter+process.env.PATH}});
+ assert.equal(stdout.trim(),exit==='signal'?'130':exit==='failure'?'1':'0');
+ assert.deepEqual((await fs.readFile(log,'utf8')).trim().split('\n').map(JSON.parse),[['run'],...(exit==='success'?[]:[['container','rm','--force','exact-test-container']])]);
+});
 async function fixture(t) {
  const root=await fs.mkdtemp(path.join(tmpdir(),'ez-tools-'));t.after(()=>fs.rm(root,{recursive:true,force:true}));
  const source=path.join(root,'source'),home=path.join(root,'tools'),deploymentDir=path.join(root,'deployment'),workspace=path.join(deploymentDir,'mind'),control=path.join(deploymentDir,'control'),hostConfig=path.join(deploymentDir,'host-executor.json'),fake=path.join(root,'fake');
@@ -83,56 +94,43 @@ test('catalog paths resolve relative to the catalog and pin each new agent indep
  assert.notEqual(first.sample.revision,next.catalog.sample.revision);
  assert.deepEqual(JSON.parse((await f.call('plugins','available')).stdout),first);
 });
-test('native discovery binding preserves notes and adds bounded nonblocking routing guidance',async t=>{
- const f=await fixture(t),instructions=path.join(f.workspace,'AGENTS.md'),notes=path.join(f.workspace,'TOOLS.md');
- await fs.writeFile(instructions,'Owner mandate\n');
+test('init never writes native instructions; the retired footer becomes the static tools line once',async t=>{
+ const f=await fixture(t),instructions=path.join(f.workspace,'AGENTS.md'),override=path.join(f.workspace,'AGENTS.override.md');
  await init(f.home,f.workspace);
- await assert.rejects(fs.access(notes),{code:'ENOENT'});
- const first=await fs.readFile(instructions,'utf8');assert(first.startsWith('Owner mandate\n'));assert(first.includes(f.home+'/bin/ez'));
- assert.match(first,/tools list --details/);assert.match(first,/`--help`/);assert.match(first,/during a foreground owner turn, prefer `ezenciel-agents-schedule create --now \.\.\.`/);assert.match(first,/A `\[schedule \.\.\.\]` turn executes its assigned work directly and must not schedule it again/);assert.doesNotMatch(first,/ezenciel-agents-message|KISS/);
- const managed=first.slice(first.indexOf('<!-- ez tools: begin -->'),first.indexOf('<!-- ez tools: end -->')+'<!-- ez tools: end -->'.length);
- assert.ok(Buffer.byteLength(managed)<=600);
- await bindToolDiscovery(f.home,f.workspace);assert.equal(await fs.readFile(instructions,'utf8'),first);
- await fs.writeFile(notes,'Legacy policy');
- await bindToolDiscovery(f.home,f.workspace);assert.equal(await fs.readFile(notes,'utf8'),'Legacy policy');
- await fs.writeFile(path.join(f.workspace,'AGENTS.override.md'),'Override mandate');
- await bindToolDiscovery(f.home,f.workspace);assert.match(await fs.readFile(path.join(f.workspace,'AGENTS.override.md'),'utf8'),/Override mandate/);
+ await assert.rejects(fs.access(instructions),{code:'ENOENT'});
+ const footer='<!-- ez tools: begin -->\nUse `/x/bin/ez`.\n<!-- ez tools: end -->';
+ await fs.writeFile(instructions,`Owner mandate\n\n${footer}\n\nOwner tail\n`);await fs.writeFile(override,`Override mandate\n${footer}\n`);
+ await bindToolDiscovery(f.home,f.workspace);
+ const retired=await fs.readFile(instructions,'utf8');
+ assert.equal(retired,`Owner mandate\n\n${TOOLS_LINE}\n\nOwner tail\n`);
+ assert.equal(await fs.readFile(override,'utf8'),`Override mandate\n${TOOLS_LINE}\n`);
+ await bindToolDiscovery(f.home,f.workspace);assert.equal(await fs.readFile(instructions,'utf8'),retired); // once: idempotent
+ await fs.writeFile(instructions,`${TOOLS_LINE}\n${footer}\n`);await bindToolDiscovery(f.home,f.workspace);
+ assert.equal(await fs.readFile(instructions,'utf8'),`${TOOLS_LINE}\n\n`); // never duplicates the line
  await fs.writeFile(instructions,'<!-- ez tools: begin -->broken');
  await assert.rejects(bindToolDiscovery(f.home,f.workspace),/Malformed/);
  assert.equal(await fs.readFile(instructions,'utf8'),'<!-- ez tools: begin -->broken');
+ const notes=path.join(f.workspace,'TOOLS.md');await fs.writeFile(notes,footer);
  await fs.rm(instructions);await fs.symlink(notes,instructions);
  await assert.rejects(bindToolDiscovery(f.home,f.workspace),/regular file/);
- assert.equal(await fs.readFile(notes,'utf8'),'Legacy policy');
-});
-test('isolated discovery uses the relay-bound ez client without exposing toolsHome',async t=>{
- const f=await fixture(t);await fs.mkdir(f.home);const workspace=await fs.realpath(f.workspace),controlDir=await fs.realpath(f.control),toolsHome=await fs.realpath(f.home),host={cli:'codex',isolation:'isolated',agents:[{name:'sample',workspace,controlDir,binDir:path.join(f.root,'bin'),toolsHome}]};
- await fs.mkdir(path.join(f.root,'bin'));await fs.writeFile(f.hostConfig,JSON.stringify(host));
- await init(f.home,f.workspace,undefined,f.hostConfig);
- const instructions=await fs.readFile(path.join(f.workspace,'AGENTS.md'),'utf8');assert.match(instructions,/Use `ez`/);assert.match(instructions,/`tools list --details`/);assert.doesNotMatch(instructions,new RegExp(f.home.replace(/[.*+?^${}()|[\]\\]/g,'\\$&')));
-});
-test('discovery rejects an over-budget launcher before rewriting instructions',async t=>{
- const f=await fixture(t),instructions=path.join(f.workspace,'AGENTS.md'),longHome=path.join(f.root,'h'.repeat(200),'n'.repeat(200));
- await fs.mkdir(longHome,{recursive:true});await fs.writeFile(instructions,'Owner mandate\n');
- await assert.rejects(bindToolDiscovery(longHome,f.workspace),/600-byte core budget/);
- assert.equal(await fs.readFile(instructions,'utf8'),'Owner mandate\n');
-});
-test('standalone init rejects over-budget guidance before creating activation state',async t=>{
- const f=await fixture(t),instructions=path.join(f.workspace,'AGENTS.md'),longHome=path.join(f.root,'i'.repeat(200),'j'.repeat(200)),catalog=path.join(f.root,'empty-catalog.json');
- await fs.writeFile(catalog,'{}');await fs.writeFile(instructions,'Owner mandate\n');
- await assert.rejects(initManager(longHome,f.workspace,catalog,undefined,true),/600-byte core budget/);
- assert.deepEqual(await fs.readdir(longHome),[]);
- assert.equal(await fs.readFile(instructions,'utf8'),'Owner mandate\n');
+ assert.equal(await fs.readFile(notes,'utf8'),footer);
+});
+test('manifest example is one line starting with a declared command',async t=>{
+ const f=await fixture(t),p=await snapshot(f.source);
+ assert.doesNotThrow(()=>validate({...f.manifest,example:'sample search "q" --limit 3'},f.deployment,p.files));
+ for(const example of ['other --help','sample\nsecond','x'.repeat(161),3]) assert.throws(()=>validate({...f.manifest,example},f.deployment,p.files),/Manifest example/);
 });
 test('installed snippets follow install, upgrade and uninstall without files or Docker reads',async t=>{
  const f=await fixture(t);await init(f.home,f.workspace);
  const details=async()=>JSON.parse((await f.call('tools','list','--details')).stdout);
  assert.deepEqual(await details(),{});
  for(const description of ['Synthetic capability','Updated capability']) {
-  await fs.writeFile(path.join(f.source,'ez-plugin.json'),JSON.stringify({...f.manifest,description}));
+  const example=description==='Updated capability'?'sample run --json':undefined;
+  await fs.writeFile(path.join(f.source,'ez-plugin.json'),JSON.stringify({...f.manifest,description,example}));
   const p=await snapshot(f.source);
   await f.call('plugins','install','sample','--source',f.source,'--revision',p.revision);
   const before=await fs.readFile(f.log,'utf8'),index=await details();
-  assert.equal(index.sample.description,description);assert.deepEqual(index.sample.commands,['ez sample --help']);
+  assert.deepEqual(index.sample.aliases,['sample']);assert.equal(index.sample.purpose,description);assert.equal(index.sample.example,`ez ${example??'sample --help'}`);
   assert.equal(await fs.readFile(index.sample.skills[0],'utf8'),'Synthetic');
   assert.deepEqual(index.sample.skillReads,[['ez','tools','skill','sample','SKILL.md']]);
   assert.deepEqual(JSON.parse((await f.call('tools','skill','sample','SKILL.md')).stdout),{plugin:'sample',revision:p.revision,path:'SKILL.md',content:'Synthetic'});
@@ -278,6 +276,24 @@ test('an unreadable invocation lease pid falls through to container verification
   await assert.rejects(locked(f.home,async()=>{}),/Stale command invocation lease/);
  } finally {process.kill=kill0;process.env.PATH=path0;}
 });
+test('a lease from another PID namespace is live while its call container runs, then drains',async t=>{
+ const f=await fixture(t);
+ const directory=path.join(f.home,'command-invocations');await fs.mkdir(directory,{recursive:true});
+ const lease=path.join(directory,'00000000-0000-4000-8000-000000000001.json');
+ // Isolated broker lease: its pid means nothing in this namespace (EPERM/ESRCH or an unrelated process).
+ await fs.writeFile(lease,JSON.stringify({pid:1,container:'broker-call',pidNamespace:'pid:[4026531999]'}),{mode:0o600});
+ const path0=process.env.PATH;process.env.PATH=f.fake+path.delimiter+path0;t.after(()=>{process.env.PATH=path0;});
+ const docker=async state=>{const file=path.join(f.fake,'docker');await fs.writeFile(file+'.next',`#!${process.execPath}\nconst a=process.argv.slice(2);if(a[0]==='container'&&a[1]==='inspect'){${state}}\n`,{mode:0o700});await fs.rename(file+'.next',file);};
+ await docker(`console.log('true')`);
+ await assert.rejects(locked(f.home,async()=>{}),/commands are active/); // never misreported as stale
+ let activated=false;const drain=locked(f.home,async()=>{activated=true;},{drainInvocations:true});
+ await new Promise(resolve=>setTimeout(resolve,100));assert.equal(activated,false);
+ await docker(`console.error('Error: No such object: broker-call');process.exit(1)`);
+ await drain;assert.equal(activated,true);await assert.rejects(fs.access(lease),{code:'ENOENT'});
+ await fs.writeFile(lease,JSON.stringify({pid:1,container:'broker-call',pidNamespace:'pid:[4026531999]'}),{mode:0o600});
+ await docker(`console.log('false')`);
+ await assert.rejects(locked(f.home,async()=>{}),/Stale command invocation lease/); // stopped but not removed: inspect first
+});
 test('changed source, symlinks, reserved aliases, arbitrary Docker fields rejected',async t=>{
  const f=await fixture(t),p=await snapshot(f.source);await init(f.home,f.workspace);
  await fs.writeFile(path.join(f.source,'client.mjs'),'changed');await assert.rejects(f.call('plugins','install','sample','--source',f.source,'--revision',p.revision));
@@ -532,9 +548,7 @@ test('standalone CLI has discoverable setup, independent guidance and status wit
  const help=JSON.parse((await exec(process.execPath,[bin,'--help'])).stdout);
  assert.match(help.usage,/--standalone/);
  await exec(process.execPath,[bin,'init','--standalone','--home',f.home,'--workspace',f.workspace],{env:f.env});
- const notes=await fs.readFile(path.join(f.workspace,'AGENTS.md'),'utf8');
- assert.match(notes,/tools list --details/);
- assert.doesNotMatch(notes,/Finish the main Telegram|ezenciel-agents-message/);
+ await assert.rejects(fs.access(path.join(f.workspace,'AGENTS.md')),{code:'ENOENT'}); // instructions stay owner-written
  const launcher=path.join(f.home,'bin','ez');
  const status=JSON.parse((await exec(launcher,['status'],{cwd:f.root,env:f.env})).stdout);
  assert.equal(status.main,null);assert.deepEqual(status.plugins,[]);

package/test/run-handoff.test.ts

@@ -0,0 +1,136 @@
+import test from 'node:test'
+import assert from 'node:assert/strict'
+import { appendFile, mkdir, mkdtemp, readdir, readFile, rename, rm, stat, symlink, writeFile } from 'node:fs/promises'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
+import type { Update } from 'grammy/types'
+import { createRelay } from '../src/index.js'
+import { ControlStore } from '../src/control-state.js'
+import { RunStore } from '../src/runs.js'
+import { Scheduler, holdsSchedule } from '../src/scheduler.js'
+import { initialPreset } from '../src/ai.js'
+
+const until = async (check: () => Promise<boolean>) => {
+  for (let i = 0; i < 400; i++) { if (await check()) return; await new Promise(r => setTimeout(r, 25)) }
+  throw new Error('Timed out')
+}
+const config = (controlDir: string, workspace: string) =>
+  ({ workspace, controlDir, pairingTtlMs: 1000, executorTimeoutMs: 0, executorCli: 'grok', telegramBotToken: 'fixture' })
+
+// The test is the host transport: it claims requests, streams events and
+// keeps the heartbeat fresh. A second path to the same control directory gives
+// the next relay an empty memory ledger, as a replacement process would have.
+const fixture = async (t: test.TestContext) => {
+  const root = await mkdtemp(join(tmpdir(), 'ez-run-handoff-')), dir = join(root, 'control'), next = join(root, 'next-control')
+  const host = join(dir, 'host-executor')
+  await mkdir(host, { recursive: true, mode: 0o700 }); await symlink(dir, next)
+  const transport = process.env.EZ_EXECUTOR_TRANSPORT
+  process.env.EZ_EXECUTOR_TRANSPORT = 'host'
+  const beat = setInterval(() => void writeFile(join(host, 'beat.tmp'), JSON.stringify({ at: Date.now() }))
+    .then(() => rename(join(host, 'beat.tmp'), join(host, 'heartbeat.json'))).catch(() => {}), 200)
+  t.after(async () => {
+    clearInterval(beat)
+    if (transport === undefined) delete process.env.EZ_EXECUTOR_TRANSPORT; else process.env.EZ_EXECUTOR_TRANSPORT = transport
+    await rm(root, { recursive: true, force: true })
+  })
+  const files = async () => (await readdir(host)).filter(file => file !== 'heartbeat.json' && !file.endsWith('.tmp')).sort()
+  const control = new ControlStore(dir, 1000)
+  await control.requestPairing(101, 101); await control.approveOwner(101)
+  return { root, dir, next, host, files, control, owner: (await control.status()).owner! }
+}
+
+test('a graceful relay stop hands running host work to the next relay, which records it without relaunching', async t => {
+  const { root, dir, next, host, files, control, owner } = await fixture(t)
+  const scheduler = new Scheduler(dir), first = new RunStore(dir)
+  const execution = await control.captureChoice({ ...initialPreset('grok'), model: 'fixture-model' })
+  const due = Date.now() + 1000
+  const saved = await scheduler.save({ id: 'long', name: 'Long', text: 'Long work', owner, execution, enabled: true,
+    trigger: { everySeconds: 60, start: new Date(due).toISOString() } }, true)
+  await scheduler.tick(owner, first, due)
+  const foreground = await first.create({ chatId: 101, telegramUserId: 101, texts: ['chat'], execution })
+  const before = createRelay(config(dir, root))
+  await before.drainSources()
+  const scheduled = (await first.list()).find(run => run.scheduled)!
+  for (const id of [foreground.id, scheduled.id]) {
+    await until(async () => (await files()).includes(id + '.request.json'))
+    await rename(join(host, id + '.request.json'), join(host, id + '.running.json'))
+    await appendFile(join(host, id + '.events'), JSON.stringify({ stream: 'stdout', text: 'working\n' }) + '\n')
+  }
+  const delivered=await first.enqueueMessage(scheduled.id,'Delivered before replacement')
+  await first.claimOutbox(delivered.id)
+  await first.markOutboxSent(delivered.id,[17])
+  await before.stop()
+  assert.equal((await stat(join(dir, 'run-handoff.json'))).mode & 0o777, 0o600)
+  const handoff = JSON.parse(await readFile(join(dir, 'run-handoff.json'), 'utf8'))
+  assert.ok(Date.now() - Date.parse(handoff.writtenAt) < 60_000)
+  assert.deepEqual(handoff.runs.map((run: { id: string; status: string }) => [run.id, run.status]).sort(),
+    [[foreground.id, 'running'], [scheduled.id, 'running']].sort())
+  assert.deepEqual(await files(), [foreground.id + '.events', foreground.id + '.running.json', scheduled.id + '.events', scheduled.id + '.running.json'].sort(),
+    'the stop must not cancel, finish or resubmit host work')
+
+  const after = createRelay(config(next, root)), runs = new RunStore(next)
+  after.bot.botInfo = { id: 999, is_bot: true, first_name: 'Fixture', username: 'fixture_bot' } as typeof after.bot.botInfo
+  after.bot.api.config.use(async () => ({ ok: true, result: { message_id: 42 } }) as never)
+  try {
+    await after.adoptHandoff()
+    await assert.rejects(readFile(join(dir, 'run-handoff.json')), { code: 'ENOENT' })
+    assert.deepEqual((await runs.list()).map(run => run.status), ['running', 'running'])
+    assert.deepEqual(await runs.waitForDelivery(delivered.id,100),await first.waitForDelivery(delivered.id,100))
+    // The new ledger accepts the run's result delivery and holds its recurring schedule.
+    assert.ok(await runs.enqueueMessage(scheduled.id, 'Result after replacement'))
+    await scheduler.tick(owner, runs, due + 60_000); await after.drainSources()
+    assert.equal((await runs.list()).length, 2, 'the next recurrence waits for the adopted occurrence')
+    await new Promise(resolve => setTimeout(resolve, 300))
+    assert.ok(!(await files()).some(file => file.endsWith('.request.json') || file.endsWith('.cancel')), 'adoption never resubmits or cancels')
+    await appendFile(join(host, foreground.id + '.events'), JSON.stringify({ stream: 'exit', code: 0 }) + '\n')
+    await rm(join(host, foreground.id + '.running.json'))
+    await until(async () => (await runs.get(foreground.id))?.status === 'completed')
+    assert.equal((await new ControlStore(next, 1000).executionSession(execution)).hasStarted, true)
+    // /stop reaches the adopted run through the existing cancel path.
+    await after.bot.handleUpdate({ update_id: 1, message: { message_id: 1, date: 0, text: '/stop', from: { id: 101, is_bot: false, first_name: 'Owner' }, chat: { id: 101, type: 'private', first_name: 'Owner' } } } as Update)
+    await until(async () => (await runs.get(scheduled.id))?.status === 'cancelled')
+    assert.ok((await files()).includes(scheduled.id + '.cancel'), 'the host is asked to stop the adopted executor')
+    assert.equal(holdsSchedule(saved, (await runs.get(scheduled.id))!), false)
+  } finally { await after.stop() }
+})
+
+test('adoption fails closed for unknown, invalid, stale or corrupt handoff records and never launches', async t => {
+  const { root, dir, files, owner } = await fixture(t)
+  const scheduler = new Scheduler(dir)
+  const saved = await scheduler.save({ id: 'gone', name: 'Gone', text: 'work', owner, enabled: true, trigger: { everySeconds: 60, start: new Date(Date.now() + 1000).toISOString() },
+    execution: { sessionId: '00000000-0000-4000-8000-000000000000', preset: { ...initialPreset('grok'), model: 'fixture-model' } } }, true)
+  const lost = { version: 1, id: 'r_schedule_lost', chatId: 101, telegramUserId: 101, texts: ['work'], status: 'running', createdAt: new Date().toISOString(),
+    scheduled: { id: saved.id, revision: saved.revision, dueAt: new Date().toISOString(), pairedAt: owner.pairedAt } }
+  const write = (runs: unknown[], writtenAt = new Date().toISOString()) => writeFile(join(dir, 'run-handoff.json'), JSON.stringify({ version: 1, writtenAt, runs }))
+  await write([lost, { ...lost, id: '../escape' }, { ...lost, id: 'r_done', status: 'completed' }])
+  let launches = 0
+  const relay = createRelay(config(dir, root), async () => { launches++; throw new Error('Must not launch') }), runs = new RunStore(dir)
+  try {
+    await relay.adoptHandoff()
+    await until(async () => (await runs.get(lost.id))?.status === 'failed')
+    const failed = (await runs.get(lost.id))!
+    assert.match(failed.failure?.error ?? '', /outcome is unknown/)
+    assert.equal(failed.failureReason, 'handoff-outcome-unknown')
+    assert.equal(failed.interrupted, true)
+    assert.equal(holdsSchedule(saved, failed), true, 'an unknown outcome holds its schedule until an explicit edit')
+    assert.deepEqual((await runs.list()).map(run => run.id), [lost.id])
+    for (const stale of [() => write([{ ...lost, id: 'r_schedule_stale' }], new Date(Date.now() - 25 * 3600_000).toISOString()), () => writeFile(join(dir, 'run-handoff.json'), '{not json')]) {
+      await stale()
+      await relay.adoptHandoff()
+      await assert.rejects(readFile(join(dir, 'run-handoff.json')), { code: 'ENOENT' })
+    }
+    await relay.drainSources()
+    assert.equal(launches, 0)
+    assert.deepEqual((await runs.list()).map(run => run.id), [lost.id])
+    assert.deepEqual(await files(), [])
+  } finally { await relay.stop() }
+  // A relay without host transport removes a record it cannot adopt.
+  delete process.env.EZ_EXECUTOR_TRANSPORT
+  await write([{ ...lost, id: 'r_schedule_local' }])
+  const local = createRelay(config(dir, root))
+  try {
+    await local.adoptHandoff()
+    await assert.rejects(readFile(join(dir, 'run-handoff.json')), { code: 'ENOENT' })
+    assert.equal(await runs.get('r_schedule_local'), null)
+  } finally { await local.stop() }
+})

package/test/schedule-cli.test.ts

@@ -2,7 +2,7 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
-import { mkdtemp, rm, writeFile } from 'node:fs/promises'
+import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { fileURLToPath } from 'node:url'
@@ -11,6 +11,7 @@ import { RunStore } from '../src/runs.js'
 import { initialPreset } from '../src/ai.js'
 import { serveTestLedger } from './helpers/ledger.js'
 import { Scheduler } from '../src/scheduler.js'
+import { Scripts } from '../src/scripts.js'
 import { callDeliverySocket, socketPathFor } from '../src/delivery-socket.js'
 const exec=promisify(execFile),bin=fileURLToPath(new URL('../bin/ezenciel-agents-schedule.mjs',import.meta.url))
 test('public scheduler CLI saves literal text, reads back, edits, pauses, and rejects external or finished callers',async t=>{
@@ -66,6 +67,28 @@ test('public scheduler CLI saves literal text, reads back, edits, pauses, and re
  await assert.rejects(exec(process.execPath,[bin,'list'],{env}),/owner-authorized/)
 })
 
+test('edit keeps a paused agent or script schedule paused and an enabled one enabled',async t=>{
+ const dir=await mkdtemp(join(tmpdir(),'ez-schedule-edit-'));t.after(()=>rm(dir,{recursive:true,force:true}))
+ const ledger=await serveTestLedger(dir);t.after(()=>ledger.stop())
+ const control=new ControlStore(dir,1000),workspace=join(dir,'workspace')
+ await control.requestPairing(101,101);await control.approveOwner(101)
+ await mkdir(workspace);await writeFile(join(workspace,'guard.mjs'),'')
+ await new Scripts(dir).save({id:'guard',owner:(await control.status()).owner!,workspace,entry:'guard.mjs',interpreter:'node',args:[],timeoutSeconds:60},true)
+ const env={...process.env,EZ_CONTROL_DIR:dir,EZ_RUN_ID:''}
+ const cli=async(...args:string[])=>JSON.parse((await exec(process.execPath,[bin,...args],{env})).stdout)
+ const tasks={agent:(text:string)=>['--model','gpt-6-astra','--text',text],script:(name:string)=>['--script','guard','--name',name]}
+ for(const [id,task] of Object.entries(tasks)){
+  await cli('create',id,...task('Original'),'--every-seconds','3600')
+  await cli('pause',id)
+  // Changing only the instructions, even with --now, must not resume or dispatch it.
+  const paused=await cli('edit',id,...task('Changed'),'--now')
+  assert.equal(paused.enabled,false);assert.equal(paused.nextEligibleAt,null)
+  assert.equal((await cli('show',id)).enabled,false)
+  await cli('resume',id)
+  assert.equal((await cli('edit',id,...task('Again'),'--every-seconds','3600')).enabled,true)
+ }
+})
+
 test('executor PATH exposes the extensionless scheduler command',async()=>{
  const command=fileURLToPath(new URL('../bin/ezenciel-agents-schedule',import.meta.url))
   assert.match((await exec(command,['--help'])).stdout,/Creates a scheduled task/)

package/test/scheduled-tasks.test.ts

@@ -7,6 +7,7 @@ import { tmpdir } from 'node:os'
 import { Scheduler } from '../src/scheduler.js'
 import { scheduledTaskDetailText, scheduledTasksText } from '../src/scheduled-tasks.js'
 import { RunStore } from '../src/runs.js'
+import type { Trigger } from '../src/schedule-time.js'
 
 const owner = { telegramUserId: 101, telegramChatId: 101, pairedAt: '2026-09-11T00:00:00.000Z' }
 const execution = { sessionId: randomUUID(), preset: { id: 'fixture', name: 'Fixture', cli: 'codex', model: 'fixture-model' } }
@@ -37,10 +38,10 @@ test('scheduled task view is read-only, owner-bound, and shows active task promp
     scheduled: { id: saved.id, revision: saved.revision, dueAt: '2026-01-01T05:00:00.000Z', pairedAt: owner.pairedAt },
   })
   await runs.patch(run.id, { status: 'completed', endedAt: '2026-01-01T05:04:00.000Z' })
-  const active = await scheduler.listActiveReadOnly(await runs.list())
+  const active = await scheduler.listTasksReadOnly(await runs.list())
   const text = scheduledTasksText(active, owner)
 
-  assert.equal(text, '📅 Scheduled tasks · 1 active\n\nAll times UTC. Use /tasks 1 for task details.\n\n1 · Daily report\n  ● Active\n  Next · Thu, Jan 1 · 05:00 UTC\n  Last · ✓ Completed · Thu, Jan 1 · 05:04 UTC\n  codex · fixture-model · default effort\n  Read the ledger and send the owner a concise report.')
+  assert.equal(text, '📅 Scheduled tasks · 1 active · 0 paused\n\nNext/last times UTC. Use /tasks 1 for task details.\n\n1 · Daily report\n  ● Active\n  Schedule · Weekdays at 09:00 · Asia/Dubai\n  Next · Thu, Jan 1 · 05:00 UTC\n  Last · ✓ Completed · Thu, Jan 1 · 05:04 UTC\n  Execution · codex (default login) · fixture-model · default effort\n  Read the ledger and send the owner a concise report.')
   assert.match(scheduledTaskDetailText(active.find(schedule => schedule.id === saved.id)!, 1), /Last run\n✓ Completed · Thu, Jan 1 · 05:04 UTC/)
   assert.doesNotMatch(text, /Other owner task|This must never be visible/)
   assert.equal(await readFile(join(scheduleDir, 'owner-task.json'), 'utf8'), before)
@@ -61,29 +62,37 @@ test('active view follows existing cursor and run state without changing schedul
         id==='interrupted'?{everySeconds:60,start:new Date(due).toISOString()}:{at:new Date(due).toISOString()}})
   }
   await scheduler.save({...common,id:'recurring',name:'recurring',trigger:{everySeconds:60,start:new Date(due).toISOString()}})
-  const names = async () => (await scheduler.listActiveReadOnly(await runs.list())).map(s=>s.id).sort()
-  assert.deepEqual(await names(),['expired','interrupted','once','recurring','review'])
+  const names = async () => (await scheduler.listTasksReadOnly(await runs.list())).map(s=>s.id).sort()
+  assert.deepEqual(await names(),['expired','interrupted','once','paused','recurring','review'])
+  const paused = (await scheduler.listTasksReadOnly(await runs.list())).find(s=>s.id==='paused')!
+  assert.equal(paused.enabled,false)
+  assert.equal(paused.nextAt,null)
+  assert.match(scheduledTasksText([paused],owner),/0 active · 1 paused[\s\S]*⏸ Paused/)
+  assert.doesNotMatch(scheduledTasksText([paused],{...owner,pairedAt:'different'}),/⏸ Paused/)
+  assert.match(scheduledTaskDetailText({...paused,runState:'running'},1),/▶ Running · ⏸ Paused/)
+  assert.match(scheduledTaskDetailText({...paused,runState:'queued'},1),/◌ Queued · ⏸ Paused/)
   await scheduler.tick(owner,runs,due)
+  assert.ok(!(await runs.list()).some(r=>r.scheduled?.id==='paused'))
   // The empty conditional review consumes its occurrence without creating work.
-  assert.deepEqual(await names(),['expired','interrupted','once','recurring'])
+  assert.deepEqual(await names(),['expired','interrupted','once','paused','recurring'])
   const queued = (await runs.list()).find(r=>r.scheduled?.id==='once')!
-  const view = (await scheduler.listActiveReadOnly(await runs.list())).find(s=>s.id==='once')!
+  const view = (await scheduler.listTasksReadOnly(await runs.list())).find(s=>s.id==='once')!
   assert.equal(view.nextAt,null)
   assert.equal(view.runState,'queued')
   assert.match(scheduledTasksText([view],owner),/Queued/)
   await runs.patch(queued.id,{status:'running'})
-  assert.equal((await scheduler.listActiveReadOnly(await runs.list())).find(s=>s.id==='once')!.runState,'running')
+  assert.equal((await scheduler.listTasksReadOnly(await runs.list())).find(s=>s.id==='once')!.runState,'running')
   for (const run of await runs.list()) await runs.patch(run.id,run.scheduled?.id==='interrupted'
     ? {status:'failed',interrupted:true} : {status:'completed'})
   const before = await readdir(join(dir,'schedules'))
-  assert.deepEqual(await names(),['recurring'])
+  assert.deepEqual(await names(),['paused','recurring'])
   assert.deepEqual(await readdir(join(dir,'schedules')),before)
   // A held recurring revision remains hidden even when its cursor has a later occurrence.
   const interrupted = await scheduler.get('interrupted')
   assert.equal('everySeconds' in interrupted.trigger && interrupted.trigger.everySeconds,60)
   // A new schedule revision has its own occurrence; old terminal runs cannot hide it.
   await scheduler.save({...common,id:'once',name:'once',trigger:{at:new Date(due+60_000).toISOString()}})
-  assert.deepEqual(await names(),['once','recurring'])
+  assert.deepEqual(await names(),['once','paused','recurring'])
 })
 
 test('prompt preview is one bounded Unicode sentence and preserves stored input', async t => {
@@ -94,15 +103,15 @@ test('prompt preview is one bounded Unicode sentence and preserves stored input'
   const saved=await scheduler.save({id:'preview',name:'Preview',text,owner,
     execution:{...execution,preset:{...execution.preset,model:'gpt-5.6-terra',effort:'high'}},
     enabled:true,trigger:{at:'2027-01-01T00:00:00Z'}})
-  const output=scheduledTasksText(await scheduler.listActiveReadOnly([]),owner)
+  const output=scheduledTasksText(await scheduler.listTasksReadOnly([]),owner)
   assert.match(output,/gpt-5.6-terra · high/)
   assert.match(output,/Next · Fri, Jan 1 · 00:00 UTC/)
   assert.equal(Array.from(output.split('\n').at(-1)!.trim()).length,140)
   assert.ok(output.endsWith('…'))
   assert.doesNotMatch(output,/Do not display/)
   assert.equal((await scheduler.get(saved.id)).text,text)
-  const other=scheduledTasksText(await scheduler.listActiveReadOnly([]),{...owner,pairedAt:'other-pairing'})
-  assert.match(other,/No active scheduled tasks/)
+  const other=scheduledTasksText(await scheduler.listTasksReadOnly([]),{...owner,pairedAt:'other-pairing'})
+  assert.match(other,/No scheduled tasks/)
   assert.doesNotMatch(other,/Preview|🧪/)
 })
 
@@ -117,8 +126,8 @@ test('a legacy invalid selection does not prevent the active menu from rendering
   saved.execution.preset = {...saved.execution.preset,model:'gpt-5.6-terra',effort:'max'}
   await writeFile(file,JSON.stringify(saved))
 
-  const active = await scheduler.listActiveReadOnly([])
-  assert.match(scheduledTasksText(active,owner),/codex · gpt-5.6-terra · max/)
+  const active = await scheduler.listTasksReadOnly([])
+  assert.match(scheduledTasksText(active,owner),/codex \(default login\) · gpt-5.6-terra · max/)
 })
 
 test('detail view truncates long instructions and tolerates invalid timestamps', async t => {
@@ -127,7 +136,7 @@ test('detail view truncates long instructions and tolerates invalid timestamps',
   const scheduler = new Scheduler(dir)
   const saved = await scheduler.save({id:'long',name:'Long task',text:'/goal '+'x'.repeat(5000),owner,
     execution,enabled:true,trigger:{at:'2027-01-01T00:00:00Z'}})
-  const active = await scheduler.listActiveReadOnly([])
+  const active = await scheduler.listTasksReadOnly([])
   const detail = scheduledTaskDetailText(active.find(schedule => schedule.id === saved.id)!,1,1)
   assert.match(detail,/📅 1 of 1 · Long task/)
   assert.match(detail,/truncated; full text lives in the workspace/)
@@ -135,3 +144,24 @@ test('detail view truncates long instructions and tolerates invalid timestamps',
   const broken = {...active.find(schedule => schedule.id === saved.id)!,nextAt:'not-a-date',lastRun:{status:'completed',at:'also-bad',currentRevision:true}} as never
   assert.doesNotMatch(scheduledTaskDetailText(broken,1,1),/NaN/)
 })
+
+test('frequency describes saved rules without inventing a uniform interval for arbitrary cron', async t => {
+  const dir=await mkdtemp(join(tmpdir(),'ez-schedule-frequency-'));t.after(()=>rm(dir,{recursive:true,force:true}))
+  const scheduler=new Scheduler(dir),start='2027-01-01T00:00:00Z',timezone='America/New_York'
+  const cases:[Trigger,string][]=[
+    [{at:start},'Once'],[{everySeconds:60,start},'Every minute'],[{everySeconds:90,start},'Every 90 seconds'],
+    [{everySeconds:3600,start},'Every hour'],[{everySeconds:172800,start},'Every 2 days'],
+    [{cron:'*/15 * * * *',timezone,start},'Every 15 minutes · America/New_York'],
+    [{cron:'*/30 * * * *',timezone,start},'Every 30 minutes · America/New_York'],
+    [{cron:'15 * * * *',timezone,start},'Hourly at :15 · America/New_York'],
+    [{cron:'30 9 * * *',timezone,start},'Daily at 09:30 · America/New_York'],
+    [{cron:'*/7 * * * *',timezone,start},'Cron */7 * * * * · America/New_York'],
+    [{cron:'0 9 1 * 1',timezone,start},'Cron 0 9 1 * 1 · America/New_York'],
+  ]
+  for(const [i,[trigger,label]] of cases.entries()){
+    const saved=await scheduler.save({id:`t-${i}`,name:`Task ${i}`,text:'Inspect saved work.',owner,execution,enabled:true,trigger})
+    const active=(await scheduler.listTasksReadOnly([])).find(s=>s.id===saved.id)!
+    assert.ok(scheduledTasksText([active],owner).includes(`Schedule · ${label}\n`))
+    assert.ok(scheduledTaskDetailText(active,1).includes(`Schedule\n${label}\n`))
+  }
+})

package/test/session-close.test.ts

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