@jc_stack/ez-agents 0.1.0-beta.48 → 0.1.0-beta.50

package/src/index.ts

@@ -9,9 +9,9 @@ import { packageVersion } from './version.js'
 import {authorizeDeliveryContext} from './delivery-context.mjs'
 import { dispatchChannel } from './channel-backend.js'
 import { randomUUID } from 'node:crypto'
-import { stat } from 'node:fs/promises'
+import { mkdir, stat, writeFile } from 'node:fs/promises'
 import { Scheduler } from './scheduler.js'
-import { Scripts } from './scripts.js'
+import { Scripts, DEFAULT_SCRIPT_TIMEOUT_SECONDS } 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'
@@ -25,11 +25,12 @@ import { isOwner, ownsRun } from './identity.js'
 import type { Update } from 'grammy/types'
 import { InboxStore, type IncomingItem } from './inbox.js'
 import { loadConfig, type Config } from './config.js'
-import { ControlStore, telegramOwner, ownerId, ownerEpoch } from './control-state.js'
+import { ControlStore, telegramOwner, ownerId, ownerEpoch, type SessionState } from './control-state.js'
 import { ApprovalStore } from './approval.js'
-import { startExecutorJob, terminateJob, opencodeDataHome, claudeConfigHome } from './executor.js'
+import { CliUnavailableError, startExecutorJob, attachHostJob, terminateJob, opencodeDataHome, claudeConfigHome } from './executor.js'
+import { attemptFailure, continuationLine, 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 { RunStore, saveRunHandoff, takeRunHandoff, type RunRecord } from './runs.js'
 import { splitTelegramText } from './reply.js'
 import { markdownToTelegramHtml, escapeHtml } from './format.js'
 import { sanitizeFileName, stageChatAttachment, workspaceFile } from './files.js'
@@ -37,8 +38,9 @@ import { transcribeAudio, synthesizeSpeech } from './audio.js'
 import { normalizeReactionEmoji } from './reaction.js'
 import { downloadTelegramFile } from './read-request.js'
 import { createConversationMenu } from './conversation-menu.js'
+import { queueSessionClose } from './session-close.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'
@@ -76,13 +78,27 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   const codexHome = join(config.controlDir, 'cli', 'codex')
   const conversationMenu = createConversationMenu(control)
   const aiMenu = createAiMenu(control, config.executorCli, undefined, config.workspace, codexHome,
-    undefined, opencodeDataHome(config.controlDir))
+    undefined, opencodeDataHome(config.controlDir), (session) => closeSession(session))
   const durableWorkerChoice = () => control.captureChoice(aiMenu.initial)
   const binDir = join(dirname(fileURLToPath(import.meta.url)), '..', 'bin')
+  // Queue the replaced chat session's silent close turn (session-close.ts).
+  // A busy relay starts it after the active run, ahead of newer chat input.
+  const closeSession = async (session: SessionState | null): Promise<void> => {
+    if (config.channelBackendUrl) return
+    // The replacement is already saved; a failed close must not fail that reply.
+    try {
+      const run = await queueSessionClose(runs, (await control.status()).owner, session)
+      if (run) void startJob(run).catch((error) => console.error('Conversation close failed to start', safeError(error)))
+    } catch (error) { console.error('Conversation close failed to queue', safeError(error)) }
+  }
 
   let activeTypingTimer: ReturnType<typeof setInterval> | null = null
   let activeBackend = false
   const ownerStopped = new WeakSet<ChildProcess>()
+  // Host-transport executors outlive this relay; a graceful stop hands them off.
+  const hostTransport = process.env.EZ_EXECUTOR_TRANSPORT === 'host' && !config.channelBackendUrl
+  const childRuns = new WeakMap<ChildProcess, string>()
+  const handedOff = new WeakSet<ChildProcess>()
   let activeChild: ChildProcess | null = null
   let runtimeStarted = false
   let shuttingDown = false
@@ -113,6 +129,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       format: 'wav',
     }) : undefined,
     wake: () => { void drainSources().catch(error => console.error('Application queue unavailable', safeError(error))) },
