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

package/src/install-tools.mjs

@@ -4,6 +4,10 @@ import { homedir } from 'node:os';
 import { fileURLToPath } from 'node:url';
 import { createHash, randomUUID } from 'node:crypto';
 import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+import { parseEnv } from 'node:util';
+import { callDeliverySocket } from './delivery-socket-client.mjs';
+import { ledgerOverlayName, ledgerOverlayYaml } from './ledger-endpoint.mjs';
 
 const root=fileURLToPath(new URL('../',import.meta.url));
 const read=async file=>JSON.parse(await fs.readFile(file,'utf8'));
@@ -52,49 +56,120 @@ export async function installationStatus(deployment) {
   let isolated=false;
   try { isolated=(await read(path.join(deployment,'agent.json'))).isolation==='isolated'; } catch { isolated=false; }
   const runtimeReady=Boolean(relay?.polling&&fresh(relay,20000)&&(isolated||fresh(host,15000)));
+  // Delivery receipts live in relay memory and are re-authorized server-side;
+  // ask the running relay. A restart drops receipts by design.
   let reply=null;
-  if(paired)for(const name of await fs.readdir(path.join(control,'outbox')).catch(e=>{if(e.code==='ENOENT')return [];throw e;})) {
-    if(!name.endsWith('.sent.json'))continue;
-    const item=await read(path.join(control,'outbox',name));
-    if(!/^tg_\d+$/.test(item.runId||'')||item.chatId!==owner.telegramChatId||(item.type&&item.type!=='message')||!Array.isArray(item.receipt?.messageIds)||!item.receipt.messageIds.length||!item.receipt.messageIds.every(n=>Number.isSafeInteger(n)&&n>0))continue;
-    const delivered=Date.parse(item.receipt.deliveredAt);if(!Number.isFinite(delivered)||delivered<Date.parse(owner.pairedAt)||delivered>Date.now())continue;
-    const r=await read(path.join(control,'runs',item.runId+'.json')).catch(absent);
-    if(r?.status==='completed'&&!r.external&&r.chatId===owner.telegramChatId&&Number.isSafeInteger(r.telegramUserId)&&r.telegramUserId>0&&(owner.kind==='group'||r.telegramUserId===owner.telegramUserId)&&(!reply||delivered>Date.parse(reply.deliveredAt)))reply={runId:item.runId,messageIds:item.receipt.messageIds,deliveredAt:item.receipt.deliveredAt};
-  }
+  if(paired)reply=(await callDeliverySocket(path.join(control,'delivery.sock'),{op:'latestReply'},2000).catch(()=>null))?.reply??null;
   return {deployment,configured,runtimeReady,ownerPaired:paired,telegramReplyVerified:Boolean(reply),reply,
     stage:!configured?'not-configured':!runtimeReady?'runtime-offline':!paired?'awaiting-owner':!reply?'awaiting-telegram-reply':'ready-for-telegram-plugin-request',
-    note:'Read-only: a saved receipt is historical delivery evidence, not a fresh live probe or proof of reboot persistence. Request plugins through the working Telegram conversation.'};
+    note:'Read-only: a live receipt from the running relay is delivery evidence; it is not retained across a relay restart. Request plugins through the working Telegram conversation.'};
+}
+// Existing host-capable deployments created before the loopback endpoint need
+// one idempotent migration: a published loopback port in docker.env plus the
+// generated overlay that maps it. New agents receive both at create time.
+const envLine = (text, key, value) => {
+  if (/['\r\n\0]/.test(value)) throw Error('Unsafe deployment value');
+  const line = `${key}='${value}'`;
+  const pattern = new RegExp(`^${key}=.*$`, 'm');
+  return pattern.test(text) ? text.replace(pattern, () => line) : text.replace(/\n*$/, '\n') + line + '\n';
+}
+
+const freeLoopbackPort = async (start = 20000) => {
+  for (let port = start; port < start + 500 && port <= 65535; port++) {
+    const free = await new Promise(resolve => {
+      const probe = createServer();
+      probe.once('error', () => resolve(false));
+      probe.listen(port, '127.0.0.1', () => probe.close(() => resolve(true)));
+    });
+    if (free) return port;
+  }
+  throw Error('No free loopback port in the deployment range');
+};
+
+const ledgerPortStart = name => 20000 + createHash('sha256').update(name).digest().readUInt16BE(0) % 10000;
+
+export async function migrateLedger({ deployment } = {}) {
+  if (!path.isAbsolute(deployment || '')) throw Error('Supply --deployment with the absolute deployment directory');
+  const directory = path.resolve(deployment), envFile = path.join(directory, 'docker.env');
+  const text = await fs.readFile(envFile, 'utf8').catch(error => { if (error.code === 'ENOENT') throw Error('Deployment docker.env not found'); throw error; });
+  const values = parseEnv(text);
+  if (!/^[a-z0-9][a-z0-9_-]{0,62}$/.test(values.COMPOSE_PROJECT_NAME || '')) throw Error('Invalid deployment COMPOSE_PROJECT_NAME');
+  if (values.EZ_ISOLATION === 'isolated' || values.EZ_EXECUTOR_TRANSPORT === 'local')
+    return { ok: true, deployment: directory, changed: false, note: 'Isolated deployment; no host ledger endpoint is needed.' };
+  if (!values.COMPOSE_FILE) throw Error('Deployment COMPOSE_FILE not found');
+  const overlay = path.join(directory, ledgerOverlayName);
+  const files = values.COMPOSE_FILE.split(path.delimiter).filter(Boolean);
+  const configured = values.EZ_DELIVERY_TCP_PORT !== undefined && files.includes(overlay) &&
+    await fs.stat(overlay).then(info => info.isFile(), () => false);
+  if (configured) return { ok: true, deployment: directory, changed: false, port: Number(values.EZ_DELIVERY_TCP_PORT) };
+  const port = values.EZ_DELIVERY_TCP_PORT !== undefined ? Number(values.EZ_DELIVERY_TCP_PORT) : await freeLoopbackPort(ledgerPortStart(values.COMPOSE_PROJECT_NAME));
+  if (!Number.isSafeInteger(port) || port < 1024 || port > 65535) throw Error('Invalid EZ_DELIVERY_TCP_PORT');
+  const next = envLine(envLine(text, 'EZ_DELIVERY_TCP_PORT', String(port)), 'COMPOSE_FILE', [...new Set([...files, overlay])].join(path.delimiter));
+  // Publish the overlay before docker.env references it: a crash in between
+  // leaves an unreferenced file instead of a deployment Compose cannot start.
+  await fs.writeFile(overlay, ledgerOverlayYaml(), { mode: 0o600 });
+  const temporary = `${envFile}.${process.pid}.tmp`;
+  await fs.writeFile(temporary, next, { mode: 0o600 });
+  await fs.rename(temporary, envFile);
+  return { ok: true, deployment: directory, changed: true, port, overlay };
 }
+
 async function fingerprintOf(source,invoke) {
   const listing=JSON.parse(await invoke('npm',['pack','--dry-run','--ignore-scripts','--json'],{cwd:source}));
   const hash=createHash('sha256');
   for(const f of listing[0].files){const file=path.resolve(source,f.path);if(!file.startsWith(source+path.sep))throw Error('Invalid package path');const data=await fs.readFile(file);hash.update(JSON.stringify([f.path,f.mode,data.length]));hash.update(data);}
   return hash.digest('hex');
 }
-export async function build({home=defaultHome(),source=root},invoke=run) {
+// Source-checkout builds are RCs. The reviewed commit is the only SHA that may
+// label an installable image, so a dirty tree can never become one and /status
+// never falls back to the bare package version on a deployment.
+export const rcLabel = /^\d+\.\d+\.\d+-beta\.\d+\.rc\.[1-9]\d*$/;
+async function buildIdentity(source,label,invoke) {
+  const git=async args=>{try{return await invoke('git',['-C',source,...args]);}catch{return undefined;}};
+  // The package root itself must be the checkout root; a tarball unpacked
+  // inside an unrelated repository is not a source checkout.
+  const top=await git(['rev-parse','--show-toplevel']);
+  const atRoot=Boolean(top)&&await fs.realpath(top).then(value=>value===source,()=>false);
+  if(!atRoot) {
+    if(label!==undefined)throw Error('--label requires a git checkout so the RC pins the reviewed commit');
+    return {};
+  }
+  if(label===undefined)throw Error('A source checkout requires --label X.Y.Z-beta.N.rc.M; commit, push and open the PR first');
+  if(!rcLabel.test(label))throw Error('RC label must look like X.Y.Z-beta.N.rc.M');
+  if((await git(['status','--porcelain']))!=='')throw Error('Commit the reviewed source before an RC build; uncommitted work cannot be installed as an RC');
+  const sha=await git(['rev-parse','HEAD']);
+  if(!/^[a-f0-9]{40}$/.test(sha||''))throw Error('RC builds require the reviewed commit SHA');
+  return {label,sha};
+}
+export async function build({home=defaultHome(),source=root,label},invoke=run) {
   source=await fs.realpath(source);
-  const fingerprint=await fingerprintOf(source,invoke),image='ezenciel-agents:install-'+fingerprint.slice(0,24);
-  const dir=path.join(path.resolve(home),'builds',fingerprint);await fs.mkdir(dir,{recursive:true,mode:0o700});
+  const identity=await buildIdentity(source,label,invoke);
+  const fingerprint=await fingerprintOf(source,invoke);
+  const artifact=createHash('sha256').update(JSON.stringify([fingerprint,identity.label??'',identity.sha??''])).digest('hex');
+  const image='ezenciel-agents:install-'+artifact.slice(0,24);
+  const dir=path.join(path.resolve(home),'builds',artifact);await fs.mkdir(dir,{recursive:true,mode:0o700});
   const lock=path.join(dir,'lock'),receipt=path.join(dir,'status.json'),log=path.join(dir,'build.log');
   let handle;
   try{handle=await fs.open(lock,'wx',0o600);}catch(e){if(e.code!=='EEXIST')throw e;return {state:'busy-or-interrupted',image,log,note:'An existing build owns this artifact. Inspect its status/log and owning process; do not start another build or remove a live lock.'};}
   try {
-    await handle.writeFile(JSON.stringify({pid:process.pid,source,image}));
+    await handle.writeFile(JSON.stringify({pid:process.pid,source,image,...identity}));
     const prior=await read(receipt).catch(absent);
     if(prior?.state==='completed')try{if(await invoke('docker',['image','inspect','--format','{{.Id}}',image])===prior.imageId)return {...prior,reused:true};}catch{/* Image was removed; rebuild under the same exclusive lock. */}
-    await atomic(receipt,{state:'building',pid:process.pid,source,image,log});
-    console.error(JSON.stringify({state:'building',image,log}));
+    await atomic(receipt,{state:'building',pid:process.pid,source,image,log,...identity});
+    console.error(JSON.stringify({state:'building',image,log,...identity}));
+    const buildArgs=identity.label?['--build-arg',`BUILD_TAG=${identity.label}`,'--build-arg',`BUILD_SHA=${identity.sha}`]:[];
+    const tags=[image,...(identity.label?[`ezenciel-agents:${identity.label}`]:[])];
     const output=await fs.open(log,'a',0o600);
-    try{await invoke('docker',['build','--progress','plain','--target','runtime','-t',image,source],{log:output.fd,timeout:3600000});}finally{await output.close();}
+    try{await invoke('docker',['build','--progress','plain','--target','runtime',...buildArgs,...tags.flatMap(t=>['-t',t]),source],{log:output.fd,timeout:3600000});}finally{await output.close();}
     if(await fingerprintOf(source,invoke)!==fingerprint)throw Error('Package changed during build; keep the source stable and retry');
-    const result={state:'completed',source,image,imageId:await invoke('docker',['image','inspect','--format','{{.Id}}',image]),log};await atomic(receipt,result);return result;
-  }catch(e){await atomic(receipt,{state:'failed',source,image,log,error:e.message});throw e;}
+    const result={state:'completed',source,image,imageId:await invoke('docker',['image','inspect','--format','{{.Id}}',image]),log,...identity};await atomic(receipt,result);return result;
+  }catch(e){await atomic(receipt,{state:'failed',source,image,log,error:e.message,...identity});throw e;}
   finally{await handle.close();await fs.rm(lock);}
 }
 export async function main(args) {
   const [action,...rest]=args;const options={};
-  if(!action||action==='--help'){console.log(JSON.stringify({commands:['preflight --executor <name-or-absolute-path> [--home PATH]','build [--home PATH]','status --deployment PATH'],note:'Host prerequisites and main-agent diagnostics only. Initialize an empty registry; verify Telegram before asking the installed agent to add plugins.'}));return;}
-  for(let i=0;i<rest.length;i+=2){if(!['--home','--executor','--deployment'].includes(rest[i])||!rest[i+1]||Object.hasOwn(options,rest[i].slice(2)))throw Error('Invalid arguments');options[rest[i].slice(2)]=rest[i+1];}
-  const allowed={preflight:['home','executor'],build:['home'],status:['deployment']};if(!allowed[action]||Object.keys(options).some(k=>!allowed[action].includes(k)))throw Error('Invalid action/options');
-  const result=action==='preflight'?await preflight(options):action==='build'?await build(options):await installationStatus(options.deployment);console.log(JSON.stringify(result));if(result.ok===false)process.exitCode=1;
+  if(!action||action==='--help'){console.log(JSON.stringify({commands:['preflight --executor <name-or-absolute-path> [--home PATH]','build [--home PATH] [--label X.Y.Z-beta.N.rc.M]','migrate-ledger --deployment PATH','status --deployment PATH'],note:'Source checkouts build RCs only: commit and open the PR first, then pass the next --label. migrate-ledger adds the loopback host endpoint to an existing host-capable deployment. Host prerequisites and main-agent diagnostics only; initialize an empty registry and verify Telegram before asking the installed agent to add plugins.'}));return;}
+  for(let i=0;i<rest.length;i+=2){if(!['--home','--executor','--deployment','--label'].includes(rest[i])||!rest[i+1]||Object.hasOwn(options,rest[i].slice(2)))throw Error('Invalid arguments');options[rest[i].slice(2)]=rest[i+1];}
+  const allowed={preflight:['home','executor'],build:['home','label'],'migrate-ledger':['deployment'],status:['deployment']};if(!allowed[action]||Object.keys(options).some(k=>!allowed[action].includes(k)))throw Error('Invalid action/options');
+  const result=action==='preflight'?await preflight(options):action==='build'?await build(options):action==='migrate-ledger'?await migrateLedger(options):await installationStatus(options.deployment);console.log(JSON.stringify(result));if(result.ok===false)process.exitCode=1;
 }

package/src/ledger-endpoint.d.mts

@@ -0,0 +1,2 @@
+export declare const ledgerOverlayName: string
+export declare const ledgerOverlayYaml: () => string

package/src/ledger-endpoint.mjs

@@ -0,0 +1,17 @@
+// One source for the host-capable ledger overlay: agent creation, the
+// deployment migration and its tests must emit the same compose fragment.
+export const ledgerOverlayName = 'ledger.compose.yaml'
+
+export const ledgerOverlayYaml = () => [
+  '# Host-capable execution: on Docker Desktop/OrbStack the control-volume',
+  '# Unix socket is not connectable from the host, so the relay serves its',
+  '# memory ledger on this published loopback port and requests authenticate',
+  '# with the per-run token in the control directory.',
+  'services:',
+  '  relay:',
+  '    environment:',
+  '      EZ_DELIVERY_TCP_PORT: ${EZ_DELIVERY_TCP_PORT:?}',
+  '    ports:',
+  '      - "127.0.0.1:${EZ_DELIVERY_TCP_PORT:?}:${EZ_DELIVERY_TCP_PORT:?}"',
+  '',
+].join('\n')

package/src/menu.ts

@@ -13,12 +13,13 @@ export const mainCommands = [
   { command: 'rename', description: 'Rename current conversation' },
   { command: 'ai', description: 'Choose AI' },
   { command: 'status', description: 'Work status' },
+  { command: 'tasks', description: 'Scheduled tasks' },
 ]
 
 export const mainKeyboard = () => new InlineKeyboard()
   .text('New conversation', 'menu:new').text('Conversations', 'menu:chats').row()
-  .text('Choose AI', 'menu:ai')
-  .text('Work status', 'menu:status')
+  .text('Choose AI', 'menu:ai').row()
+  .text('Work status', 'menu:status').text('Scheduled tasks', 'menu:scheduled-tasks')
 
 const clientLabel = (cli: string) => cli === 'codex-gui' ? 'codex-gui (desktop)' : cli
 
@@ -33,6 +34,10 @@ export const createAiMenu = (control: ControlStore, cli: string, catalog = readM
   const initial = chatPreset(cli)
   const host = process.env.EZ_EXECUTOR_TRANSPORT === 'host'
   if (host) catalog = async () => JSON.parse(await readFile(path.join(process.env.EZ_CONTROL_DIR!, 'host-executor/models.json'),'utf8'))
+  // Local execution runs Codex with CODEX_HOME set to the agent-bound control
+  // directory, but the default catalog probed the process home instead. Bind it
+  // to the same agent-bound home so /ai lists the models Codex can actually run.
+  else if (codexHome && catalog === readModels) catalog = () => readModels(undefined, isInstalled, codexHome)
   const refresh = async () => control.syncClientPresets(initial, host ? [] : await discoverDefaults(workspace, { codexHome }))
   const validate = async (preset: AiPreset) => {
     assertEffort(preset.effort, preset.model, preset.cli)

package/src/message-history.ts

@@ -1,11 +1,12 @@
-import { readFile, readdir } from 'node:fs/promises'
-import { join, basename } from 'node:path'
+import { basename } from 'node:path'
 import { requireOwnerExecution } from './execution-authority.js'
 import { ControlStore } from './control-state.js'
 import { ownsRun } from './identity.js'
-import { RunStore } from './runs.js'
+import { RunStore, sentOutbox } from './runs.js'
 
-// Read existing delivery receipts; native sessions still own conversation history.
+// Read existing delivery receipts from the relay memory ledger; native
+// sessions still own conversation history. Explicit tool path only (message
+// history CLI / delivery socket history op), never ambient prompt enrichment.
 export async function deliveredMessages(controlDir: string, runId: string, options: { limit?: number; messageId?: number } = {}) {
   const limit = options.limit ?? 8
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > 50) throw new Error('Limit must be 1..50')
@@ -20,26 +21,20 @@ export async function deliveredMessages(controlDir: string, runId: string, optio
     ownsRun(owner, run) && !run.external && !run.taskId && !run.application &&
     Date.parse(run.createdAt) >= pairedAt && (!run.scheduled || run.scheduled.pairedAt === owner!.pairedAt)
   ).map(run => [run.id, run]))
-  const directory = join(controlDir, 'outbox')
-  const files = await readdir(directory).catch((error: NodeJS.ErrnoException) => {
-    if (error.code === 'ENOENT') return []
-    throw error
-  })
   const messages = []
-  for (const file of files.filter(file => file.endsWith('.sent.json'))) {
-    // Corrupt or incomplete receipts are not delivery evidence.
-    let item
-    try { item = JSON.parse(await readFile(join(directory, file), 'utf8')) } catch { continue }
+  for (const item of sentOutbox(controlDir)) {
+    // Incomplete receipts are not delivery evidence.
     if (!item || typeof item !== 'object') continue
-    const run = runs.get(item.runId)
-    const deliveredAt = Date.parse(item.receipt?.deliveredAt)
-    const ids = item.receipt?.messageIds
+    const run = item.runId === undefined ? undefined : runs.get(item.runId)
+    const receipt = (item.receipt ?? {}) as { deliveredAt?: unknown; messageIds?: unknown }
+    const deliveredAt = Date.parse(receipt.deliveredAt as string)
+    const ids = receipt.messageIds
     if (!run || item.chatId !== caller.chatId || !Number.isFinite(deliveredAt) || deliveredAt < pairedAt ||
       !Array.isArray(ids) || !ids.length || !ids.every(id => Number.isSafeInteger(id) && id > 0)) continue
-    if (options.messageId !== undefined && !ids.includes(options.messageId)) continue
+    if (options.messageId !== undefined && !(ids as number[]).includes(options.messageId)) continue
     messages.push({
       runId: run.id, sessionId: run.execution?.sessionId, nativeSessionId: run.nativeSessionId,
-      scheduleId: run.scheduled?.id, messageIds: ids as number[], deliveredAt: item.receipt.deliveredAt as string,
+      scheduleId: run.scheduled?.id, messageIds: ids as number[], deliveredAt: receipt.deliveredAt as string,
       type: item.type || 'message', text: typeof item.text === 'string' ? item.text
         : typeof item.approvalPrompt === 'string' ? item.approvalPrompt : undefined,
       voiceText: typeof item.voiceText === 'string' ? item.voiceText : undefined,

package/src/message.ts

@@ -1,12 +1,12 @@
 import { readFile,realpath } from 'node:fs/promises'
 import { loadControlConfig } from './config.js'
-import { parseMessageArgs, sendRunDocument, sendRunText, sendRunVoice } from './message-send.js'
-import { RunStore } from './runs.js'
+import { parseMessageArgs } from './message-send.js'
 import { parseArgs } from 'node:util'
-import { deliveredMessages } from './message-history.js'
 import {authorizeDeliveryContext,currentDeliveryOwner} from './delivery-context.mjs'
 import {workspaceFile} from './files.js'
+import { callDeliverySocket, socketPathFor } from './delivery-socket.js'
 import path from 'node:path'
+import { randomBytes } from 'node:crypto'
 
 const rawArgs = process.argv.slice(2)
 if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
@@ -19,11 +19,13 @@ if (rawArgs.includes('--help') || rawArgs.includes('-h')) {
   process.exit(0)
 }
 
+const controlDir = loadControlConfig().controlDir
+const socketPath = socketPathFor(controlDir)
 const runId = process.env.EZ_RUN_ID?.trim()
-const deliveryContext = !runId && process.env.EZ_DELIVERY_CONTEXT ? authorizeDeliveryContext(JSON.parse(process.env.EZ_DELIVERY_CONTEXT),await currentDeliveryOwner(loadControlConfig().controlDir)) : undefined
+const deliveryContext = !runId && process.env.EZ_DELIVERY_CONTEXT ? authorizeDeliveryContext(JSON.parse(process.env.EZ_DELIVERY_CONTEXT),await currentDeliveryOwner(controlDir)) : undefined
 if(rawArgs[0]==='receipt') {
   if(!deliveryContext||rawArgs.length!==2)throw new Error('Receipt requires an authenticated delivery context and outbox ID')
-  console.log(JSON.stringify(await new RunStore(loadControlConfig().controlDir).ownerDeliveryReceipt(deliveryContext,rawArgs[1]!)))
+  console.log(JSON.stringify(await callDeliverySocket(socketPath, { op: 'receipt', payload: { context: deliveryContext, id: rawArgs[1]! } })))
   process.exit(0)
 }
 if (rawArgs[0] === 'history') {
@@ -32,10 +34,11 @@ if (rawArgs[0] === 'history') {
       limit: { type: 'string' }, 'message-id': { type: 'string' },
     } })
     if (!runId) throw new Error('EZ_RUN_ID is required')
-    const result = await deliveredMessages(loadControlConfig().controlDir, runId, {
+    const result = await callDeliverySocket(socketPath, { op: 'history', payload: {
+      runId,
       limit: values.limit === undefined ? undefined : Number(values.limit),
       messageId: values['message-id'] === undefined ? undefined : Number(values['message-id']),
-    })
+    } })
     await new Promise<void>((resolve, reject) => process.stdout.write(JSON.stringify(result) + '\n', error => error ? reject(error) : resolve()))
   } catch (error) {
     console.error(error instanceof Error ? error.message : String(error))
@@ -49,8 +52,6 @@ if (!runId && !deliveryContext) {
   process.exit(1)
 }
 
-const store = new RunStore(loadControlConfig().controlDir)
-
 let textContent = args.text?.trim()
 if (args.textFile) {
   if(deliveryContext)throw new Error('Channel delivery requires inline text, not host file input')
@@ -62,21 +63,28 @@ if (args.textFile) {
   }
 }
 
-let item
+// Delivery rides the relay socket (same envelope the relay pump delivers);
+// the relay re-verifies ownership before sending. Client-generated IDs keep
+// retried sends idempotent without a second delivery.
+const envelope: Record<string, unknown> = {
+  ...(runId ? { runId } : {}),
+  ...(deliveryContext ? { kind: 'owner', deliveryContext } : {}),
+  ...(args.replyTo !== undefined ? { replyToMessageId: args.replyTo } : {}),
+}
 if(deliveryContext) {
   if(args.document) {
     if(!process.env.EZ_AGENT_WORKSPACE)throw new Error('Channel delivery requires owning workspace')
     const documentPath=await workspaceFile(process.env.EZ_AGENT_WORKSPACE,args.document)
-    item=await store.enqueueOwnerDelivery(deliveryContext,{type:'document',documentPath:path.relative(await realpath(process.env.EZ_AGENT_WORKSPACE),documentPath),text:textContent,replyToMessageId:args.replyTo})
-  } else if(args.voice) item=await store.enqueueOwnerDelivery(deliveryContext,{type:'voice',voiceText:args.voice,replyToMessageId:args.replyTo})
-  else if(textContent) item=await store.enqueueOwnerDelivery(deliveryContext,{type:'message',text:textContent,replyToMessageId:args.replyTo})
+    Object.assign(envelope,{type:'document',documentPath:path.relative(await realpath(process.env.EZ_AGENT_WORKSPACE),documentPath),text:textContent})
+  } else if(args.voice) Object.assign(envelope,{type:'voice',voiceText:args.voice})
+  else if(textContent) Object.assign(envelope,{type:'message',text:textContent})
   else throw new Error('Message content is required')
 } else if (args.document) {
-  item = await sendRunDocument(store, runId!, args.document, textContent, { replyTo: args.replyTo })
+  Object.assign(envelope,{kind:'document',documentPath:args.document,text:textContent})
 } else if (args.voice) {
-  item = await sendRunVoice(store, runId!, args.voice, { replyTo: args.replyTo })
+  Object.assign(envelope,{kind:'voice',voiceText:args.voice})
 } else if (textContent) {
-  item = await sendRunText(store, runId!, textContent, { replyTo: args.replyTo })
+  Object.assign(envelope,{kind:'message',text:textContent,id:`${runId}_${Date.now().toString(36)}_${randomBytes(2).toString('hex')}`})
 } else {
   console.error(
     'Usage: ezenciel-agents-message [--text-file <path> | --text <text>] [--document <path>] [--voice <text>] [--reply-to <id>]',
@@ -84,9 +92,18 @@ if(deliveryContext) {
   process.exit(1)
 }
 
+let item: { outbox_id: string; id: string; type?: string }
+try {
+  item = await callDeliverySocket(socketPath, { op: 'enqueue', payload: envelope }) as typeof item
+} catch (error) {
+  console.error(error instanceof Error ? error.message : String(error))
+  process.exit(1)
+}
+
 try {
   if(deliveryContext)console.log(JSON.stringify({ok:true,status:'queued',outbox_id:item.id}))
-  const receipt = await store.waitForDelivery(item.id,deliveryContext?20000:undefined)
+  const receipt = await callDeliverySocket(socketPath,
+    { op: 'wait', payload: { id: item.id } }, deliveryContext?30000:130000)
   console.log(
     JSON.stringify({
       ok: true,
@@ -95,7 +112,7 @@ try {
       ...(deliveryContext?{connection:deliveryContext.connectionId}:{}),
       outbox_id: item.id,
       type: item.type,
-      receipt,
+      receipt: (receipt as { receipt?: unknown }).receipt ?? receipt,
     }),
   )
 } catch (error) {