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

package/src/host-executor.ts

@@ -7,9 +7,11 @@ import { mkdir, readFile, writeFile, readdir, rename, rm, appendFile, realpath }
 import path from 'node:path'
 import { isHostRunId } from './host-executor-protocol.js'
 import { fileURLToPath } from 'node:url'
-import { startExecutorJob, terminateJob, resolveExecutor, validateCodexProvider, type CodexProviderBinding, type ExecutorOptions } from './executor.js'
+import { CliUnavailableError, startExecutorJob, terminateJob, resolveExecutor, validateCodexProvider, type CodexProviderBinding, type ExecutorOptions } from './executor.js'
+import { activeSetup } from './runs.js'
+import { startupLine, startupObserver } from './setup-fallback.js'
 import { parseIsolationClass, type IsolationClass } from './isolation.js'
-import { readModels, validateSelection, validateOpencodeProviders, type ModelChoice } from './ai.js'
+import { readModels, sameEngine, validateSelection, validateOpencodeProviders, type ModelChoice } from './ai.js'
 import type { ChildProcess } from 'node:child_process'
 import { packageVersion } from './version.js'
 import { installedPluginVersions } from './software-status.js'
@@ -48,11 +50,13 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
       new Set(installation.agents.map(a=>a.controlDir)).size !== installation.agents.length)
     throw new Error('Each agent requires a separate workspace and control directory')
   const active = new Map<string, ChildProcess>()
+  // A fallback attempt reuses its run ID; claim it only after the prior attempt's cleanup.
+  const claimed = new Set<string>()
   const tasks = new Set<Promise<void>>()
   let catalogRefresh: Promise<void> | undefined
   const locks: string[] = []
   const sharedWorkspaces = new Map<HostBinding, string>()