+    closeSession: (session) => closeSession(session),
     createTelegramPairing: async (bindingId, owner) => {
       const username = bot?.botInfo?.username
       if (!username || !/^[A-Za-z][A-Za-z0-9_]{4,31}$/.test(username))
@@ -177,7 +194,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       // stat uses the effective UID; access uses the relay's isolated real UID.
       if (await stat(join(config.controlDir,'upgrade-pause.json')).then(()=>true,e=>{if(e.code==='ENOENT')return false;throw e})) return
       if ((await runs.get(run.id))?.status !== 'queued') return
-      if (!telegramEnabled && !run.application && !run.delivery && !run.scheduled && !run.external) return
+      if (!telegramEnabled && !run.application && !run.delivery && !run.scheduled && !run.external && !run.sessionClose) return
       if (!run.scheduled && await runs.running(false)) return
       const owner = (await control.status()).owner
       if (!owner || !ownsRun(owner, run)) {
@@ -236,6 +253,26 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         await releaseExternal(run)
         return
       }
+      // 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
+        }
+        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, unavailable ? `Run ${run.id} could not start. ${safeError(error)}` : `Run ${run.id} failed to start. Check the local relay log.`)
+        setImmediate(() => {
+          void runs
+            .nextQueued()
+            .then((next) => next && startJob(next))
+            .catch(console.error)
+        })
+      }
       try {
         const launchStarted = performance.now()
         const started = await runs.patch(run.id, { status: 'running', startedAt: new Date().toISOString() })
@@ -251,121 +288,198 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           : 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)
-        const { child, cleanup } = 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: 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, 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) })
-        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
+        // 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 failure (see attemptFailure) of a current,
+        // uncancelled occurrence. Setups in an exhausted 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
           }
-          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' : selected.cli,
-          ...(script ? { script: script.ref.id, script_revision: script.ref.revision } : {}),
-          session: session.sessionId,
-          isResume: session.hasStarted,
-        })
+          await runs.patch(run.id, { attempts })
+          return preset
+        }
+        // Each attempt is a fresh native session: a rejected Claude attempt already
+        // claimed its ID, and a session cannot resume under another login's home.
+        const launchSetup = async (preset: AiPreset): Promise<{ child: ChildProcess; cleanup: () => Promise<void>; preset: AiPreset }> => {
+          for (;;) {
+            const sessionId = attempts.length ? randomUUID() : session.nativeSessionId || session.sessionId
+            const continuation = continuationLine(started.id, attempts)
+            if (ordered) {
+              attempts = [...attempts, { preset, quotaScope: quotaScope(preset), outcome: 'running', sessionId, startedAt: new Date().toISOString() }]
+              await runs.patch(run.id, { attempts })
+            }
+            try {
+              return { ...await launch(continuation ? [...texts, continuation] : 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
+          childRuns.set(child, run.id)
+          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)
+          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 = !timedOut && (ownerStopped.has(child) || Boolean(run.scheduled && await scheduler.cancelled(run.id)))
-                if (timedOut) failureReason = 'script-timeout'
-                const failed = !cancelled && (code !== 0 || timedOut)
-                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)
-              } 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
+          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()
+                  // The next relay records a handed-off run's result.
+                  if (handedOff.has(child)) return
+                  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) {
+                    const { continues, ...failure } = failed ? attemptFailure(observed!) : { continues: false }
+                    settle({ outcome: cancelled ? 'cancelled' : failed ? 'failed' : 'completed', exitCode: code, ...failure })
+                    await runs.patch(run.id, { attempts })
+                    eligible = continues && !interrupted
+                  }
+                  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 })
-            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) {
-        if (!run.scheduled && activeTypingTimer) {
-          clearInterval(activeTypingTimer)
-          activeTypingTimer = null
+              })
+              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 runs.patch(run.id, { status: 'failed', failureReason: '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.`)
-        setImmediate(() => {
-          void runs
-            .nextQueued()
-            .then((next) => next && startJob(next))
-            .catch(console.error)
-        })
+        await watch(await launchSetup(selected))
+      } catch (error) {
+        await startFailed(error)
       }
     })
   }
