@jc_stack/ez-agents 0.1.0-beta.33 → 0.1.0-beta.36

package/test/files.test.ts

@@ -35,13 +35,13 @@ test('sanitizes dangerous file names', () => {
   assert.equal(sanitizeFileName('report 2026!@#.pdf'), 'report_2026___.pdf')
 })
 
-test('stages file into workspace inbox cleanly', async () => {
+test('stages file into control attachments, never the workspace', async () => {
   const tmp = await mkdtemp(path.join(tmpdir(), 'ez-files-'))
   try {
     const data = Buffer.from('%PDF-1.4 sample content')
     const staged = await stageIncomingFile(tmp, 'sample.pdf', data)
     assert.equal(staged.fileType, 'pdf')
-    assert.match(staged.relativePath, /^inbox[/\\][a-f0-9-]+_sample\.pdf$/)
+    assert.match(staged.relativePath, /^attachments[/\\][a-f0-9-]+_sample\.pdf$/)
     const read = await readFile(staged.fullPath)
     assert.deepEqual(read, data)
   } finally {

package/test/helpers/ledger.ts

@@ -0,0 +1,18 @@
+import { createLedgerHandler, serveDeliverySocket } from '../../src/delivery-socket.js'
+
+// Serves the relay memory ledger for child-process CLIs (message, react,
+// approval, schedule) in tests that do not start a full relay. Handlers run
+// in this process, so test-created runs are visible to CLI children through
+// the shared-volume socket. Fixtures that start a relay must NOT also serve:
+// the relay serves the same path.
+export const serveTestLedger = async (
+  controlDir: string,
+  status: () => { polling: boolean; applicationOnly: boolean; telegramConfigured: boolean; version: string } =
+    () => ({ polling: false, applicationOnly: false, telegramConfigured: true, version: 'test' }),
+) => {
+  const server = await serveDeliverySocket(
+    controlDir,
+    createLedgerHandler(controlDir, { wake: () => {}, status }),
+  )
+  return server
+}

package/test/host-executor.test.ts

@@ -41,6 +41,12 @@ test('legacy host lock fails closed while its PID is alive',async()=>{
   }finally{await rm(root,{recursive:true,force:true})}
 })
 
+test('isolated installations cannot start host transport', async () => {
+  const abort=new AbortController()
+  await assert.rejects(serveHostExecutor({cli:'grok',isolation:'isolated',agents:[]},abort.signal),/Isolated agents run the native CLI in the relay/)
+  abort.abort()
+})
+
 test('host restart clears dead native lease only after proving previous CLI stopped',async()=>{
   const root=await mkdtemp(path.join(tmpdir(),'ez-native-recovery-'));
   const workspace=path.join(root,'mind'),controlDir=path.join(root,'control'),toolsHome=path.join(root,'tools'),directory=path.join(controlDir,'host-executor');
@@ -63,6 +69,80 @@ test('host restart clears dead native lease only after proving previous CLI stop
   }finally{abort.abort();await server;await rm(root,{recursive:true,force:true});}
 });
 
+test('host execution resolves a declared provider from the bound agent, not a launcher wrapper', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'ez-host-provider-'))
+  const workspace = path.join(root, 'mind')
+  const controlDir = path.join(root, 'control')
+  const directory = path.join(controlDir, 'host-executor')
+  const provider = {
+    id: 'openrouter', name: 'OpenRouter', baseUrl: 'https://openrouter.ai/api/v1',
+    envKey: 'OPENROUTER_API_KEY', models: ['deepseek/deepseek-v4.1-flash'],
+  }
+  const installation = {
+    cli: 'codex' as const,
+    agents: [{name: 'test', workspace, controlDir, binDir: path.join(root, 'bin'), codexProviders: [provider]}],
+  }
+  const abort = new AbortController()
+  let server: Promise<void> | undefined
+  let captured: any
+  const previousPath = process.env.PATH
+  try {
+    await mkdir(workspace, {recursive: true})
+    await mkdir(directory, {recursive: true})
+    const fakeBin = path.join(root, 'bin')
+    await mkdir(fakeBin, {recursive: true})
+    await mkdir(path.join(controlDir, 'cli', 'codex'), {recursive: true})
+    await writeFile(path.join(fakeBin, 'codex'), '#!/bin/sh\nexit 0\n', {mode: 0o700})
+    await writeFile(path.join(controlDir, 'cli', 'codex', 'models_cache.json'), JSON.stringify({models: [
+      {slug: provider.models[0], visibility: 'list', display_name: 'DeepSeek V4.1 Flash', supported_reasoning_levels: [{effort: 'max'}]},
+    ]}))
+    process.env.PATH = `${fakeBin}${path.delimiter}${previousPath ?? ''}`
+    await ownerRun(controlDir, 'r_provider')
+    server = serveHostExecutor(installation, abort.signal, async (_texts, options) => {
+      captured = options
+      const child = spawn(process.execPath, ['-e', 'process.exit(0)'])
+      return {child, cleanup: async () => {}, stdout: ''}
+    })
+    for (let n = 0; n < 100; n++) {
+      try { await readFile(path.join(directory, 'heartbeat.json')); break }
+      catch { await new Promise(resolve => setTimeout(resolve, 20)) }
+    }
+    await writeFile(path.join(directory, 'r_provider.request.json'), JSON.stringify({
+      texts: ['hello'], options: {cli: 'codex', provider: 'openrouter', model: provider.models[0], effort: 'max'},
+    }))
+    let events = ''
+    for (let n = 0; n < 100; n++) {
+      try {
+        events = await readFile(path.join(directory, 'r_provider.events'), 'utf8')
+        if (events.includes('"stream":"exit"')) break
+      } catch {}
+      await new Promise(resolve => setTimeout(resolve, 20))
+    }
+    assert.match(events, /"stream":"exit","code":0/)
+    const catalog = JSON.parse(await readFile(path.join(directory, 'models.json'), 'utf8'))
+    assert.deepEqual(catalog.filter((model: any) => model.model === provider.models[0]), [
+      {
+        cli: 'codex-gui', model: provider.models[0],
+        name: 'codex-gui · DeepSeek V4.1 Flash', efforts: ['max'],
+      },
+      {
+        cli: 'codex', provider: 'openrouter', model: provider.models[0],
+        name: `OpenRouter · ${provider.models[0]}`, efforts: ['max'],
+      },
+    ])
+    assert.deepEqual(catalog.filter((model: any) => model.cli === 'codex' && !model.provider), [])
+    assert.equal(captured.provider, 'openrouter')
+    assert.deepEqual(captured.codexProvider, provider)
+    assert.equal(captured.model, provider.models[0])
+  } finally {
+    abort.abort()
+    await server
+    if (previousPath === undefined) delete process.env.PATH
+    else process.env.PATH = previousPath
+    await rm(root, {recursive: true, force: true})
+  }
+})
+
 test('one installed CLI executes two agent bindings with separate minds and sanitized environment', async () => {
   const root=await mkdtemp(path.join(tmpdir(),'ez-host-'))
   const abort=new AbortController()

package/test/inbox.test.ts

@@ -8,12 +8,11 @@ import { InboxStore } from '../src/inbox.js'
 import { RunStore } from '../src/runs.js'
 
 const update = (id: number): Update => ({ update_id: id })
-test('intake survives restart, deduplicates IDs, seals membership and retains cancellation tombstones', async () => {
+test('intake deduplicates IDs, seals membership and retains cancellation tombstones (memory only)', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-inbox-'))
   try {
-    let inbox = new InboxStore(dir)
+    const inbox = new InboxStore(dir)
     assert.equal(await inbox.accept(update(1)), true)
-    inbox = new InboxStore(dir)
     assert.equal(await inbox.accept(update(1)), false)
     await inbox.accept(update(2))
     assert.equal(await inbox.next(), undefined)
@@ -23,12 +22,11 @@ test('intake survives restart, deduplicates IDs, seals membership and retains ca
       [1, 2],
     )
     await inbox.accept(update(3))
-    inbox = new InboxStore(dir)
     assert.deepEqual(await inbox.next(true), batch)
     const runs = new RunStore(dir)
     const input = { id: batch.id, chatId: 101, telegramUserId: 101, texts: ['hello'] }
     await runs.create(input)
-    // Crash between run creation and inbox completion must not produce a second run.
+    // Retry with the same run ID returns the existing run; no second run.
     await runs.create(input)
     assert.equal((await runs.list()).length, 1)
     await inbox.finish(batch.id)
@@ -36,19 +34,19 @@ test('intake survives restart, deduplicates IDs, seals membership and retains ca
     assert.equal(await inbox.cancel(), 1)
     assert.equal(await inbox.accept(update(3)), false)
     assert.equal(await inbox.next(true), undefined)
-    assert.equal((await stat(join(dir, 'inbox.json'))).mode & 0o777, 0o600)
+    // Stateless pipe: no inbox.json exists on disk; restart drops by design.
+    await assert.rejects(stat(join(dir, 'inbox.json')))
   } finally {
     await rm(dir, { recursive: true, force: true })
   }
 })
 
-test('corrupt intake fails closed without overwriting evidence; invalid identifiers are rejected', async () => {
+test('restart loses nothing by design; invalid identifiers are rejected', async () => {
   const dir = await mkdtemp(join(tmpdir(), 'ez-inbox-corrupt-'))
   try {
-    await writeFile(join(dir, 'inbox.json'), '{broken')
+    // A fresh directory starts empty: no durable journal survives a restart.
     const inbox = new InboxStore(dir)
-    await assert.rejects(inbox.accept(update(4)), /Inbox unreadable/)
-    assert.equal(await readFile(join(dir, 'inbox.json'), 'utf8'), '{broken')
+    assert.deepEqual(await inbox.status(), { pending: 0, failed: 0 })
     assert.throws(() => inbox.accept(update(-1)), /Invalid update ID/)
     await assert.rejects(
       new RunStore(dir).create({ id: '../escape', chatId: 101, telegramUserId: 101, texts: [] }),

package/test/install-config.test.ts

@@ -14,8 +14,10 @@ test('configure preserves custom paths and unknown settings, keeps token private
   const root = await mkdtemp(path.join(tmpdir(), 'ez-configure-'))
   try {
     await writeFile(path.join(root, '.env'), 'EZ_AGENT_WORKSPACE="my mind"\nEZ_CONTROL_DIR="private control"\nEXTRA="keep me"\n')
+    const purpose = path.join(root, 'purpose.md')
+    await writeFile(purpose, 'Configured assistant\n')
     const token = '123456789:' + 'a'.repeat(30)
-    const result = await configureInstallation(root, 'codex', token)
+    const result = await configureInstallation(root, 'codex', token, purpose)
     assert.equal(result.tokenConfigured, true)
     assert.equal(JSON.stringify(result).includes(token), false)
     const env = parseEnv(await readFile(result.envFile, 'utf8'))
@@ -24,12 +26,12 @@ test('configure preserves custom paths and unknown settings, keeps token private
     assert.equal(env.EZ_AGENT_WORKSPACE, path.join(root, 'my mind'))
     assert.equal((await stat(result.envFile)).mode & 0o777, 0o600)
     assert.equal(await readActiveExecutor(result.envFile), 'codex')
-    const soul = path.join(result.workspace, 'SOUL.md')
-    await writeFile(soul, 'Customized purpose')
+    const agents = path.join(result.workspace, 'AGENTS.md')
+    await writeFile(agents, 'Customized purpose')
     const repeated = await configureInstallation(root, 'codex')
     assert.deepEqual(repeated.created, [])
     assert.equal(repeated.tokenConfigured, true)
-    assert.equal(await readFile(soul, 'utf8'), 'Customized purpose')
+    assert.match(await readFile(agents, 'utf8'), /Customized purpose/)
     await assert.rejects(stat(result.controlDir), { code: 'ENOENT' }) // No control/owner mutation.
   } finally { await rm(root, { recursive: true, force: true }) }
 })
@@ -56,20 +58,30 @@ test('packaged configure accepts token through stdin without echo or extra initi
   const root = await mkdtemp(path.join(tmpdir(), 'ez-configure-cli-'))
   try {
     const token = '123456789:' + 'b'.repeat(30)
+    const purpose = path.join(root, 'purpose.md')
+    await writeFile(purpose, 'Packaged assistant\n')
     const bin = fileURLToPath(new URL('../bin/ezenciel-agents-setup.mjs', import.meta.url))
-    const result = spawnSync(process.execPath, [bin, 'configure', 'codex', '--token-stdin'], { cwd: root, input: token, encoding: 'utf8', timeout: 10000 })
+    const result = spawnSync(process.execPath, [bin, 'configure', 'codex', '--purpose-file', purpose, '--token-stdin'], { cwd: root, input: token, encoding: 'utf8', timeout: 10000 })
     assert.equal(result.status, 0, result.stderr)
     assert.equal((result.stdout + result.stderr).includes(token), false)
-    assert.equal(JSON.parse(result.stdout).created.length, 3)
+    assert.deepEqual(JSON.parse(result.stdout).created, ['AGENTS.md'])
     assert.equal(parseEnv(await readFile(path.join(root, '.env'), 'utf8')).TELEGRAM_BOT_TOKEN, token)
   } finally { await rm(root, { recursive: true, force: true }) }
 })
 
+test('fresh configure refuses to invent a generic purpose', async () => {
+  const root = await mkdtemp(path.join(tmpdir(), 'ez-configure-purpose-'))
+  try {
+    await assert.rejects(configureInstallation(root, 'codex'), /purpose file is required/)
+  } finally { await rm(root, { recursive: true, force: true }) }
+})
+
 test('Docker startup uses explicit deployment binding and literal paths without secrets or host supervisors', () => {
   const definition = serviceDefinition('/tmp/my agent $literal')
   assert.equal(definition.command, 'docker')
   assert.ok(definition.args.includes('/tmp/my agent $literal/docker.env'))
   assert.deepEqual(definition.args.slice(-4), ['up', '-d', '--wait', 'relay'])
+  assert.deepEqual(serviceDefinition('/tmp/isolated', true).args.slice(-5), ['up', '-d', '--wait', 'relay', 'plugin-broker'])
   assert.doesNotMatch(JSON.stringify(definition), /TELEGRAM_BOT_TOKEN|launchctl|systemctl/)
   assert.throws(() => serviceDefinition('/tmp/\nbad'), /single-line/)
 })

package/test/install-tools.test.mjs

@@ -3,7 +3,10 @@ import assert from 'node:assert/strict';
 import * as fs from 'node:fs/promises';
 import {tmpdir} from 'node:os';
 import path from 'node:path';
-import {preflight,installationStatus,build,hostEnvironment} from '../src/install-tools.mjs';
+import {preflight,installationStatus,build,hostEnvironment,migrateLedger} from '../src/install-tools.mjs';
+import {parseEnv} from 'node:util';
+import {RunStore} from '../src/runs.js';
+import {serveTestLedger} from './helpers/ledger.js';
 
 async function fixture(t){const root=await fs.mkdtemp(path.join(tmpdir(),'ez-install-tools-'));t.after(()=>fs.rm(root,{recursive:true,force:true}));return root;}
 test('preflight checks the selected executable and reports missing prerequisites without credentials',async t=>{
@@ -19,22 +22,61 @@ test('preflight checks the selected executable and reports missing prerequisites
 test('installation status separates files, pairing and current-owner Telegram delivery evidence',async t=>{
   const root=await fixture(t),control=path.join(root,'control');
   assert.equal((await installationStatus(root)).stage,'not-configured');
-  for(const dir of ['host-executor','outbox','runs'])await fs.mkdir(path.join(control,dir),{recursive:true});
+  await fs.mkdir(path.join(control,'host-executor'),{recursive:true});
   for(const name of ['agent.json','host-executor.json','docker.env','relay.env'])await fs.writeFile(path.join(root,name),'private');
   const write=(name,obj)=>fs.writeFile(path.join(control,name),JSON.stringify(obj));
   await write('heartbeat.json',{at:Date.now(),polling:true});await write('host-executor/heartbeat.json',{at:Date.now()});
+  // Delivery evidence comes from the running relay's memory ledger.
+  const ledger=await serveTestLedger(control,()=>({polling:true,applicationOnly:false,telegramConfigured:true,version:'test'}));t.after(()=>ledger.stop());
+  assert.equal((await installationStatus(root)).stage,'awaiting-owner');
+  await fs.writeFile(path.join(root,'agent.json'),JSON.stringify({isolation:'isolated'}));
+  await fs.rm(path.join(control,'host-executor/heartbeat.json'));
+  assert.equal((await installationStatus(root)).stage,'awaiting-owner');
+  await fs.writeFile(path.join(root,'agent.json'),'private');
+  await write('host-executor/heartbeat.json',{at:Date.now()});
   assert.equal((await installationStatus(root)).stage,'awaiting-owner');
   const owner={telegramUserId:123,telegramChatId:123,pairedAt:new Date(Date.now()-10000).toISOString()};await write('control-state.json',{owner});
   assert.equal((await installationStatus(root)).stage,'awaiting-telegram-reply');
-  const item={runId:'tg_12',chatId:123,receipt:{messageIds:[42],deliveredAt:new Date().toISOString()}};
-  await write('outbox/test.sent.json',item);await write('runs/tg_12.json',{status:'completed',chatId:123,telegramUserId:999});
+  const runs=new RunStore(control),deliver=async(id,text,chatId,telegramUserId,ids,status='completed')=>{
+    const run=await runs.create({id,chatId,telegramUserId,texts:[text]});
+    await runs.patch(run.id,{status:'running'});
+    const item=await runs.enqueueMessage(run.id,text);
+    await runs.claimOutbox(item.id);await runs.markOutboxSent(item.id,ids);
+    await runs.patch(run.id,{status});
+  };
+  // Another chat member's completed delivery is not the owner's reply evidence.
+  await deliver('tg_13','other member',123,999,[42]);
   assert.equal((await installationStatus(root)).telegramReplyVerified,false);
-  await write('runs/tg_12.json',{status:'completed',chatId:123,telegramUserId:123});
+  // A failed run never counts, even with a receipt.
+  await deliver('tg_14','failed',123,123,[43],'failed');
+  assert.equal((await installationStatus(root)).telegramReplyVerified,false);
+  await deliver('tg_12','hello',123,123,[42]);
   assert.equal((await installationStatus(root)).stage,'ready-for-telegram-plugin-request');
-  await write('heartbeat.json',{at:0,polling:true});assert.equal((await installationStatus(root)).stage,'runtime-offline');
-  await write('outbox/test.sent.json',{...item,runId:'../../escape'});assert.equal((await installationStatus(root)).telegramReplyVerified,false);
+  // With the relay down, status falls back to the legacy heartbeat file.
+  await ledger.stop();await write('heartbeat.json',{at:0,polling:true});assert.equal((await installationStatus(root)).stage,'runtime-offline');
   await fs.writeFile(path.join(control,'control-state.json'),'{');await assert.rejects(installationStatus(root));
 });
+test('host-capable deployments migrate once to a loopback ledger endpoint',async t=>{
+  const root=await fixture(t),deployment=path.join(root,'agent');await fs.mkdir(deployment);
+  const envFile=path.join(deployment,'docker.env');
+  await fs.writeFile(envFile,"COMPOSE_PROJECT_NAME='ez-agent-canary'\nCOMPOSE_FILE='/opt/ez/compose.yaml:/opt/ez/extra.compose.yaml'\n",{mode:0o600});
+  const first=await migrateLedger({deployment});
+  assert.equal(first.changed,true);assert.ok(Number.isSafeInteger(first.port)&&first.port>=1024);
+  const values=parseEnv(await fs.readFile(envFile,'utf8'));
+  assert.equal(values.EZ_DELIVERY_TCP_PORT,String(first.port));
+  assert.equal(values.COMPOSE_FILE,`/opt/ez/compose.yaml:/opt/ez/extra.compose.yaml:${path.join(deployment,'ledger.compose.yaml')}`);
+  assert.match(await fs.readFile(path.join(deployment,'ledger.compose.yaml'),'utf8'),/127\.0\.0\.1:\$\{EZ_DELIVERY_TCP_PORT:\?\}/);
+  assert.equal((await fs.stat(envFile)).mode&0o777,0o600);
+  const second=await migrateLedger({deployment});
+  assert.equal(second.changed,false);assert.equal(second.port,first.port);
+  await assert.rejects(migrateLedger({deployment:path.join(root,'missing')}),/docker.env not found/);
+});
+test('isolated deployments need no host ledger endpoint',async t=>{
+  const root=await fixture(t),deployment=path.join(root,'isolated');await fs.mkdir(deployment);
+  await fs.writeFile(path.join(deployment,'docker.env'),"COMPOSE_PROJECT_NAME='ez-agent-isolated'\nCOMPOSE_FILE='/opt/ez/compose.yaml'\nEZ_ISOLATION='isolated'\nEZ_EXECUTOR_TRANSPORT='local'\n",{mode:0o600});
+  const result=await migrateLedger({deployment});
+  assert.equal(result.changed,false);assert.match(result.note,/Isolated/);
+});
 test('same-artifact build retries do not spawn a second Docker build and reuse verified completed image',async t=>{
   const home=await fixture(t),source=path.join(home,'source');await fs.mkdir(source);await fs.writeFile(path.join(source,'package.json'),'{}');
   let started,finish,count=0;const running=new Promise(r=>started=r),held=new Promise(r=>finish=r);
@@ -45,6 +87,37 @@ test('same-artifact build retries do not spawn a second Docker build and reuse v
   assert.equal((await build({home,source},invoke)).reused,true);assert.equal(count,1);
   await fs.writeFile(path.join(source,'package.json'),'{"changed":true}');await build({home,source},invoke);assert.equal(count,2);
 });
+test('source checkouts build RCs only: clean reviewed commit plus increasing label',async t=>{
+  const home=await fixture(t),source=path.join(home,'source');await fs.mkdir(source);await fs.writeFile(path.join(source,'package.json'),'{}');
+  let inside=true,status='',built=[],toplevel=source;const sha='a'.repeat(40);
+  const invoke=async(cmd,args)=>{
+    if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);
+    if(cmd==='git'){
+      if(!inside)throw Error('not a git repository');
+      if(args[2]==='rev-parse'&&args[3]==='--show-toplevel')return toplevel;
+      if(args[2]==='status')return status;
+      if(args[2]==='rev-parse'&&args[3]==='HEAD')return sha;
+      return '';
+    }
+    if(args[0]==='build'){built.push(args);return 'image';}
+    return 'sha256:fixture';
+  };
+  await assert.rejects(build({home,source},invoke),/requires --label/);
+  await assert.rejects(build({home,source,label:'0.1.0-beta.36'},invoke),/RC label/);
+  status=' M src/executor.ts';
+  await assert.rejects(build({home,source,label:'0.1.0-beta.36.rc.2'},invoke),/Commit the reviewed source/);
+  status='';
+  const result=await build({home,source,label:'0.1.0-beta.36.rc.2'},invoke);
+  assert.equal(result.label,'0.1.0-beta.36.rc.2');assert.equal(result.sha,sha);
+  const args=built.at(-1);
+  assert.ok(args.includes('BUILD_TAG=0.1.0-beta.36.rc.2'));assert.ok(args.includes(`BUILD_SHA=${sha}`));
+  assert.ok(args.includes('ezenciel-agents:0.1.0-beta.36.rc.2'));
+  inside=false;
+  await assert.rejects(build({home,source,label:'0.1.0-beta.36.rc.2'},invoke),/--label requires a git checkout/);
+  // A tarball unpacked inside an unrelated repository is not a source checkout.
+  inside=true;toplevel=home;
+  assert.equal((await build({home,source},invoke)).label,undefined);
+});
 test('a failed build releases its own lock and leaves a failure receipt for diagnosis',async t=>{
   const home=await fixture(t),source=path.join(home,'source');await fs.mkdir(source);await fs.writeFile(path.join(source,'package.json'),'{}');
   const invoke=async(cmd)=>{if(cmd==='npm')return JSON.stringify([{files:[{path:'package.json'}]}]);throw Error('Synthetic build failed');};

package/test/intake-relay.test.ts

@@ -1,5 +1,6 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
+import { randomBytes } from 'node:crypto'
 import { mkdtemp, readdir, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
@@ -8,6 +9,7 @@ import { once } from 'node:events'
 import type { Update } from 'grammy/types'
 import { createRelay } from '../src/index.js'
 import { ControlStore } from '../src/control-state.js'
+import { ApplicationBindings } from '../src/application-channel.js'
 import { RunStore } from '../src/runs.js'
 import { InboxStore } from '../src/inbox.js'
 import { ApprovalStore } from '../src/approval.js'
@@ -113,7 +115,9 @@ test('approved owner group accepts different members, controls and group deliver
     await control.revokeOwner()
     await f.relay.bot.handleUpdate(group(1))
     assert.equal(f.launched.length, 0)
-    assert.equal((await control.status()).pending[0].title, 'Team')
+    const request = (await control.status()).pending[0]
+    if (!request || !('title' in request)) throw new Error('Group pairing request missing')
+    assert.equal(request.title, 'Team')
     await control.approveOwner(-101, true)
     await f.relay.bot.handleUpdate(group(2, 303))
     await f.relay.bot.handleUpdate(group(3, 404))
@@ -263,7 +267,7 @@ test('conversation menu is owner-only and removes the retired settings control',
   try {
     await f.relay.bot.handleUpdate(message(1, '/menu'))
     assert.deepEqual(f.keyboards.at(-1)!.flat().map((b) => b.text),
-      ['New conversation', 'Conversations', 'Choose AI', 'Work status'])
+      ['New conversation', 'Conversations', 'Choose AI', 'Work status', 'Scheduled tasks'])
     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'))
@@ -284,9 +288,11 @@ test('conversation menu is owner-only and removes the retired settings control',
     assert.match(f.replies.at(-1)!, /Menu expired/)
     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 active scheduled tasks for this owner/)
+    assert.ok(!f.keyboards.at(-1)!.flat().some((button) => button.text === 'Scheduled tasks'))
+    await f.relay.bot.handleUpdate(message(9, '/tasks'))
+    assert.match(f.replies.at(-1)!, /📅 Scheduled tasks[\s\S]*No active scheduled tasks/)
+    await f.relay.bot.handleUpdate(message(10, '/tasks 2'))
+    assert.match(f.replies.at(-1)!, /Scheduled task 2 was not found/)
     assert.equal(f.launched.length, 0)
   } finally { await f.close() }
 })
@@ -386,7 +392,7 @@ test('slow voice normalization preserves instruction order and leaves controls r
     release()
     await processing
     assert.equal(f.launched[0][0], 'Use the following voice note')
-    assert.match(f.launched[0][1], /Quoted context/)
+    assert.doesNotMatch(f.launched[0][1], /Quoted context/)
     assert.match(f.launched[0][1], /Fixture voice transcript/)
     assert.equal(f.launched[0].length, 2)
     assert.equal((await new InboxStore(f.dir).status()).pending, 1)
@@ -632,7 +638,7 @@ test('conversation menu paginates and stale pages remain usable after archiving'
 })
 
 
-test('older conversation names come from owner messages and detail keeps archive available when resume fails', async () => {
+test('conversation names never read run history and detail keeps archive available when resume fails', async () => {
   const f = await fixture()
   try {
     const store = new ControlStore(f.dir, 1000)
@@ -649,7 +655,8 @@ test('older conversation names come from owner messages and detail keeps archive
     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.startsWith('Untitled conversation')))
+    assert.ok(!rows.flat().some(b => b.text.includes('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:')))
@@ -657,7 +664,7 @@ test('older conversation names come from owner messages and detail keeps archive
       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.match(f.replies.at(-1)!, /Untitled conversation \d+[\s\S]*binding/)
     assert.deepEqual(f.keyboards.at(-1)![0], [{text: 'Archive this conversation', callback_data: `chat:archive:${old.sessionId}`}])
   } finally { await f.close() }
 })
@@ -680,7 +687,7 @@ test('Telegram and application image/PDF/text use identical native attachment me
       const telegram=(await new RunStore(f.dir).list()).find(run=>run.messageId===update.message!.message_id)!
       assert.ok(telegram)
       const application=await f.relay.applicationChannel.submit(binding.bindingId,{requestId:name,scope:'chat',followOwner:true,text:update.message!.caption,attachment:{name,data:bytes.toString('base64')}})
-      const normalize=(text:string)=>text.replace(/inbox\/[a-f0-9-]+_/,'inbox/ID_')
+      const normalize=(text:string)=>text.replace(/attachments\/[a-f0-9-]+_/,'attachments/ID_')
       assert.equal(normalize(application.texts[0]),normalize(telegram.texts[0]))
       assert.equal(application.ownerId,telegram.ownerId)
       assert.equal(application.execution?.sessionId,telegram.execution?.sessionId)
@@ -699,9 +706,49 @@ test('web launcher is private-owner-only and bypasses native intake without repl
     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'])
+    assert.deepEqual(f.keyboards.at(-1)!.flat().map(b=>b.text),['New conversation','Conversations','Choose AI','Work status','Scheduled tasks','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()}
 })
+
+test('application Telegram link connects without launching work; bad link replies expired', async () => {
+  const f=await fixture()
+  try {
+    const control=new ControlStore(f.dir,1000)
+    await control.revokeOwner()
+    const owner=await control.registerOwner('account:web')
+    const binding=await new ApplicationBindings(f.dir).register('webapp',randomBytes(32).toString('base64url'),owner,true)
+    assert.ok(binding)
+    const pairing=await control.createApplicationTelegramPairing(binding.bindingId,owner)
+    assert.ok(pairing)
+    await f.relay.bot.handleUpdate(message(1,`/start ${'A'.repeat(43)}`))
+    assert.match(f.replies.at(-1)!,/expired|no longer valid/)
+    assert.equal(f.launched.length,0)
+    await f.relay.bot.handleUpdate(message(2,`/start ${pairing.token}`))
+    assert.match(f.replies.at(-1)! ,/connected/)
+    assert.equal(f.launched.length,0)
+    assert.equal((await control.status()).owner?.telegramUserId,101)
+  } finally {await f.close()}
+})
+
+test('tasks command never reaches the executor on invalid input or foreign senders', async () => {
+  const f = await fixture()
+  try {
+    const stranger = message(1, '/tasks');stranger.message!.from!.id = 202
+    await f.relay.bot.handleUpdate(stranger)
+    assert.equal(f.launched.length, 0)
+    assert.ok(!f.replies.join('\n').includes('Scheduled tasks'))
+    const strangerDetail = message(2, '/tasks 1');strangerDetail.message!.from!.id = 202
+    await f.relay.bot.handleUpdate(strangerDetail)
+    assert.equal(f.launched.length, 0)
+    assert.ok(!f.replies.join('\n').includes('Scheduled tasks'))
+    for (const [id, text] of [[3, '/tasks 0'], [4, '/tasks abc'], [5, '/tasks 1.5'], [6, '/tasks 2 extra']] as const) {
+      await f.relay.bot.handleUpdate(message(id, text))
+      assert.match(f.replies.at(-1)!, /Usage: \/tasks \[number\]/)
+    }
+    await f.relay.drainInbox(true)
+    assert.equal(f.launched.length, 0)
+  } finally { await f.close() }
+})