-  const activeWorkspaces = new Map<HostBinding, { lanes: Set<boolean>; release?: () => Promise<void> }>()
+  const activeWorkspaces = new Map<HostBinding, { lanes: Map<string, boolean>; release?: () => Promise<void> }>()
   const additionalWorkspaces = new Map<HostBinding, string[]>()
   const catalog = async (agent: HostBinding) => {
     const discovered = await readModels(undefined, undefined, path.join(agent.controlDir, 'cli', 'codex'),
@@ -148,6 +152,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
         for (const file of await readdir(directory)) {
           if (!file.endsWith('.request.json') || !isHostRunId(file.slice(0,-13))) continue
           const id=file.slice(0,-13)
+          if (claimed.has(path.join(directory,id))) continue
           let run
           try {
             run = await readRun(agent.controlDir, id)
@@ -161,29 +166,31 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
           const base=path.join(directory,id)
           const scheduled = Boolean(run?.scheduled)
           let workspace = activeWorkspaces.get(agent)
-          if (workspace?.lanes.has(scheduled)) continue
+          if (!scheduled && workspace && [...workspace.lanes.values()].includes(false)) continue
           if (!workspace) {
             const release = agent.toolsHome
               ? await (await import('./plugins/workspace-lease.mjs')).workspaceLease(agent.toolsHome,{kind:'native',runId:id}) : undefined
             if (agent.toolsHome && !release) continue
-            workspace = { lanes: new Set(), release }
+            workspace = { lanes: new Map(), release }
             activeWorkspaces.set(agent, workspace)
           }
-          workspace.lanes.add(scheduled)
-          // Keep plugin workspace invocations excluded until both streams finish.
+          workspace.lanes.set(id, scheduled)
+          claimed.add(base)
+          // Keep plugin workspace invocations excluded until all native jobs finish.
           const releaseWorkspace = async () => {
-            workspace.lanes.delete(scheduled)
+            workspace.lanes.delete(id)
             if (!workspace.lanes.size) {
               activeWorkspaces.delete(agent)
               await workspace.release?.()
             }
           }
           try { await rename(base+'.request.json',base+'.running.json') }
-          catch (error) { await releaseWorkspace(); throw error }
+          catch (error) { claimed.delete(base); await releaseWorkspace(); throw error }
           const task=(async()=>{
             let job: Awaited<ReturnType<typeof startExecutorJob>> | undefined
             let cancellation: ReturnType<typeof setInterval> | undefined
             let writes=Promise.resolve()
+            let observeClaude=false
             const emit=(event:unknown)=>{writes=writes.then(()=>appendFile(base+'.events',JSON.stringify(event)+'\n',{mode:0o600}))}
             try {
               try { await readFile(base+'.cancel'); throw new Error('Cancelled') } catch(error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }
@@ -195,34 +202,58 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
                 await new Tasks(agent.controlDir).authorize(run, false)
               } else await authorizeRun(agent.controlDir, path.basename(base))
               const opts=request.options as ExecutorOptions
-              if (run?.scheduled) {
-                assertScheduledModel(run.execution?.preset.model)
-                if (opts.model !== run.execution!.preset.model) throw new Error('Scheduled run model does not match its saved task model')
+              // Script occurrences come from the authorized run record, never the request.
+              if (run?.script) {
+                if (!run.scheduled) throw new Error('Script runs require a scheduled occurrence')
+                const options:ExecutorOptions={workspace:agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,sharedWorkspace,additionalWorkspaces:additionalWorkspaces.get(agent),
+                  runId:path.basename(base),timeoutMs:0,repairEnabled:opts.repairEnabled,
+                  script:{...run.script,scheduleId:run.scheduled.id,scheduleRevision:run.scheduled.revision,dueAt:run.scheduled.dueAt}}
+                job=await launch(request.texts,options)
+              } else {
+                const cli = opts.cli || installation.cli
+                if (run?.scheduled) {
+                  const setup = activeSetup(run)
+                  assertScheduledModel(setup?.model)
+                  if (opts.model !== setup!.model || cli !== setup!.cli) throw new Error('Scheduled run model does not match its saved task model')
+                  observeClaude = cli === 'claude'
+                }
+                resolveExecutor(cli)
+                // The credential home comes from the authorized run's captured
+                // choice; a request can never move it to another account.
+                const captured = run?.scheduled ? activeSetup(run) : run?.execution?.preset
+                if ((opts.authProfile !== undefined || (captured?.cli === cli && captured.authProfile !== undefined)) &&
+                    !(captured && sameEngine(captured, {cli, authProfile: opts.authProfile})))
+                  throw new Error('Run auth profile does not match its captured AI selection')
+                const provider = cli === 'codex' && opts.provider
+                  ? (agent.codexProviders ?? []).map(validateCodexProvider).find(candidate=>candidate.id===opts.provider)
+                  : undefined
+                if (opts.provider && !provider) throw new Error('Selected Codex provider is not installed for this agent')
+                const model = opts.model
+                if (provider && !model) throw new Error('Selected Codex provider requires a declared model')
+                if (provider && model && !provider.models.includes(model)) throw new Error('Selected model is not declared for this Codex provider')
+                if (!provider && model && (agent.codexProviders ?? []).some(binding=>binding.models.includes(model)))
+                  throw new Error('Selected Codex provider is required for this model')
+                // Admission and execution must use the same catalog snapshot. A
+                // transient native-client probe failure must not reject a model
+                // that the host just advertised to the relay and application.
+                if (cli !== installation.cli || opts.authProfile !== undefined) await validateSelection({id:'selected',name:'Selected model',cli,provider:opts.provider,authProfile:opts.authProfile,model,effort:opts.effort},JSON.parse(await readFile(path.join(directory,'models.json'),'utf8')))
+                const options:ExecutorOptions={workspace:agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,sharedWorkspace,additionalWorkspaces:additionalWorkspaces.get(agent),cli,
+                  runId:path.basename(base),timeoutMs:0,repairEnabled:opts.repairEnabled,
+                  sessionId:opts.sessionId,isResume:opts.isResume,model,effort:opts.effort,provider:opts.provider,authProfile:opts.authProfile,codexAutoCompactTokens:opts.codexAutoCompactTokens,codexProvider:provider,
+                  promptSuffix:runPromptSuffix(run),taskRun:Boolean(run?.taskId),nativeSession:Boolean(run?.scheduled)}
+                job=await launch(request.texts,options)
               }
-              const cli = opts.cli || installation.cli
-              resolveExecutor(cli)
-              const provider = cli === 'codex' && opts.provider
-                ? (agent.codexProviders ?? []).map(validateCodexProvider).find(candidate=>candidate.id===opts.provider)
-                : undefined
-              if (opts.provider && !provider) throw new Error('Selected Codex provider is not installed for this agent')
-              const model = opts.model
-              if (provider && !model) throw new Error('Selected Codex provider requires a declared model')
-              if (provider && model && !provider.models.includes(model)) throw new Error('Selected model is not declared for this Codex provider')
-              if (!provider && model && (agent.codexProviders ?? []).some(binding=>binding.models.includes(model)))
-                throw new Error('Selected Codex provider is required for this model')
-              // Admission and execution must use the same catalog snapshot. A
-              // transient native-client probe failure must not reject a model
-              // that the host just advertised to the relay and application.
-              if (cli !== installation.cli) await validateSelection({id:'selected',name:'Selected model',cli,provider:opts.provider,model,effort:opts.effort},JSON.parse(await readFile(path.join(directory,'models.json'),'utf8')))
-              const options:ExecutorOptions={workspace:agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,sharedWorkspace,additionalWorkspaces:additionalWorkspaces.get(agent),cli,
-                runId:path.basename(base),timeoutMs:0,repairEnabled:opts.repairEnabled,
-                sessionId:opts.sessionId,isResume:opts.isResume,model,effort:opts.effort,provider:opts.provider,codexAutoCompactTokens:opts.codexAutoCompactTokens,codexProvider:provider,
-                promptSuffix:runPromptSuffix(run),taskRun:Boolean(run?.taskId),nativeSession:Boolean(run?.scheduled)}
-              job=await launch(request.texts,options)
               active.set(base,job.child)
               await writeFile(base+'.process.json',JSON.stringify({pid:job.child.pid}),{mode:0o600})
               if(signal.aborted)terminateJob(job.child)
-              job.child.stdout?.on('data',chunk=>emit({stream:'stdout',text:chunk.toString()}))
+              // Scheduled Claude streams every event; forward only the startup summary.
+              const startup = observeClaude ? startupObserver() : undefined
+              let summary = ''
+              job.child.stdout?.setEncoding('utf8').on('data',(chunk:string)=>{
+                if (!startup) return emit({stream:'stdout',text:chunk})
+                startup.write(chunk)
+                if (startup.summary() !== summary) { summary = startup.summary(); emit({stream:'stdout',text:summary+'\n'}) }
+              })
               job.child.stderr?.on('data',chunk=>emit({stream:'stderr',text:chunk.toString()}))
               cancellation=setInterval(()=>{void readFile(base+'.cancel').then(()=>terminateJob(job!.child)).catch(()=>{})},250)
               const code=await new Promise<number>(resolve=>job!.child.once('close',code=>resolve(code??1)))
@@ -230,7 +261,9 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               await job.cleanup()
               job = undefined
               emit({stream:'exit',code})
-            } catch (error) { emit({stream:'stderr',text:'Host CLI execution failed: '+redactFailure(error instanceof Error ? error.message : 'Unknown error')+'\n'}); emit({stream:'exit',code:1}) }
+            } catch (error) {
+              if (error instanceof CliUnavailableError) emit({stream:'stdout',text:startupLine({workBegan:false,rejection:{category:'cli-unavailable'}})+'\n'})
+              emit({stream:'stderr',text:'Host CLI execution failed: '+redactFailure(error instanceof Error ? error.message : 'Unknown error')+'\n'}); emit({stream:'exit',code:1}) }
             finally {
               if(cancellation)clearInterval(cancellation)
               await job?.cleanup().catch(() => {})
@@ -240,6 +273,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               await rm(base+'.cancel',{force:true})
               active.delete(base)
               await releaseWorkspace()
+              claimed.delete(base)
             }
           })()
           tasks.add(task); void task.finally(()=>tasks.delete(task))

package/src/index.ts

@@ -11,6 +11,8 @@ import { dispatchChannel } from './channel-backend.js'
 import { randomUUID } from 'node:crypto'
 import { stat } from 'node:fs/promises'
 import { Scheduler } from './scheduler.js'
+import { Scripts } from './scripts.js'
+import { redactFailure } from './failure.js'
 import { ownedScheduledTasks, scheduledTaskDetailText, scheduledTasksText } from './scheduled-tasks.js'
 import { EventSources, eventRunId, batchReady, type SourceEvent } from './event-sources.js'
 import {removeTaskAttachments} from './task-attachments.js'
@@ -25,7 +27,8 @@ import { InboxStore, type IncomingItem } from './inbox.js'
 import { loadConfig, type Config } from './config.js'
 import { ControlStore, telegramOwner, ownerId, ownerEpoch } from './control-state.js'
 import { ApprovalStore } from './approval.js'
-import { startExecutorJob, terminateJob, opencodeDataHome } from './executor.js'
+import { CliUnavailableError, startExecutorJob, terminateJob, opencodeDataHome, claudeConfigHome } from './executor.js'
+import { advances, nextSetup, quotaScope, setupCandidates, startupObserver, unavailableSummary, SetupsUnavailableError, type SetupAttempt } from './setup-fallback.js'
 import { assertScheduledModel } from './model-policy.js'
 import { RunStore, type RunRecord } from './runs.js'
 import { splitTelegramText } from './reply.js'
@@ -36,7 +39,7 @@ import { normalizeReactionEmoji } from './reaction.js'
 import { downloadTelegramFile } from './read-request.js'
 import { createConversationMenu } from './conversation-menu.js'
 import { createAiMenu, mainCommands, mainKeyboard } from './menu.js'
-import { chatPreset, initialPreset, persistedPreset, presetLabel, statusPreset } from './ai.js'
+import { chatPreset, initialPreset, persistedPreset, presetLabel, statusPreset, type AiPreset } from './ai.js'
 import { discoverDefaults } from './client-defaults.js'
 import { runPromptSuffix } from './prompt-suffix.js'
 import { softwareStatus } from './software-status.js'
@@ -44,7 +47,7 @@ import { softwareStatus } from './software-status.js'
 export const createRelay = (config: Config, launch = startExecutorJob) => {
   const safeError = (error: unknown): string => {
     let message = error instanceof Error ? error.message : typeof error === 'string' ? error : 'Unknown error'
-    for (const secret of [config.channelBackendToken, config.telegramBotToken, config.geminiApiKey, config.openaiApiKey]) {
+    for (const secret of [config.channelBackendToken, config.telegramBotToken, config.geminiApiKey, config.openaiApiKey, config.openrouterApiKey]) {
       if (secret) message = message.replaceAll(secret, '[redacted]')
     }
     return message
@@ -60,7 +63,9 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   const scheduler = new Scheduler(config.controlDir)
   const background = new Map<string, ChildProcess>()
   const completions = new Set<Promise<void>>()
-  const tasks = new Tasks(config.controlDir)
+  const speechOptions = { geminiApiKey: config.geminiApiKey, openrouterApiKey: config.openrouterApiKey, speechProvider: config.speechProvider, speechModel: config.speechModel }
+  const speechConfigured = config.speechProvider === 'openrouter' ? Boolean(config.openrouterApiKey) : Boolean(config.geminiApiKey)
+  const tasks = new Tasks(config.controlDir, speechConfigured ? (text) => synthesizeSpeech(text, { ...speechOptions, voice: config.speechVoiceEn, signal: AbortSignal.timeout(20000) }) : undefined)
   const processTaskRequests = taskRequests(tasks)
   let taskWork: Promise<void> | undefined
   const drainTaskRequests = (): Promise<void> => {
@@ -103,8 +108,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   const applicationChannel = new ApplicationChannel({
     controlDir: config.controlDir, workspace: config.workspace, isolation: config.isolation, initial: aiMenu.initial,
     aiControls: aiMenu,
-    speech: config.geminiApiKey ? (text, language) => synthesizeSpeech(text, {
-      geminiApiKey: config.geminiApiKey,
+    speech: speechConfigured ? (text, language) => synthesizeSpeech(text, {
+      ...speechOptions,
       voice: language === 'es' ? config.speechVoiceEs : config.speechVoiceEn,
       format: 'wav',
     }) : undefined,
@@ -207,8 +212,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       }
       if (run.scheduled && !(await scheduler.get(run.scheduled.id)).enabled) return
       // A long scheduled turn must not occupy the owner's chat stream.
-      // Each stream remains serial, with separate native sessions.
-      if (run.scheduled ? background.size > 0 : activeChild !== null) return
+      // Foreground stays serial; scheduled jobs have independent native sessions.
+      if (run.scheduled ? background.size >= (config.scheduledConcurrency ?? 6) : activeChild !== null) return
       let texts = run.texts
       if (run.external) {
         // Availability failures leave durable queued work for a later check.
@@ -232,111 +237,19 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         await releaseExternal(run)
         return
       }
-      try {
-        const launchStarted = performance.now()
-        const started = await runs.patch(run.id, { status: 'running', startedAt: new Date().toISOString() })
-        if (!started.execution && !run.taskId) throw new Error('Legacy queued work has no pinned AI. Resend the request after /new.')
-        const startsOwnSession = Boolean(run.external || run.taskId || run.scheduled)
-        const session = startsOwnSession
-          ? { sessionId: randomUUID(), hasStarted: false, nativeSessionId: undefined }
-          : await control.executionSession(started.execution!)
-        const selected = run.taskId ? (started.execution?.preset.cli === 'codex' ? started.execution.preset : initialPreset('codex')) : started.execution!.preset
-        if (run.scheduled) assertScheduledModel(selected.model)
-        const { child, cleanup } = await launch(texts, {
-          workspace: config.workspace,
-          timeoutMs: config.executorTimeoutMs,
-          repairEnabled: config.repairEnabled,
-          runId: started.id,
-          controlDir: config.controlDir,
-          binDir,
-          cli: selected.cli,
-          model: selected.model,
-          effort: selected.effort,
-          provider: selected.provider,
-          codexAutoCompactTokens: config.codexAutoCompactTokens,
-          codexSandbox: !run.taskId && selected.cli === 'codex' ? config.codexSandbox : undefined,
-          sessionId: session.nativeSessionId || session.sessionId,
-          isResume: session.hasStarted,
-          promptSuffix: runPromptSuffix(started),
-          taskRun: Boolean(run.taskId),
-          nativeSession: Boolean(run.scheduled),
-          onSession: run.external || run.taskId ? undefined : async (id) => { await runs.patch(run.id,{nativeSessionId:id}); if (!run.scheduled) await control.saveNativeSession(session.sessionId,id) },
-        })
-        const executionStarted = performance.now()
-        // Attach before disk writes: a fast child can close while PID persistence
-        // is pending, and Node drains its remaining pipes during process close.
-        let failureReason = 'executor-exit', errorTail = '', interrupted = false
-        child.stderr?.setEncoding('utf8').on('data', (chunk: string) => {
-          errorTail = (errorTail + chunk).slice(-16384)
-          if (chunk.includes('Host CLI executor is offline')) failureReason = 'host-executor-offline'
-          if (chunk.includes('Host executor client interrupted by')) {
-            failureReason = 'host-executor-transport-interrupted'
-            interrupted = true
-          }
-          if (chunk.trim()) console.error('executor stderr', started.id, chunk.trim())
-        })
-        console.info('run timing', { run_id: run.id, phase: 'launch',
-          queue_ms: Math.max(0, Date.parse(started.startedAt!) - Date.parse(run.createdAt)),
-          startup_ms: Math.round(executionStarted - launchStarted), resumed: session.hasStarted })
-        if (run.scheduled) background.set(run.id,child)
-        else activeChild = child
-        const finished = new Promise<number | null>((resolve) => {
-          if (child.exitCode !== null || child.signalCode !== null) resolve(child.exitCode)
-          else child.once('close', resolve)
-        })
-        await runs.patch(started.id, { pid: child.pid })
-        console.info('run started', {
-          run_id: started.id,
-          pid: child.pid,
-          cli: selected.cli,
-          session: session.sessionId,
-          isResume: session.hasStarted,
-        })
-
-        if (!run.scheduled && activeTypingTimer) clearInterval(activeTypingTimer)
-        if (bot && run.chatId !== undefined && !run.application && !run.external && !run.taskId && !run.scheduled) activeTypingTimer = setInterval(() => {
-          if (performance.now() - executionStarted < 30000) void bot.api.sendChatAction(run.chatId!, 'typing').catch(() => {})
-        }, 4000)
-
-        const completion = finished.then((code) => {
-          console.info('run timing', { run_id: run.id, phase: 'execution',
-            execution_ms: Math.round(performance.now() - executionStarted), exit_code: code })
-          return (async () => {
-            await withStartLock(async () => {
-              try {
-                await cleanup()
-                if (code === 0 && !run.external && !run.taskId && !run.scheduled) await control.markSessionStarted(session.sessionId)
-                const cancelled = ownerStopped.has(child) || Boolean(run.scheduled && await scheduler.cancelled(run.id))
-                await runs.patch(started.id, { status: cancelled ? 'cancelled' : code === 0 ? 'completed' : 'failed', endedAt: new Date().toISOString(), exitCode: code, ...(code !== 0 && !cancelled ? { failureReason, interrupted, failure: await failureEvidence(config.controlDir, safeError(errorTail || `Executor exited with ${code === null ? 'a signal' : `code ${code}`}`)) } : {}) })
-                await releaseExternal(run)
-              } catch (error) {
-                await runs.patch(started.id, { status: ownerStopped.has(child) ? 'cancelled' : 'failed', failureReason: 'session-finalization', failure: await failureEvidence(config.controlDir, safeError(error)), endedAt: new Date().toISOString() })
-                console.error('Session completion failed', safeError(error))
-              } finally {
-                if (run.scheduled) background.delete(run.id)
-                else {
-                  activeChild = null
-                  if (activeTypingTimer) clearInterval(activeTypingTimer)
-                  activeTypingTimer = null
-                }
-              }
-            })
-            console.info('run ended', { run_id: started.id, code })
-            const next = await runs.nextQueued()
-            if (next && !shuttingDown) await startJob(next)
-          })().catch((error) => console.error('Run completion failed', error.message))
-        })
-        completions.add(completion)
-        void completion.finally(() => completions.delete(completion))
-      } catch (error) {
+      // Shared by a first launch and a fallback launch that cannot start.
+      const startFailed = async (error: unknown) => {
         if (!run.scheduled && activeTypingTimer) {
           clearInterval(activeTypingTimer)
           activeTypingTimer = null
         }
-        await runs.patch(run.id, { status: 'failed', failureReason: 'executor-start', failure: await failureEvidence(config.controlDir, safeError(error)), endedAt: new Date().toISOString() })
+        if (run.scheduled) background.delete(run.id)
+        const unavailable = error instanceof SetupsUnavailableError
+        await runs.patch(run.id, { status: 'failed', failureReason: unavailable ? 'setups-unavailable' : 'executor-start', failure: await failureEvidence(config.controlDir, safeError(error)), endedAt: new Date().toISOString() })
         await releaseExternal(run)
         console.error('run start failed', run.id, safeError(error))
-        if (bot && !run.application && !run.delivery && run.chatId !== undefined) await sendChat(run.chatId, `Run ${run.id} failed to start. Check the local relay log.`)
+        if (bot && !run.application && !run.delivery && run.chatId !== undefined)
+          await sendChat(run.chatId, unavailable ? `Run ${run.id} could not start. ${safeError(error)}` : `Run ${run.id} failed to start. Check the local relay log.`)
         setImmediate(() => {
           void runs
             .nextQueued()
@@ -344,6 +257,210 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             .catch(console.error)
         })
       }
+      try {
+        const launchStarted = performance.now()
+        const started = await runs.patch(run.id, { status: 'running', startedAt: new Date().toISOString() })
+        // A registered script occurrence: no model, prompt or native session.
+        const script = run.script && run.scheduled
+          ? { registration: await new Scripts(config.controlDir).owned(run.script.id, owner), ref: run.script, scheduled: run.scheduled }
+          : undefined
+        if (run.script && !script) throw new Error('Script runs require a scheduled occurrence')
+        if (!started.execution && !run.taskId && !script) throw new Error('Legacy queued work has no pinned AI. Resend the request after /new.')
+        const startsOwnSession = Boolean(run.external || run.taskId || run.scheduled)
+        const session = startsOwnSession
+          ? { sessionId: randomUUID(), hasStarted: false, nativeSessionId: undefined }
+          : await control.executionSession(started.execution!)
+        const selected = script ? initialPreset('codex') : run.taskId ? (started.execution?.preset.cli === 'codex' ? started.execution.preset : initialPreset('codex')) : started.execution!.preset
+        if (run.scheduled && !script) assertScheduledModel(selected.model)
+        // A scheduled occurrence may name ordered fallback setups. They share this
+        // run, workspace and concurrency slot; each is tried at most once.
+        const candidates = run.scheduled && !script ? setupCandidates(started.execution!) : [selected]
+        const ordered = candidates.length > 1
+        let attempts: SetupAttempt[] = []
+        const settle = (change: Partial<SetupAttempt>) => {
+          attempts = [...attempts.slice(0, -1), { ...attempts[attempts.length - 1], ...change, endedAt: new Date().toISOString() }]
+        }
+        // Advance only after an eligible pre-work failure of a current, uncancelled
+        // occurrence. Setups in an exhausted quota scope are skipped and recorded.
+        const advance = async (): Promise<AiPreset | undefined> => {
+          let preset: AiPreset | undefined
+          const current = !shuttingDown && !await scheduler.cancelled(run.id) ? (await control.status()).owner : undefined
+          if (current && ownsRun(current, run) && await scheduler.current(run, current)) {
+            const next = nextSetup(candidates, attempts)
+            attempts = [...attempts, ...next.skipped]
+            if (!next.preset) {
+              await runs.patch(run.id, { attempts })
+              throw new SetupsUnavailableError(unavailableSummary(attempts))
+            }
+            preset = next.preset
+          }
+          await runs.patch(run.id, { attempts })
+          return preset
+        }
+        // Each attempt is a fresh native session; a rejected Claude attempt already claimed its ID.
+        const launchSetup = async (preset: AiPreset): Promise<{ child: ChildProcess; cleanup: () => Promise<void>; preset: AiPreset }> => {
+          for (;;) {
+            const sessionId = attempts.length ? randomUUID() : session.nativeSessionId || session.sessionId
+            if (ordered) {
+              attempts = [...attempts, { preset, quotaScope: quotaScope(preset), outcome: 'running', startedAt: new Date().toISOString() }]
+              await runs.patch(run.id, { attempts })
+            }
+            try {
+              return { ...await launch(texts, script ? {
+                workspace: config.workspace, timeoutMs: 0, repairEnabled: config.repairEnabled, runId: started.id,
+                controlDir: config.controlDir, binDir,
+                script: { ...script.ref, scheduleId: script.scheduled.id, scheduleRevision: script.scheduled.revision, dueAt: script.scheduled.dueAt },
+              } : {
+                workspace: config.workspace,
+                timeoutMs: config.executorTimeoutMs,
+                repairEnabled: config.repairEnabled,
+                runId: started.id,
+                controlDir: config.controlDir,
+                binDir,
+                cli: preset.cli,
+                model: preset.model,
+                effort: preset.effort,
+                provider: preset.provider,
+                authProfile: preset.authProfile,
+                codexAutoCompactTokens: config.codexAutoCompactTokens,
+                codexSandbox: !run.taskId && preset.cli === 'codex' ? config.codexSandbox : undefined,
+                sessionId,
+                isResume: session.hasStarted,
+                promptSuffix: runPromptSuffix(started),
+                taskRun: Boolean(run.taskId),
+                nativeSession: Boolean(run.scheduled),
+                onSession: run.external || run.taskId ? undefined : async (id) => { await runs.patch(run.id,{nativeSessionId:id}); if (!run.scheduled) await control.saveNativeSession(session.sessionId,id) },
+              }), preset }
+            } catch (error) {
+              if (ordered && !(error instanceof CliUnavailableError)) {
+                settle({ outcome: 'failed', category: 'uncertain' })
+                await runs.patch(run.id, { attempts })
+              }
+              if (!ordered || !(error instanceof CliUnavailableError)) throw error
+              settle({ outcome: 'failed', category: 'cli-unavailable' })
+              const next = await advance()
+              if (!next) throw error
+              preset = next
+            }
+          }
+        }
+        const watch = async ({ child, cleanup, preset }: Awaited<ReturnType<typeof launchSetup>>): Promise<void> => {
+          const executionStarted = performance.now()
+          // Attach before disk writes: a fast child can close while PID persistence
+          // is pending, and Node drains its remaining pipes during process close.
+          let failureReason = 'executor-exit', errorTail = '', interrupted = false, outputTail = '', timedOut = false
+          // Script output is bounded diagnostics for run inspection, never chat.
+          if (script) child.stdout?.setEncoding('utf8').on('data', (chunk: string) => { outputTail = (outputTail + chunk).slice(-16384) })
+          // Structured startup events decide whether a failed setup may advance.
+          const startup = ordered ? startupObserver() : undefined
+          if (startup) child.stdout?.setEncoding('utf8').on('data', startup.write)
+          const scriptTimer = script ? setTimeout(() => { timedOut = true; terminateJob(child) }, script.registration.timeoutSeconds * 1000) : undefined
+          child.once('close', () => clearTimeout(scriptTimer))
+          child.stderr?.setEncoding('utf8').on('data', (chunk: string) => {
+            errorTail = (errorTail + chunk).slice(-16384)
+            if (script) outputTail = (outputTail + chunk).slice(-16384)
+            if (chunk.includes('Host CLI executor is offline')) failureReason = 'host-executor-offline'
+            if (chunk.includes('Host executor client interrupted by')) {
+              failureReason = 'host-executor-transport-interrupted'
+              interrupted = true
+            }
+            if (chunk.trim()) console.error('executor stderr', started.id, chunk.trim())
+          })
+          console.info('run timing', { run_id: run.id, phase: 'launch',
+            queue_ms: Math.max(0, Date.parse(started.startedAt!) - Date.parse(run.createdAt)),
+            startup_ms: Math.round(executionStarted - launchStarted), resumed: session.hasStarted })
+          if (run.scheduled) background.set(run.id,child)
+          else activeChild = child
+          const finished = new Promise<number | null>((resolve) => {
+            if (child.exitCode !== null || child.signalCode !== null) resolve(child.exitCode)
+            else child.once('close', resolve)
+          })
+          await runs.patch(started.id, { pid: child.pid })
+          console.info('run started', {
+            run_id: started.id,
+            pid: child.pid,
+            cli: script ? 'script' : preset.cli,
+            ...(script ? { script: script.ref.id, script_revision: script.ref.revision } : {}),
+            ...(ordered ? { setup: attempts.length } : {}),
+            session: session.sessionId,
+            isResume: session.hasStarted,
+          })
+
+          if (!run.scheduled && activeTypingTimer) clearInterval(activeTypingTimer)
+          if (bot && run.chatId !== undefined && !run.application && !run.external && !run.taskId && !run.scheduled) activeTypingTimer = setInterval(() => {
+            if (performance.now() - executionStarted < 30000) void bot.api.sendChatAction(run.chatId!, 'typing').catch(() => {})
+          }, 4000)
+
+          const free = () => {
+            if (run.scheduled) background.delete(run.id)
+            else {
+              activeChild = null
+              if (activeTypingTimer) clearInterval(activeTypingTimer)
+              activeTypingTimer = null
+            }
+          }
+          const finalize = async (code: number | null, cancelled: boolean, failed: boolean) => {
+            await runs.patch(started.id, { status: cancelled ? 'cancelled' : failed ? 'failed' : 'completed', endedAt: new Date().toISOString(), exitCode: code,
+              ...(script ? { output: redactFailure(safeError(outputTail)), ...(timedOut ? { timedOut } : {}) } : {}),
+              ...(failed ? { failureReason, interrupted, failure: await failureEvidence(config.controlDir, safeError(timedOut ? `Script exceeded its ${script!.registration.timeoutSeconds}s timeout and was terminated` : errorTail || `Executor exited with ${code === null ? 'a signal' : `code ${code}`}`)) } : {}) })
+            await releaseExternal(run)
+          }
+          const completion = finished.then((code) => {
+            console.info('run timing', { run_id: run.id, phase: 'execution',
+              execution_ms: Math.round(performance.now() - executionStarted), exit_code: code })
+            return (async () => {
+              let eligible = false
+              await withStartLock(async () => {
+                try {
+                  await cleanup()
+                  if (code === 0 && !run.external && !run.taskId && !run.scheduled) await control.markSessionStarted(session.sessionId)
+                  const cancelled = !timedOut && (ownerStopped.has(child) || Boolean(run.scheduled && await scheduler.cancelled(run.id)))
+                  if (timedOut) failureReason = 'script-timeout'
+                  const observed = startup?.result()
+                  const rejected = observed?.rejection && !observed.workBegan ? observed.rejection : undefined
+                  // A rejection before work is a failure even when the CLI exits 0.
+                  const failed = !cancelled && (code !== 0 || timedOut || Boolean(rejected))
+                  if (startup) {
+                    settle({ outcome: cancelled ? 'cancelled' : failed ? 'failed' : 'completed', exitCode: code,
+                      ...(failed ? { category: rejected?.category ?? (observed!.workBegan ? 'after-work-began' : 'uncertain') } : {}),
+                      ...(failed && rejected?.resetAt ? { resetAt: rejected.resetAt } : {}) })
+                    await runs.patch(run.id, { attempts })
+                    eligible = failed && !interrupted && advances(rejected)
+                  }
+                  if (!eligible) await finalize(code, cancelled, failed)
+                } catch (error) {
+                  eligible = false
+                  await runs.patch(started.id, { status: ownerStopped.has(child) ? 'cancelled' : 'failed', failureReason: 'session-finalization', failure: await failureEvidence(config.controlDir, safeError(error)), endedAt: new Date().toISOString() })
+                  console.error('Session completion failed', safeError(error))
+                } finally {
+                  // An advancing occurrence keeps its concurrency slot for the next setup.
+                  if (!eligible) free()
+                }
+              })
+              console.info('run ended', { run_id: started.id, code, ...(eligible ? { advancing: true } : {}) })
+              // Re-check cancellation and shutdown under the start lock, so a stop
+              // that already snapshotted children never misses the next setup.
+              if (eligible) return withStartLock(async () => {
+                try {
+                  const next = await advance()
+                  if (next) return await watch(await launchSetup(next))
+                  const cancelled = await scheduler.cancelled(run.id)
+                  await finalize(code, cancelled, !cancelled)
+                  free()
+                  setImmediate(() => { void runs.nextQueued().then(queued => { if (queued && !shuttingDown) return startJob(queued) }).catch(console.error) })
+                } catch (error) { await startFailed(error) }
+              })
+              const next = await runs.nextQueued()
+              if (next && !shuttingDown) await startJob(next)
+            })().catch((error) => console.error('Run completion failed', error.message))
+          })
+          completions.add(completion)
+          void completion.finally(() => completions.delete(completion))
+        }
+        await watch(await launchSetup(selected))
+      } catch (error) {
+        await startFailed(error)
+      }
     })
   }
 
@@ -587,8 +704,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           } else if (item.type === 'voice' && item.voiceText) {
             await bot!.api.sendChatAction(item.chatId, 'record_voice')
             const { buffer } = await synthesizeSpeech(item.voiceText, {
-              geminiApiKey: config.geminiApiKey,
-              openaiApiKey: config.openaiApiKey,
+              ...speechOptions,
               voice: config.speechVoiceEn,
             })
             await paceSend()
@@ -719,7 +835,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     const delivery = await runs.deliveryStatus()
     const ai = await control.aiState(aiMenu.initial)
     const selected = ai.presets.find((p) => p.id === ai.selectedId)!
-    const discovered = await discoverDefaults(config.workspace, { codexHome, nativeCodexFallback: true })
+    const discovered = await discoverDefaults(config.workspace, { codexHome, claudeHome: claudeConfigHome(config.controlDir), nativeCodexFallback: true })
     const displayedSelected = statusPreset(selected, discovered)
     const scheduled = all.filter(run => run.scheduled && run.status === 'running').length
     const queued = all.filter(run => run.status === 'queued').length
@@ -743,6 +859,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       '',
       'Work',
       `Current: ${running ? (waitingForHost ? 'waiting for the workspace' : 'running') : 'idle'}`,
+      `Scheduled limit: ${config.scheduledConcurrency ?? 6}`,
       `Background: ${scheduled ? `${scheduled} scheduled task${scheduled === 1 ? '' : 's'} running` : 'none'}`,
       `Queue: ${queued || incoming.pending ? `${queued} run${queued === 1 ? '' : 's'}; ${incoming.pending} incoming message${incoming.pending === 1 ? '' : 's'}` : 'empty'}`,
       ...(attention.length ? ['', 'Needs attention', ...attention] : []),

package/src/install-tools.mjs

@@ -16,13 +16,14 @@ export const hostEnvironment=()=>Object.fromEntries(['HOME','PATH','LANG','LC_AL
 async function atomic(file,value) {
   const tmp=file+'.'+randomUUID()+'.tmp';await fs.writeFile(tmp,JSON.stringify(value)+'\n',{mode:0o600,flag:'wx'});await fs.rename(tmp,file);
 }
-export function run(command,args,{cwd,log,timeout=15000}={}) {
+export function run(command,args,{cwd,log,timeout=15000,stdoutOnly=false}={}) {
   return new Promise((resolve,reject)=>{
-    const child=spawn(command,args,{cwd,env:hostEnvironment(),stdio:['ignore',log??'pipe',log??'pipe']});let output='';
-    for(const stream of [child.stdout,child.stderr])stream?.on('data',b=>output=(output+b).slice(-200000));
+    const child=spawn(command,args,{cwd,env:hostEnvironment(),stdio:['ignore',log??'pipe',log??'pipe']});let output='',stdout='';
+    child.stdout?.on('data',b=>{output=(output+b).slice(-200000);if(stdoutOnly)stdout=(stdout+b).slice(-200000);});
+    child.stderr?.on('data',b=>output=(output+b).slice(-200000));
     const timer=setTimeout(()=>child.kill('SIGTERM'),timeout);
     child.once('error',e=>{clearTimeout(timer);reject(e);});
-    child.once('close',code=>{clearTimeout(timer);if(code!==0)reject(Error(`${command} failed (${code})${log===undefined?': '+output.trim():''}`));else resolve(output.trim());});
+    child.once('close',code=>{clearTimeout(timer);if(code!==0)reject(Error(`${command} failed (${code})${log===undefined?': '+output.trim():''}`));else resolve((stdoutOnly?stdout:output).trim());});
   });
 }
 export const defaultHome=()=>path.join(process.env.XDG_DATA_HOME||path.join(homedir(),'.local/share'),'ez');
@@ -115,7 +116,9 @@ export async function migrateLedger({ deployment } = {}) {
 }
 
 export async function latestCodexVersion(invoke,manager={command:"npm",args:[]}) {
-  const version=JSON.parse(await invoke(manager.command,[...manager.args,'view','@openai/codex@latest','version','--json','--registry','https://registry.npmjs.org/']));
+  const output=await invoke(manager.command,[...manager.args,'view','@openai/codex@latest','version','--json','--registry','https://registry.npmjs.org/'],{stdoutOnly:true});
+  let version;
+  try {version=JSON.parse(output);}catch {throw Error('Codex version discovery returned invalid JSON on stdout');}
   if(typeof version!=='string'||!/^\d+\.\d+\.\d+$/.test(version))throw Error('Invalid latest Codex version');
   return version;
 }