@@ -935,7 +1049,9 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
 
     if (text === '/new') {
       await control.aiState(aiMenu.initial)
+      const previous = await control.getActiveSession()
       const next = await control.resetSession()
+      await closeSession(previous)
       await ctx.reply(
         `🔄 Started fresh conversation session (<code>${next.sessionId.slice(0, 8)}</code>). Agent files and memory preserved.`,
         { parse_mode: 'HTML' },
@@ -1123,7 +1239,9 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         await ctx.reply(id ? `Incoming batch ${id} queued for retry.` : 'No failed incoming batch to retry.')
       } else if (action === 'new') {
         await control.aiState(aiMenu.initial)
+        const previous = await control.getActiveSession()
         const next = await control.resetSession()
+        await closeSession(previous)
         await ctx.answerCallbackQuery({ text: 'New session started' })
         await ctx.reply(
           `🔄 Started fresh conversation session (<code>${next.sessionId.slice(0, 8)}</code>).`,
@@ -1165,11 +1283,90 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   })
   }
 
+  // Watch runs a previous relay handed off until they finish, with the normal
+  // receipts. Never relaunch; existing loops still revoke and cancel them. An
+  // unknown outcome is recorded interrupted, which holds its schedule.
+  const adoptHandoff = async (): Promise<void> => {
+    const handed = await takeRunHandoff(config.controlDir)
+    if (!hostTransport) { if (handed.length) console.error('Ignoring run handoff without host transport', handed.length); return }
+    // Admit every record before the first attach, so no trigger races a hold.
+    const admitted = (await Promise.all(handed.map(run => runs.adopt(run).catch(() => null)))).filter((run): run is RunRecord => run !== null)
+    for (const run of admitted) await withStartLock(async () => {
+      let child: ChildProcess
+      try {
+        // The foreground lane is serial; a second foreground handoff is corrupt.
+        if (!run.scheduled && activeChild) throw new Error('A second handed-off foreground run was cancelled; its outcome is unknown')
+        child = await attachHostJob(config.controlDir, run.id)
+      } catch (error) {
+        // Never leave an unobserved executor: ask the host to stop it.
+        await mkdir(join(config.controlDir, 'host-executor'), { recursive: true, mode: 0o700 })
+          .then(() => writeFile(join(config.controlDir, 'host-executor', run.id + '.cancel'), '', { mode: 0o600 })).catch(() => {})
+        await runs.patch(run.id, { status: 'failed', endedAt: new Date().toISOString(), interrupted: true, failureReason: 'handoff-outcome-unknown', failure: await failureEvidence(config.controlDir, safeError(error)) })
+        return
+      }
+      // Listen before any await so a fast exit cannot be missed.
+      const closed = new Promise<number | null>(resolve => child.once('close', resolve))
+      let errorTail = '', outputTail = '', timedOut = false
+      child.stdout?.setEncoding('utf8').on('data', (chunk: string) => { if (run.script) outputTail = (outputTail + chunk).slice(-16384) })
+      child.stderr?.setEncoding('utf8').on('data', (chunk: string) => {
+        errorTail = (errorTail + chunk).slice(-16384)
+        if (run.script) outputTail = (outputTail + chunk).slice(-16384)
+      })
+      if (run.scheduled) background.set(run.id, child)
+      else activeChild = child
+      childRuns.set(child, run.id)
+      await runs.patch(run.id, { pid: child.pid })
+      console.info('run adopted', { run_id: run.id, pid: child.pid })
+      // A script keeps its registered bound from its original start.
+      const limit = run.script ? await new Scripts(config.controlDir).get(run.script.id).then(script => script.timeoutSeconds, () => DEFAULT_SCRIPT_TIMEOUT_SECONDS) : 0
+      const timer = limit ? setTimeout(() => { timedOut = true; terminateJob(child) }, Math.max(0, Date.parse(run.startedAt ?? run.createdAt) + limit * 1000 - Date.now())) : undefined
+      const completion = closed.then(code => withStartLock(async () => {
+        clearTimeout(timer)
+        if (run.scheduled) background.delete(run.id)
+        else if (activeChild === child) activeChild = null
+        if (handedOff.has(child)) return
+        const cancelled = !timedOut && (ownerStopped.has(child) || Boolean(run.scheduled && await scheduler.cancelled(run.id)))
+        const failed = !cancelled && code !== 0
+        const status = cancelled ? 'cancelled' : failed ? 'failed' : 'completed'
+        const unknown = errorTail.includes('outcome is unknown'), transport = errorTail.includes('Host executor client interrupted by')
+        const failureReason = timedOut ? 'script-timeout' : unknown ? 'handoff-outcome-unknown' : transport ? 'host-executor-transport-interrupted'
+          : errorTail.includes('Host CLI executor is offline') ? 'host-executor-offline' : 'executor-exit'
+        if (code === 0 && run.execution && !run.external && !run.taskId && !run.scheduled) await control.markSessionStarted(run.execution.sessionId)
+        const at = new Date().toISOString(), last = run.attempts?.at(-1)
+        await runs.patch(run.id, { status, endedAt: at, exitCode: code,
+          ...(last?.outcome === 'running' ? { attempts: [...run.attempts!.slice(0, -1), { ...last, outcome: status, exitCode: code, endedAt: at }] } : {}),
+          ...(run.script ? { output: redactFailure(safeError(outputTail)), ...(timedOut ? { timedOut } : {}) } : {}),
+          ...(failed ? { failureReason, interrupted: unknown || transport, failure: await failureEvidence(config.controlDir, safeError(errorTail || `Executor exited with ${code === null ? 'a signal' : `code ${code}`}`)) } : {}) })
+        await releaseExternal(run)
+        console.info('run ended', { run_id: run.id, code, adopted: true })
+      })).then(async () => {
+        const next = await runs.nextQueued()
+        if (next && !shuttingDown) await startJob(next)
+      }).catch(error => console.error('Adopted run completion failed', safeError(error)))
+      completions.add(completion)
+      void completion.finally(() => completions.delete(completion))
+    }).catch(error => console.error('Run adoption failed', run.id, safeError(error)))
+  }
+
   let stopWork: Promise<void> | undefined
   const stop = (): Promise<void> => stopWork ?? (stopWork = (async () => {
     shuttingDown = true
     runtimeStarted = false
     pollingAbort.abort()
+    // Hand off running host work before any wait can outlast the stop grace
+    // period. The lock lets an in-flight launch register; later ones see shutdown.
+    if (hostTransport) await withStartLock(async () => {
+      const handoff = new Map<ChildProcess, RunRecord>()
+      for (const child of [...(activeChild ? [activeChild] : []), ...background.values()]) {
+        const run = childRuns.has(child) ? await runs.get(childRuns.get(child)!) : null
+        if (run?.status === 'running' && !ownerStopped.has(child) && child.exitCode === null && child.signalCode === null) handoff.set(child, run)
+      }
+      if (!handoff.size) return
+      try { await saveRunHandoff(config.controlDir, [...handoff.values()]) }
+      catch (error) { console.error('Run handoff failed; stopping host work', safeError(error)); return }
+      // SIGKILL leaves no cancel marker, so the host keeps each executor running.
+      for (const child of handoff.keys()) { handedOff.add(child); child.kill('SIGKILL') }
+    })
     await deliveryServer?.stop().catch(() => {})
     deliveryServer = null
     await applicationChannel.stop()
@@ -1181,8 +1378,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     await Promise.all([sourceWork, intakeWork].map(work => work?.catch(() => {})))
     // Finish registering in-flight launches before taking the child snapshot.
     await withStartLock(async () => {
-      if (activeChild) terminateJob(activeChild)
-      for (const child of background.values()) terminateJob(child)
+      for (const child of [...(activeChild ? [activeChild] : []), ...background.values()]) if (!handedOff.has(child)) terminateJob(child)
       if (activeTypingTimer) clearInterval(activeTypingTimer)
     })
     await Promise.all(completions)
@@ -1208,11 +1404,13 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       deliveryServer = await serveDeliverySocket(config.controlDir, handleDeliveryOp, {
         ...(Number.isSafeInteger(deliveryTcpPort) && deliveryTcpPort >= 1024 && deliveryTcpPort <= 65535 ? { tcpPort: deliveryTcpPort } : {}),
       })
+      // Reconcile, then adopt handed-off runs, before any intake can launch work.
+      await scheduler.recover(runs)
+      await adoptHandoff()
       if (config.applicationPort) await applicationChannel.listen(config.applicationPort, config.applicationHost)
       runtimeStarted = true
       const owner = (await control.status()).owner
       if (telegramEnabled && telegramOwner(owner) && !config.channelBackendUrl) await telegramSource!.start(owner!)
-      await scheduler.recover(runs)
       sourceTimer = setInterval(() => {
         void drainSources().catch(error => console.error('Event-source drain failed', safeError(error)))
       }, 1000)
@@ -1286,7 +1484,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       }
     }
   }
