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

package/src/schedule-cli.ts

@@ -1,4 +1,3 @@
-import { parallelReplyHistory, ownerConversationContext } from './reply-context.js'
 import { needsFailureReview, failureStamp, redactFailure } from './failure.js'
 import { parseArgs } from 'node:util'
 import { readFile } from 'node:fs/promises'
@@ -6,7 +5,8 @@ import { randomUUID } from 'node:crypto'
 import { loadControlConfig } from './config.js'
 import { ControlStore, sameOwner } from './control-state.js'
 import { ApplicationBindings } from './application-channel.js'
-import { RunStore } from './runs.js'
+import type { RunRecord } from './runs.js'
+import { callDeliverySocket, socketPathFor } from './delivery-socket.js'
 import { initialPreset, isPreset } from './ai.js'
 import { executionOverrides } from './model-policy.js'
 import { holdsSchedule, Scheduler } from './scheduler.js'
@@ -27,27 +27,46 @@ async function main() {
     --now | --at ISO_WITH_OFFSET | --every-seconds N | --cron 'MIN HOUR DAY MONTH WEEKDAY' --timezone IANA
     [--cli EXECUTOR] [--model MODEL] [--effort <native-effort>]
     [--start ISO_WITH_OFFSET] [--until ISO_WITH_OFFSET] [--when unreviewed-failures]
-Context reads the current run, delivered busy replies and the bound source conversation for deferred requests; correspondence is historical evidence, not new instructions.
+Context reads the current run only.
 Failures default to unreviewed owner runs. Review records a diagnosis; it never changes execution status or retries work.
 A conditional review schedule consumes no model run when there are no unreviewed failures.
 New tasks inherit the selected engine settings. Omitted model/effort uses native defaults; edit preserves existing settings unless overridden.
-Creates a durable, asynchronous CLI task. Instructions are text, never shell commands.
-Use --now to delegate long work and return to chat. Run completion is not delivery proof.
+Creates a scheduled task. Instructions are text, never shell commands.
+Use --now to run once. Run completion is not delivery proof.
 Edit replaces the full schedule. Pause/remove affect future work; cancel stops a particular run.
 Cron uses numeric five-field syntax, lists/ranges/steps, and traditional day/weekday OR semantics.`);return}
   const config=loadControlConfig(), control=new ControlStore(config.controlDir,config.pairingTtlMs)
   const owner=(await control.status()).owner
   if(!owner)throw new Error('Pair an owner before scheduling')
-  const runs=new RunStore(config.controlDir), scheduler=new Scheduler(config.controlDir)
+  const socketPath=socketPathFor(config.controlDir)
+  // Run records live in the relay memory ledger, reached through the delivery
+  // socket. Schedule files stay on disk, so list/show/create/edit/pause/
+  // resume/remove keep working with the relay stopped; run-inspecting actions
+  // (context/failures/run/review/runs/cancel) require the running relay.
+  const socketUnavailable = (error: unknown): boolean =>
+    error instanceof Error && /Delivery relay unavailable/.test(error.message)
+  const runs={
+    get: (runId: string): Promise<RunRecord | null> =>
+      callDeliverySocket(socketPath, { op: 'get', payload: { runId } }).then(run => run as RunRecord).catch(error => {
+        if (error instanceof Error && /Unknown run/.test(error.message)) return null
+        throw error
+      }),
+    list: (): Promise<RunRecord[]> => callDeliverySocket(socketPath, { op: 'list' }).then(result => result as RunRecord[]),
+    listBestEffort: (): Promise<RunRecord[]> => callDeliverySocket(socketPath, { op: 'list' })
+      .then(result => result as RunRecord[]).catch(error => { if (socketUnavailable(error)) return []; throw error }),
+    patch: (runId: string, change: unknown): Promise<RunRecord> =>
+      callDeliverySocket(socketPath, { op: 'patch', payload: { runId, change: change as Record<string, unknown> } }).then(run => run as RunRecord),
+  }
+  const scheduler=new Scheduler(config.controlDir)
   const caller=process.env.EZ_RUN_ID ? await runs.get(process.env.EZ_RUN_ID) : null
   if (caller?.application || caller?.delivery) await new ApplicationBindings(config.controlDir).authorize(caller)
   if(process.env.EZ_RUN_ID && (!caller || caller.status!=='running' || caller.external || caller.taskId || caller.replyOnly ||
     !ownsRun(owner, caller) ||
     (caller.scheduled && caller.scheduled.pairedAt!==owner.pairedAt)))throw new Error('Scheduling requires an active owner-authorized run')
   const owned=(s:{owner:typeof owner})=>sameOwner(s.owner,owner)
-  const ownsFailureRun=(r:Awaited<ReturnType<RunStore['get']>>)=>r && ownsRun(owner,r) && (!r.scheduled || r.scheduled.pairedAt===owner.pairedAt)
+  const ownsFailureRun=(r:RunRecord | null)=>r && ownsRun(owner,r) && (!r.scheduled || r.scheduled.pairedAt===owner.pairedAt)
   const show=async(s:Awaited<ReturnType<Scheduler['get']>>)=>{
-    const held=(await runs.list()).filter(r=>holdsSchedule(s,r))
+    const held=(await runs.listBestEffort()).filter(r=>holdsSchedule(s,r))
     const interruptedRunIds=held.filter(r=>r.interrupted).map(r=>r.id)
     const failedReviewRunIds=held.filter(r=>!r.interrupted).map(r=>r.id)
     const next=s.enabled && !held.length ? nextOccurrence(s.trigger,Date.now()) : null
@@ -59,7 +78,7 @@ Cron uses numeric five-field syntax, lists/ranges/steps, and traditional day/wee
     if(!caller)throw new Error('Context requires an active owner run')
     const origin=caller.scheduled?.originRunId ? await runs.get(caller.scheduled.originRunId) : null
     if(origin && !ownsFailureRun(origin))throw new Error('Source context is outside this owner binding')
-    result=caller.application || caller.delivery ? {run:caller,...(origin ? {origin} : {})} : {run:caller,busyReplies:await parallelReplyHistory(config.controlDir,caller),...(origin?{origin:await ownerConversationContext(config.controlDir,origin)}:{})}
+    result={run:caller,...(origin ? {origin} : {})}
   }else if(action==='failures'){
     const limit=Number(v.limit || 20)
     if(!Number.isSafeInteger(limit) || limit<1 || limit>100)throw new Error('Limit must be 1..100')
@@ -102,7 +121,7 @@ Cron uses numeric five-field syntax, lists/ranges/steps, and traditional day/wee
     if(action==='cancel'){
       const run=await runs.get(id)
       if(!run?.scheduled || run.scheduled.pairedAt!==owner.pairedAt || !ownsRun(owner,run))throw new Error('Unknown background run')
-      await scheduler.cancel(id);result={cancelRequested:id}
+      await scheduler.cancel(id, run);result={cancelRequested:id}
     }else{
       const s=await scheduler.get(id)
       if(!owned(s))throw new Error('Schedule ownership mismatch')

package/src/scheduled-tasks.ts

@@ -16,17 +16,60 @@ const displayedPreset = (schedule: Schedule) => {
   catch { return schedule.execution.preset }
 }
 
-export const scheduledTasksText = (schedules: ActiveSchedule[], owner: Owner) => {
-  const owned = schedules.filter((schedule) => ownsSchedule(owner, schedule))
+const weekdays = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
+const months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
+const time = (value: number | string) => {
+  const date = new Date(value)
+  if (!Number.isFinite(date.getTime())) return '—'
+  return `${weekdays[date.getUTCDay()]}, ${months[date.getUTCMonth()]} ${date.getUTCDate()} · ${String(date.getUTCHours()).padStart(2,'0')}:${String(date.getUTCMinutes()).padStart(2,'0')} UTC`
+}
+
+const preview = (schedule: Schedule) => {
+  const sentence = schedule.text.trim().replace(/\s+/gu,' ').split(/(?<=[.!?])\s/u)[0]
+  const chars = Array.from(sentence)
+  return chars.length > 140 ? chars.slice(0,139).join('')+'…' : sentence
+}
+
+const currentState = (schedule: ActiveSchedule) =>
+  schedule.runState === 'running' ? '▶ Running' : schedule.runState === 'queued' ? '◌ Queued' : '● Active'
+
+const lastRun = (schedule: ActiveSchedule) => {
+  if (!schedule.lastRun) return '— Not run yet'
+  const status = schedule.lastRun.status === 'completed' ? '✓ Completed' : schedule.lastRun.status === 'failed' ? '✕ Failed' : '⊘ Cancelled'
+  return `${status} · ${time(schedule.lastRun.at)}${schedule.lastRun.currentRevision ? '' : ' · previous version'}`
+}
+
+export const ownedScheduledTasks = (schedules: ActiveSchedule[], owner: Owner) =>
+  schedules.filter((schedule) => ownsSchedule(owner, schedule))
     .sort((a, b) => a.name.localeCompare(b.name))
-  if (!owned.length) return 'Active scheduled tasks\n\nNo active scheduled tasks for this owner.'
-  return ['Active scheduled tasks', ...owned.map((schedule) => {
+
+export const scheduledTasksText = (schedules: ActiveSchedule[], owner: Owner) => {
+  const owned = ownedScheduledTasks(schedules, owner)
+  if (!owned.length) return '📅 Scheduled tasks\n\nNo active scheduled tasks.'
+  return [`📅 Scheduled tasks · ${owned.length} active`, 'All times UTC. Use /tasks 1 for task details.', ...owned.map((schedule, index) => {
     const preset = displayedPreset(schedule)
-    const sentence = schedule.text.trim().replace(/\s+/gu,' ').split(/(?<=[.!?])\s/u)[0]
-    const chars = Array.from(sentence)
-    const preview = chars.length > 140 ? chars.slice(0,139).join('')+'…' : sentence
-    const next = schedule.nextAt === null ? '' : `Next: ${new Date(schedule.nextAt).toISOString().replace('T',' ').replace('.000Z',' UTC')}`
-    const timing = [schedule.runState === 'running' ? 'Running' : schedule.runState === 'queued' ? 'Queued' : '',next].filter(Boolean).join(' · ')
-    return `• ${schedule.name}\n  ${presetLabel(preset)}\n  ${timing}\n  ${preview}`
+    return `${index + 1} · ${schedule.name}\n  ${currentState(schedule)}\n  Next · ${schedule.nextAt === null ? '—' : time(schedule.nextAt)}\n  Last · ${lastRun(schedule)}\n  ${presetLabel(preset)}\n  ${preview(schedule)}`
   })].join('\n\n')
 }
+
+export const scheduledTaskDetailText = (schedule: ActiveSchedule, number: number, total?: number) => {
+  const preset = displayedPreset(schedule)
+  const instructions = schedule.text.trim()
+  const capped = instructions.length > 2000 ? instructions.slice(0, 2000) + '… (truncated; full text lives in the workspace)' : instructions
+  return [
+    `📅 ${number}${total === undefined ? '' : ` of ${total}`} · ${schedule.name}`,
+    currentState(schedule),
+    '',
+    'Next run',
+    schedule.nextAt === null ? '—' : time(schedule.nextAt),
+    '',
+    'Last run',
+    lastRun(schedule),
+    '',
+    'Engine',
+    presetLabel(preset),
+    '',
+    'Instructions',
+    capped,
+  ].join('\n')
+}

package/src/scheduler.ts

@@ -18,7 +18,12 @@ export type Schedule = {
   owner: Owner; execution: ExecutionChoice
   delivery?: { bindingId: string; scope: string }
 }
-export type ActiveSchedule = Schedule & { nextAt: number | null; runState?: 'queued' | 'running' }
+export type ScheduledRunSummary = {
+  status: 'completed' | 'failed' | 'cancelled'
+  at: string
+  currentRevision: boolean
+}
+export type ActiveSchedule = Schedule & { nextAt: number | null; runState?: 'queued' | 'running'; lastRun?: ScheduledRunSummary }
 export type ScheduledOrigin = { id: string; revision: string; dueAt: string; pairedAt: string; originRunId?: string }
 export const validScheduledOrigin = (v: unknown): v is ScheduledOrigin => {
   const s = v as ScheduledOrigin
@@ -85,11 +90,18 @@ export class Scheduler {
     for (const s of await this.listReadOnly()) {
       if (!s.enabled) continue
       const current = runs.filter(r => r.scheduled?.id === s.id && r.scheduled.revision === s.revision && ownsRun(s.owner,r))
+      const history = runs.filter(r => r.scheduled?.id === s.id && r.scheduled.pairedAt === s.owner.pairedAt && ownsRun(s.owner,r))
+        .filter((r): r is RunRecord & { status: ScheduledRunSummary['status'] } =>
+          r.status === 'completed' || r.status === 'failed' || r.status === 'cancelled')
+        .sort((a,b) => (b.endedAt ?? b.startedAt ?? b.createdAt).localeCompare(a.endedAt ?? a.startedAt ?? a.createdAt))
+      const last = history[0]
       const runState = current.some(r => r.status === 'running') ? 'running' : current.some(r => r.status === 'queued') ? 'queued' : undefined
       if (!runState && current.some(r => holdsSchedule(s,r))) continue
       try {
         const nextAt = await this.pendingOccurrence(s)
-        if (runState || nextAt !== null) active.push({...s,nextAt,runState})
+        if (runState || nextAt !== null) active.push({...s,nextAt,runState,...(last ? {
+          lastRun: {status:last.status,at:last.endedAt ?? last.startedAt ?? last.createdAt,currentRevision:last.scheduled!.revision===s.revision},
+        } : {})})
       }
       catch { console.error('Unreadable schedule cursor',s.id) }
     }
@@ -121,10 +133,10 @@ export class Scheduler {
         (!!s.delivery || ((s.owner.telegramLinkedAt ?? s.owner.pairedAt) === (owner.telegramLinkedAt ?? owner.pairedAt) && s.owner.telegramChatId === owner.telegramChatId))
     } catch { return false }
   }
-  async cancel(runId: string) {
+  async cancel(runId: string, run?: RunRecord | null) {
     assertId(runId); await this.ensure()
-    const run = await new RunStore(this.controlDir).get(runId)
-    if (!run?.scheduled) throw new Error('Unknown background run')
+    const record = run ?? await new RunStore(this.controlDir).get(runId)
+    if (!record?.scheduled) throw new Error('Unknown background run')
     await atomic(join(this.dir,runId+'.cancel'),{})
   }
   async cancelled(runId: string): Promise<boolean> {
@@ -160,11 +172,12 @@ export class Scheduler {
         if (s.when === 'unreviewed-failures' && !(await runs.list()).some(r => needsFailureReview(r) && ownsRun(owner, r) && (!r.scheduled || r.scheduled.pairedAt === owner.pairedAt))) {
           await atomic(cursor,{next:future}); continue
         }
+        const dueAt = new Date(next).toISOString()
         await runs.create({id:scheduledRunId(s,next),
           ownerId:ownerId(owner),ownerEpoch:ownerEpoch(owner),
           ...(s.delivery ? {delivery:s.delivery} : {chatId:s.owner.telegramChatId,telegramUserId:s.owner.telegramUserId,telegramEpoch:s.owner.telegramLinkedAt ?? s.owner.pairedAt}),
-          texts:[s.text],execution:s.execution,
-          scheduled:{id:s.id,revision:s.revision,dueAt:new Date(next).toISOString(),pairedAt:s.owner.pairedAt,...(s.originRunId?{originRunId:s.originRunId}:{})}})
+          texts:[`[schedule ${s.id} due ${dueAt}]`, s.text],execution:s.execution,
+          scheduled:{id:s.id,revision:s.revision,dueAt,pairedAt:s.owner.pairedAt,...(s.originRunId?{originRunId:s.originRunId}:{})}})
         // A restart between run creation and this cursor write sees the same occurrence ID.
         await atomic(cursor,{next:future})
       } catch { console.error('Schedule dispatch failed',s.id) }

package/src/service.ts

@@ -8,21 +8,21 @@ import { parseEnv } from 'node:util'
 const run = promisify(execFile)
 const packageRoot = fileURLToPath(new URL('../', import.meta.url))
 
-export const serviceDefinition = (directory: string) => {
+export const serviceDefinition = (directory: string, includePluginBroker = false) => {
   const root = path.resolve(directory)
   if (/[\r\n\0]/.test(root)) throw new Error('Service paths must be single-line values.')
   return { command: 'docker', args: ['compose', '--project-directory', packageRoot,
-    '--env-file', path.join(root, 'docker.env'), 'up', '-d', '--wait', 'relay'] }
+    '--env-file', path.join(root, 'docker.env'), 'up', '-d', '--wait', ...(includePluginBroker ? ['relay', 'plugin-broker'] : ['relay'])] }
 }
 
 // Docker owns lifecycle. No host-service fallback or provider onboarding here.
 export const installService = async (directory: string) => {
-  const definition = serviceDefinition(directory)
   const file = path.join(path.resolve(directory), 'docker.env')
   if (!(await lstat(file)).isFile()) throw new Error('docker.env must be a regular file')
   const values = parseEnv(await readFile(file, 'utf8'))
   if (!values.COMPOSE_PROJECT_NAME || !values.EZ_RELAY_ENV_FILE)
     throw new Error('docker.env must bind COMPOSE_PROJECT_NAME and EZ_RELAY_ENV_FILE; see docs/docker-runtime.md')
+  const definition = serviceDefinition(directory, values.EZ_EXECUTOR_TRANSPORT === 'local')
   await run(definition.command, definition.args)
   return { service: 'relay', runtime: 'docker', project: values.COMPOSE_PROJECT_NAME, active: true }
 }

package/src/setup.ts

@@ -113,7 +113,7 @@ export const runCli = async (): Promise<void> => {
   const envFilePath = path.resolve(process.cwd(), '.env')
 
   if (args[0] === '--help' || args[0] === '-h') {
-    console.log('Usage: ezenciel-agents-setup configure <executor> [--token-stdin] | service | init | status | <executor>\nconfigure writes private .env paths and seeds missing mind files; it does not start or pair the bot.\n--token-stdin accepts the BotFather token without putting it in command arguments or output.\nservice starts only the Docker Compose relay bound by docker.env in the current directory. It does not install the host-executor service; follow docs/host-service.md. It does not pair the owner.\nFollow docs/setup.md through a real Telegram reply; package installation alone is incomplete.')
+    console.log('Usage: ezenciel-agents-setup configure <executor> [--purpose-file PATH] [--token-stdin] | service | init [--purpose-file PATH] | status | <executor>\nFresh workspace setup requires a concise purpose file written from the owner request. configure writes private .env paths and seeds missing mind files; it does not start or pair the bot.\n--token-stdin accepts the BotFather token without putting it in command arguments or output.\nservice starts only the Docker Compose relay bound by docker.env in the current directory. It does not install the host-executor service; follow docs/host-service.md. It does not pair the owner.\nFollow docs/setup.md through a real Telegram reply; package installation alone is incomplete.')
     return
   }
 
@@ -124,10 +124,13 @@ export const runCli = async (): Promise<void> => {
   }
 
   if (args[0] === 'configure') {
-    if (!args[1] || args.length > 3 || (args[2] && args[2] !== '--token-stdin'))
-      throw new Error('Usage: ezenciel-agents-setup configure <executor> [--token-stdin]')
+    const tail = args.slice(2), purposeAt = tail.indexOf('--purpose-file'), tokenAt = tail.indexOf('--token-stdin')
+    const purposeFile = purposeAt >= 0 ? tail[purposeAt + 1] : undefined
+    const consumed = new Set([...(purposeAt >= 0 ? [purposeAt, purposeAt + 1] : []), ...(tokenAt >= 0 ? [tokenAt] : [])])
+    if (!args[1] || (purposeAt >= 0 && !purposeFile) || tail.some((_, index) => !consumed.has(index)))
+      throw new Error('Usage: ezenciel-agents-setup configure <executor> [--purpose-file PATH] [--token-stdin]')
     let token: string | undefined
-    if (args[2]) {
+    if (tokenAt >= 0) {
       if (process.stdin.isTTY) throw new Error('Supply the token through stdin, not a command argument.')
       let input = ''
       for await (const chunk of process.stdin) {
@@ -136,14 +139,15 @@ export const runCli = async (): Promise<void> => {
       }
       token = input.trim()
     }
-    console.log(JSON.stringify(await configureInstallation(process.cwd(), args[1], token)))
+    console.log(JSON.stringify(await configureInstallation(process.cwd(), args[1], token, purposeFile && path.resolve(purposeFile))))
     return
   }
 
   if (args[0] === 'init') {
-    if (args.length !== 1) throw new Error('Usage: ezenciel-agents-setup init (uses EZ_AGENT_WORKSPACE or ./agent)')
+    if (args.length !== 1 && !(args.length === 3 && args[1] === '--purpose-file'))
+      throw new Error('Usage: ezenciel-agents-setup init [--purpose-file PATH] (uses EZ_AGENT_WORKSPACE or ./agent)')
     const workspace = path.resolve(process.env.EZ_AGENT_WORKSPACE?.trim() || './agent')
-    const created = await initializeWorkspace(workspace)
+    const created = await initializeWorkspace(workspace, args[2] && path.resolve(args[2]))
     const config = loadControlConfig()
     await new ControlStore(config.controlDir, config.pairingTtlMs).syncClientPresets(
       chatPreset(await readActiveExecutor(envFilePath)), await discoverDefaults(workspace,

package/src/software-status.ts

@@ -1,6 +1,8 @@
 import { readFile } from 'node:fs/promises'
+import { arch as relayArch, platform as relayPlatform } from 'node:os'
 import path from 'node:path'
-import { packageVersion } from './version.js'
+import { isolationTransport } from './isolation.js'
+import { relayVersionLabel } from './version.js'
 
 export const installedPluginVersions = async (toolsHome?: string) => {
   if (!toolsHome) return null
@@ -10,14 +12,44 @@ export const installedPluginVersions = async (toolsHome?: string) => {
   } catch { return null }
 }
 
-export const softwareStatus = async (controlDir: string): Promise<string[]> => {
-  const lines = [`Relay: running · v${packageVersion}`]
+export const softwareStatus = async (controlDir: string, isolation?: string): Promise<string[]> => {
+  const lines = [`Relay: running · ${relayVersionLabel()}`]
+  let host: { version?: unknown; plugins?: unknown; platform?: unknown; arch?: unknown } | null = null
   try {
     const h = JSON.parse(await readFile(path.join(controlDir, 'host-executor/heartbeat.json'), 'utf8'))
     if (!Number.isFinite(h.at) || h.at > Date.now() + 5000 || Date.now() - h.at >= 15000) throw Error('Stale host')
+    host = h
+    lines.push(`Env: ${envLabel(host, isolation)}`)
     lines.push(`Host transport: running · ${typeof h.version === 'string' ? `v${h.version}` : 'version unknown'}`)
     if (!Array.isArray(h.plugins)) lines.push('Plugins: unknown')
     else lines.push(`Plugins: ${h.plugins.length ? h.plugins.map((p: {id: string; version: string}) => `${p.id} ${p.version}`).join(', ') : 'none installed'}`)
-  } catch { lines.push('Host transport: unavailable', 'Plugins: unknown') }
+  } catch {
+    lines.push(`Env: ${envLabel(host, isolation)}`)
+    if (isolation === 'isolated') {
+      lines.push('Host transport: n/a · isolated execution')
+      lines.push((await brokerPlugins(controlDir)) ?? 'Plugins: isolated broker · versions via `ez tools list`')
+    } else lines.push('Host transport: unavailable', 'Plugins: unknown')
+  }
   return lines
 }
+
+const envLabel = (host: { platform?: unknown; arch?: unknown } | null, isolation?: string): string => {
+  const rawPlatform = typeof host?.platform === 'string' && host.platform ? host.platform : relayPlatform()
+  const rawArch = typeof host?.arch === 'string' && host.arch ? host.arch : relayArch()
+  const where = rawPlatform === 'darwin' ? `mac (${rawPlatform}/${rawArch})` : `${rawPlatform}/${rawArch}`
+  const mode = isolation ?? 'unknown'
+  const transport = isolation === 'isolated' || isolation === 'host-capable' ? isolationTransport(isolation) : 'unknown'
+  return `${where} · ${mode} · ${transport}`
+}
+
+const brokerPlugins = async (controlDir: string): Promise<string | null> => {
+  try {
+    const status = JSON.parse(await readFile(path.join(controlDir, 'plugin-broker-plugins.json'), 'utf8')) as {
+      plugins?: { id: unknown; version: unknown }[]
+    }
+    if (!Array.isArray(status.plugins)) return null
+    const entries = status.plugins.filter(p => typeof p?.id === 'string' && typeof p?.version === 'string')
+    if (entries.length !== status.plugins.length) return null
+    return `Plugins: ${entries.length ? entries.map(p => `${p.id} ${p.version}`).join(', ') : 'none installed'}`
+  } catch { return null }
+}

package/src/task-executor.ts

@@ -5,7 +5,7 @@ import { join } from 'node:path'
 import { fileURLToPath } from 'node:url'
 import { spawn, execFile } from 'node:child_process'
 import { promisify } from 'node:util'
-import { RunStore } from './runs.js'
+import { readRun } from './delivery-socket.js'
 import { Tasks } from './tasks.js'
 import { executorEnvironment, terminateJob, type ExecutorOptions } from './executor.js'
 
@@ -38,7 +38,7 @@ export function taskArguments(directory: string, broker: string[], prompt: strin
     '-'] // Literal input travels on stdin, including slash commands and leading options.
 }
 export async function startTaskExecutor(options: ExecutorOptions) {
-  const run = await new RunStore(options.controlDir).get(options.runId)
+  const run = await readRun(options.controlDir, options.runId)
   if (!run || run.status !== 'running') throw new Error('No active task run')
   const task = await new Tasks(options.controlDir).authorize(run, false)
   const capabilityNames = (task.capabilities ?? []).map(item => `capability_${item.id}`)
@@ -53,7 +53,10 @@ export async function startTaskExecutor(options: ExecutorOptions) {
     await mkdir(directory, { mode: 0o700 }); await mkdir(home, { mode: 0o700 })
     const catalog = await promisify(execFile)('codex', ['debug', 'models', '--bundled'], { env: environment, maxBuffer: 4 * 1024 * 1024 })
     await writeFile(join(temporary, 'models.json'), JSON.stringify(taskModelCatalog(JSON.parse(catalog.stdout))), { mode: 0o600 })
-    await symlink(join(homedir(), '.codex', 'auth.json'), join(home, 'auth.json'))
+    const auth = process.env.EZ_ISOLATION === 'isolated'
+      ? join(options.controlDir, 'cli', 'codex', 'auth.json')
+      : join(homedir(), '.codex', 'auth.json')
+    await symlink(auth, join(home, 'auth.json'))
     const broker = [process.execPath, '--import', fileURLToPath(new URL('../node_modules/tsx/dist/loader.mjs', import.meta.url)),
       fileURLToPath(new URL('./task-mcp.ts', import.meta.url)), options.controlDir, options.runId, options.toolsHome ?? '', JSON.stringify(task.capabilities ?? [])]
     const prompt = JSON.stringify({event: run.external ? 'correspondence_received' : 'task_activated', taskId: run.taskId})

package/src/task-workspace.ts

@@ -2,9 +2,10 @@ import { mkdir, lstat } from 'node:fs/promises'
 import { join } from 'node:path'
 import { assertId } from './identity.js'
 
-// Fixed, agent-bound path, never a caller-provided cwd. No shared mutable task files.
-export async function taskWorkspace(workspace: string, id: string): Promise<string> {
-  const dirs=[join(workspace,'work'),join(workspace,'work','tasks'),join(workspace,'work','tasks',assertId(id))]
+// Fixed, agent-bound path under the control directory, never the workspace
+// mind folder and never a caller-provided cwd. No shared mutable task files.
+export async function taskWorkspace(baseDir: string, id: string): Promise<string> {
+  const dirs=[join(baseDir,'work'),join(baseDir,'work','tasks'),join(baseDir,'work','tasks',assertId(id))]
   for(const dir of dirs){
     await mkdir(dir,{recursive:true,mode:0o700})
     if(!(await lstat(dir)).isDirectory())throw new Error('Task workspace must not be a symlink')

package/src/tasks.ts

@@ -161,7 +161,7 @@ export class Tasks {
   async ownerCall(runId: string, command: string, args: Record<string, unknown>) {
     return this.serial(async () => {
       const run = await requireOwnerExecution(this.controlDir, runId)
-      if (run.scheduled || run.id.startsWith('r_update_') || run.id.startsWith('r_schedule_')) throw new Error('Task changes require a current owner message')
+      if (run.scheduled || run.id.startsWith('r_schedule_')) throw new Error('Task changes require a current owner message')
       if (command === 'list') return this.list()
       if (command === 'revoke') {
         const task = await this.get(String(args.taskId))

package/src/telegram-provisioning-cli.ts

@@ -0,0 +1,22 @@
+import { fileURLToPath } from 'node:url'
+import path from 'node:path'
+import { provisionTelegramBot } from './telegram-provisioning.js'
+
+const help = 'Usage: ezenciel-agents-provision-telegram --config PRIVATE_CONFIG_FILE < BOTFATHER_TOKEN\nConfigures one existing Ez deployment using its installed relay image and version from the deployment\'s docker.env; the config never selects an image. The token is accepted only through stdin, written only to that deployment\'s private relay secret, and is never printed.'
+
+export const runTelegramProvisioningCli = async (args = process.argv.slice(2), input = process.stdin): Promise<void> => {
+  if (args.includes('--help') || args.includes('-h')) { console.log(help); return }
+  if (args.length !== 2 || args[0] !== '--config' || !args[1]) throw new Error(help)
+  if ((input as NodeJS.ReadStream).isTTY) throw new Error('Supply the BotFather token through stdin, not a command argument.')
+  let token = ''
+  for await (const chunk of input) {
+    token += chunk.toString()
+    if (token.length > 512) { (input as NodeJS.ReadStream).destroy?.(); throw new Error('Token input is too long.') }
+  }
+  await provisionTelegramBot(args[1], token.trim())
+  console.log(JSON.stringify({ configured: true }))
+}
+
+if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
+  void runTelegramProvisioningCli().catch(error => { console.error((error as Error).message); process.exitCode = 1 })
+}