-  return { bot: bot!, telegramEnabled, isRunning: () => telegramEnabled ? Boolean(bot?.isRunning()) : runtimeStarted, start, stop, drainOutbox, drainInbox, drainSources, drainTaskRequests, applicationChannel }
+  return { bot: bot!, telegramEnabled, isRunning: () => telegramEnabled ? Boolean(bot?.isRunning()) : runtimeStarted, start, stop, drainOutbox, drainInbox, drainSources, drainTaskRequests, adoptHandoff, applicationChannel }
 }
 
 if (process.argv[1] && path.resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {

package/src/menu.ts

@@ -3,8 +3,8 @@ import { readFile } from 'node:fs/promises'
 import path from 'node:path'
 import { randomBytes } from 'node:crypto'
 import { InlineKeyboard, type Context } from 'grammy'
-import { ControlStore, type ControlGuard } from './control-state.js'
-import { chatPreset, installed, persistedPreset, presetLabel, presetProvider, readModels, validateSelection, type AiPreset, type ModelChoice } from './ai.js'
+import { ControlStore, type ControlGuard, type SessionState } from './control-state.js'
+import { chatPreset, installed, persistedPreset, presetLabel, presetProvider, readModels, sameChoice, sameEngine, validateSelection, type AiPreset, type ModelChoice } from './ai.js'
 import { discoverDefaults } from './client-defaults.js'
 import { claudeConfigHome } from './executor.js'
 
@@ -25,13 +25,13 @@ export const mainKeyboard = () => new InlineKeyboard()
 const clientLabel = (cli: string) => cli === 'codex-gui' ? 'codex-gui (desktop)' : cli
 
 const matchesModel = (preset: AiPreset, model: ModelChoice) =>
-  model.cli === preset.cli && model.provider === preset.provider && (preset.model === undefined || model.model === preset.model) &&
+  sameEngine(model, preset) && model.provider === preset.provider && (preset.model === undefined || model.model === preset.model) &&
   (preset.effort === undefined || model.efforts.includes(preset.effort))
 
 // Short-lived opaque button IDs: no model names or executable arguments from callbacks.
 // These are operational settings, not a second conversational/agent loop.
 export const createAiMenu = (control: ControlStore, cli: string, catalog = readModels, workspace = process.cwd(), codexHome?: string,
-  isInstalled = installed, opencodeDataHome?: string) => {
+  isInstalled = installed, opencodeDataHome?: string, closeSession?: (session: SessionState | null) => Promise<void>) => {
   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'))
@@ -66,8 +66,9 @@ export const createAiMenu = (control: ControlStore, cli: string, catalog = readM
     const state = (await control.status()).ai
     if (!state) throw new Error('AI settings not initialized')
     const current = state.presets.find((p) => p.id === state.selectedId)!
-    const fresh = current.cli !== preset.cli || presetProvider(current) !== presetProvider(preset) || Boolean(session && !session.cli)
+    const fresh = !sameEngine(current, preset) || presetProvider(current) !== presetProvider(preset) || Boolean(session && !session.cli)
     if (!await control.selectPreset(preset.id, expectedSession, fresh, guard)) throw new Error('AI binding changed. Refresh available AIs before trying again.')
+    if (fresh) await closeSession?.(session)
     return { preset, fresh }
   }
   const choose = async (ctx: Context, preset: AiPreset) => {
@@ -127,9 +128,9 @@ export const createAiMenu = (control: ControlStore, cli: string, catalog = readM
     const state = (await control.status()).ai
     if (!state) throw new Error('AI settings not initialized')
     const candidate: AiPreset = { id: randomBytes(8).toString('hex'),
-      name: `${model.name}${effort ? ` · ${effort}` : ''}`.slice(0, 80), cli: model.cli, provider:model.provider, model: model.model, effort }
+      name: `${model.name}${effort ? ` · ${effort}` : ''}`.slice(0, 80), cli: model.cli, provider:model.provider, ...(model.authProfile ? {authProfile:model.authProfile} : {}), model: model.model, effort }
     const stored = persistedPreset(candidate)
-    const existing = state.presets.find((preset) => preset.cli === stored.cli && preset.provider === stored.provider && preset.model === stored.model && preset.effort === stored.effort)
+    const existing = state.presets.find((preset) => sameChoice(preset, stored))
     const preset = existing ?? candidate
     await validateSelection(preset, await catalog(), host ? async name => (await catalog()).some(model => model.cli === name) : isInstalled)
     // Private scopes persist their selection on the session, not the owner menu.