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

package/src/host-executor.ts

@@ -3,7 +3,7 @@ import { Tasks } from './tasks.js'
 import { ControlStore } from './control-state.js'
 import { authorizeRun, readRun } from './delivery-socket.js'
 import { runPromptSuffix } from './prompt-suffix.js'
-import { mkdir, readFile, writeFile, readdir, rename, rm, appendFile, realpath } from 'node:fs/promises'
+import { mkdir, readFile, writeFile, readdir, rename, rm, appendFile, realpath, utimes, stat } from 'node:fs/promises'
 import path from 'node:path'
 import { isHostRunId } from './host-executor-protocol.js'
 import { fileURLToPath } from 'node:url'
@@ -42,13 +42,16 @@ export const refreshAgentCatalog = async (agent: HostBinding,
 const processStart = async (pid:number) => (await processSnapshot()).get(pid)?.birth
 
 export const serveHostExecutor = async (installation: HostInstallation, signal: AbortSignal, launch = startExecutorJob,
-  readCatalog?: (agent: HostBinding) => Promise<ModelChoice[]>) => {
+  readCatalog?: (agent: HostBinding) => Promise<ModelChoice[]>, retire?: AbortSignal) => {
   if (installation.isolation !== undefined) parseIsolationClass(installation.isolation)
-  if (installation.isolation === 'isolated') throw new Error('Isolated agents run the native CLI in the relay; do not start host transport')
+  if (installation.isolation === 'isolated' && process.env.EZ_CONTAINER_EXECUTOR !== '1') throw new Error('Isolated agents run the native CLI in the relay; do not start host transport')
   resolveExecutor(installation.cli)
   if (new Set(installation.agents.map(a=>a.workspace)).size !== installation.agents.length ||
       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 containerId = process.env.EZ_CONTAINER_EXECUTOR === '1' ? process.env.HOSTNAME : undefined
+  const hostStarted = await processStart(process.pid)
+  let retiring = false
   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>()
@@ -74,9 +77,29 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
   const freshCatalog = readCatalog ?? catalog
   const beat = async (agent: HostBinding) => {
     const directory = path.join(agent.controlDir, 'host-executor')
-    await writeFile(path.join(directory, 'heartbeat.tmp'), JSON.stringify({ at: Date.now(), pid: process.pid, version: packageVersion, platform: process.platform, arch: process.arch, plugins: await installedPluginVersions(agent.toolsHome) }), { mode: 0o600 })
+    await writeFile(path.join(directory, 'heartbeat.tmp'), JSON.stringify({ at: Date.now(), pid: process.pid, version: packageVersion, platform: process.platform, arch: process.arch, ...(process.env.EZ_CONTAINER_EXECUTOR === '1' ? {containerExecutor:true,containerId} : {}), plugins: await installedPluginVersions(agent.toolsHome) }), { mode: 0o600 })
     await rename(path.join(directory, 'heartbeat.tmp'), path.join(directory, 'heartbeat.json'))
   }
+  const recoverClaims = async (agent: HostBinding) => {
+    const directory=path.join(agent.controlDir,'host-executor')
+    for (const file of await readdir(directory)) if (file.endsWith('.running.json') && isHostRunId(file.slice(0,-13))) {
+      const base=path.join(directory,file.slice(0,-13))
+      if (claimed.has(base)) continue
+      let prior: {pid?:number;started?:string;hostPid?:number;hostStarted?:string;containerId?:string} | undefined
+      try { prior=JSON.parse(await readFile(base+'.process.json','utf8')) } catch(error) { if ((error as NodeJS.ErrnoException).code!=='ENOENT') throw error }
+      if(prior?.containerId && prior.containerId!==containerId){
+        const touched=await stat(base+'.events').then(s=>s.mtimeMs,()=>0)
+        if(Date.now()-touched<15000)continue
+      }
+      if (!prior?.containerId && prior?.hostPid && prior.hostStarted && await processStart(prior.hostPid)===prior.hostStarted) continue
+      if (!prior?.containerId && prior?.pid && await processStart(prior.pid)) {
+        if (!prior.hostPid) throw Error('Previous host CLI is still running; stop it before recovery')
+        if (prior.started && await processStart(prior.pid)===prior.started) terminateJob({pid:prior.pid,exitCode:null,signalCode:null} as ChildProcess)
+      }
+      await appendFile(base+'.events',JSON.stringify({stream:'exit',code:1})+'\n',{mode:0o600})
+      await rm(base+'.process.json',{force:true});await rm(base+'.running.json',{force:true})
+    }
+  }
   try {
     for (const agent of installation.agents) {
       if (![agent.workspace,agent.controlDir,agent.binDir].every(path.isAbsolute)) throw new Error('Host bindings require absolute paths')
@@ -89,7 +112,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
         if (!Array.isArray(agent.additionalWorkspaces) || agent.additionalWorkspaces.some(workspace=>typeof workspace!=='string' || !path.isAbsolute(workspace))) throw new Error('Additional workspaces require absolute paths')
         additionalWorkspaces.set(agent,await Promise.all(agent.additionalWorkspaces.map(workspace=>realpath(workspace))))
       }
-      if (agent.toolsHome) {
+      if (agent.toolsHome && !containerId) {
         if (!path.isAbsolute(agent.toolsHome)) throw new Error('Plugin registry binding requires an absolute path')
         const config=JSON.parse(await readFile(path.join(agent.toolsHome,'config.json'),'utf8'))
         if (config.schemaVersion!==1 || config.workspace!==await realpath(agent.workspace)) throw new Error('Plugin registry belongs to another workspace')
@@ -99,6 +122,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
       const lock=path.join(directory,'worker.lock')
       try {
         const prior=JSON.parse(await readFile(lock,'utf8'))
+        if(prior.containerId&&prior.containerId!==containerId)throw Error('Previous isolated worker still owns the claim lock')
         const currentStart=await processStart(prior.pid)
         if (!prior.started || !currentStart || prior.started===currentStart) {
           try { process.kill(prior.pid,0); throw new Error('Host executor already running') }
@@ -107,34 +131,29 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
         await rm(lock)
       }
       catch(error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }
-      await writeFile(lock,JSON.stringify({pid:process.pid,started:await processStart(process.pid)}),{mode:0o600,flag:'wx'})
+      await writeFile(lock,JSON.stringify({pid:process.pid,started:await processStart(process.pid),...(containerId ? {containerId} : {})}),{mode:0o600,flag:'wx'})
       locks.push(lock)
       const models = await freshCatalog(agent)
       await new ControlStore(agent.controlDir, 900000).normalizeProviderBindings(models)
       const modelsFile=path.join(directory,'models.json')
       await writeFile(modelsFile+'.tmp',JSON.stringify(models),{mode:0o600});await rename(modelsFile+'.tmp',modelsFile)
-      // A host crash is terminal for a claimed job. Never replay an action.
-      for (const file of await readdir(directory)) if (file.endsWith('.running.json')) {
-        const base=path.join(directory,file.slice(0,-13))
-        try {
-          const prior=JSON.parse(await readFile(base+'.process.json','utf8'))
-          try { process.kill(prior.pid,0); throw new Error('Previous host CLI is still running; stop it before recovery') }
-          catch(error) { if ((error as NodeJS.ErrnoException).code !== 'ESRCH') throw error }
-        } catch(error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }
-        await rm(base+'.process.json',{force:true})
-        await appendFile(base+'.events',JSON.stringify({stream:'exit',code:1})+'\n',{mode:0o600})
-        await rm(path.join(directory,file))
-      }
-      if (agent.toolsHome) await (await import('./plugins/workspace-lease.mjs')).recoverNativeLease(agent.toolsHome)
+      await recoverClaims(agent)
+      if (agent.toolsHome && !containerId) await (await import('./plugins/workspace-lease.mjs')).recoverNativeLease(agent.toolsHome)
     }
     let catalogAt=Date.now()
     const catalogSeen=new Map<HostBinding,string>()
     while (!signal.aborted) {
       const parent=Number(process.env.EZ_HOST_SUPERVISOR_PID)
-      if(parent) { try { process.kill(parent,0) } catch { break } }
+      if(parent && !retiring) { try { process.kill(parent,0) } catch { break } }
+      if (retire?.aborted && !retiring) {
+        retiring=true
+        await catalogRefresh
+        for (const lock of locks.splice(0)) await rm(lock,{force:true})
+      }
+      if (retiring && !tasks.size) break
       // Keep transport liveness independent of native catalog I/O.
-      for (const agent of installation.agents) await beat(agent)
-      if(!catalogRefresh && Date.now()-catalogAt>30000){
+      if (!retiring) for (const agent of installation.agents) await beat(agent)
+      if(!retiring && !catalogRefresh && Date.now()-catalogAt>30000){
         catalogAt=Date.now()
         catalogRefresh=(async()=>{
           for(const agent of installation.agents){
@@ -149,6 +168,8 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
       }
       for (const agent of installation.agents) {
         const directory=path.join(agent.controlDir,'host-executor')
+        if (retiring) continue
+        await recoverClaims(agent)
         for (const file of await readdir(directory)) {
           if (!file.endsWith('.request.json') || !isHostRunId(file.slice(0,-13))) continue
           const id=file.slice(0,-13)
@@ -168,9 +189,9 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
           let workspace = activeWorkspaces.get(agent)
           if (!scheduled && workspace && [...workspace.lanes.values()].includes(false)) continue
           if (!workspace) {
-            const release = agent.toolsHome
+            const release = agent.toolsHome && !containerId
               ? await (await import('./plugins/workspace-lease.mjs')).workspaceLease(agent.toolsHome,{kind:'native',runId:id}) : undefined
-            if (agent.toolsHome && !release) continue
+            if (agent.toolsHome && !containerId && !release) continue
             workspace = { lanes: new Map(), release }
             activeWorkspaces.set(agent, workspace)
           }
@@ -184,7 +205,11 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               await workspace.release?.()
             }
           }
-          try { await rename(base+'.request.json',base+'.running.json') }
+          try {
+            await writeFile(base+'.process.json',JSON.stringify({hostPid:process.pid,hostStarted,...(containerId ? {containerId} : {})}),{mode:0o600})
+            await appendFile(base+'.events','',{mode:0o600})
+            await rename(base+'.request.json',base+'.running.json')
+          }
           catch (error) { claimed.delete(base); await releaseWorkspace(); throw error }
           const task=(async()=>{
             let job: Awaited<ReturnType<typeof startExecutorJob>> | undefined
@@ -205,7 +230,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               // 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),
+                const options:ExecutorOptions={catalogTransport:containerId?'local':'host',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)
@@ -237,14 +262,18 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
                 // 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,
+                const options:ExecutorOptions={catalogTransport:containerId?'local':'host',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)
               }
               active.set(base,job.child)
-              await writeFile(base+'.process.json',JSON.stringify({pid:job.child.pid}),{mode:0o600})
+              // Observe completion before process metadata I/O: a fast CLI may
+              // already have exited when launch returns, or while that I/O waits.
+              const closed=job.child.exitCode!==null||job.child.signalCode!==null
+                ? Promise.resolve(job.child.exitCode??1)
+                : new Promise<number>(resolve=>job!.child.once('close',code=>resolve(code??1)))
               if(signal.aborted)terminateJob(job.child)
               // Scheduled Claude streams every event; forward only the startup summary.
               const startup = observeClaude ? startupObserver() : undefined
@@ -255,8 +284,9 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
                 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)))
+              await writeFile(base+'.process.json',JSON.stringify({pid:job.child.pid,started:job.child.pid ? await processStart(job.child.pid) : undefined,hostPid:process.pid,hostStarted,...(containerId ? {containerId} : {})}),{mode:0o600})
+              cancellation=setInterval(()=>{void readFile(base+'.cancel').then(()=>terminateJob(job!.child)).catch(()=>{}); const now=new Date();void utimes(base+'.events',now,now).catch(()=>{})},250)
+              const code=await closed
               if (cancellation) clearInterval(cancellation)
               await job.cleanup()
               job = undefined
@@ -290,8 +320,9 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
 }
 
 if (process.argv[1] && path.resolve(process.argv[1])===fileURLToPath(import.meta.url)) {
-  const abort=new AbortController()
+  const abort=new AbortController(),retire=new AbortController()
+  process.once('SIGUSR2',()=>retire.abort())
   for(const signal of ['SIGTERM','SIGINT'] as const)process.once(signal,()=>abort.abort())
   const config=JSON.parse(await readFile(process.argv[2],'utf8'))
-  await serveHostExecutor(config,abort.signal)
+  await serveHostExecutor(config,abort.signal,undefined,undefined,retire.signal)
 }

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,12 +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 { CliUnavailableError, startExecutorJob, terminateJob, opencodeDataHome, claudeConfigHome } from './executor.js'
-import { advances, nextSetup, quotaScope, setupCandidates, startupObserver, unavailableSummary, SetupsUnavailableError, type SetupAttempt } from './setup-fallback.js'
+import { CliUnavailableError, startExecutorJob, attachHostJob, terminateJob, opencodeDataHome, claudeConfigHome, usesFileTransport } 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'
@@ -38,6 +38,7 @@ 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, type AiPreset } from './ai.js'
 import { discoverDefaults } from './client-defaults.js'
@@ -77,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 = async () => !config.channelBackendUrl && await usesFileTransport(config.controlDir)
+  const childRuns = new WeakMap<ChildProcess, string>()
+  const handedOff = new WeakSet<ChildProcess>()
   let activeChild: ChildProcess | null = null
   let runtimeStarted = false
   let shuttingDown = false
@@ -114,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))
@@ -178,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)) {
@@ -280,8 +296,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         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.
+        // 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
@@ -297,16 +313,18 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           await runs.patch(run.id, { attempts })
           return preset
         }
-        // Each attempt is a fresh native session; a rejected Claude attempt already claimed its ID.
+        // 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', startedAt: new Date().toISOString() }]
+              attempts = [...attempts, { preset, quotaScope: quotaScope(preset), outcome: 'running', sessionId, startedAt: new Date().toISOString() }]
               await runs.patch(run.id, { attempts })
             }
             try {
-              return { ...await launch(texts, script ? {
+              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 },
@@ -371,6 +389,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             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)
@@ -413,6 +432,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
               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'
@@ -421,11 +442,10 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
                   // 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 } : {}) })
+                    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 = failed && !interrupted && advances(rejected)
+                    eligible = continues && !interrupted
                   }
                   if (!eligible) await finalize(code, cancelled, failed)
                 } catch (error) {
@@ -648,8 +668,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   }
 
   let outboxWork: Promise<void> | undefined
-  const drainOutbox = (onlyRunId?: string): Promise<void> => {
-    if (shuttingDown) return outboxWork ?? Promise.resolve()
+  const drainOutbox = (onlyRunId?: string, stopping = false): Promise<void> => {
+    if (shuttingDown && !stopping) return outboxWork ?? Promise.resolve()
     return outboxWork ?? (outboxWork = (async () => {
       for (const item of await runs.pendingOutbox()) {
         if (onlyRunId && item.runId !== onlyRunId) continue
@@ -753,6 +773,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   // children, host executor, CLIs) enqueue and query the memory ledger
   // through the shared handler in delivery-socket.ts. The pump below stays
   // the single delivery executor; the socket only admits work into it.
+  let drainingHandoff=false
   let deliveryServer: { socketPath: string; stop: () => Promise<void> } | null = null
   const handleDeliveryOp = createLedgerHandler(config.controlDir, {
     wake: () => { void drainOutbox() },
@@ -815,7 +836,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     const owner = (await control.status()).owner
     if (!owner) return 'Scheduled tasks\n\nNo paired owner.'
     // This intentionally uses the reader that does not create a schedules directory.
-    const active = await scheduler.listActiveReadOnly(await runs.list())
+    const active = await scheduler.listTasksReadOnly(await runs.list())
     return { owner, active, text: scheduledTasksText(active, owner) }
   }
   const replyScheduledTasks = async (ctx: Context, number?: number) => {
@@ -872,6 +893,18 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         : []),
     ].join('\n')
   }
+  const stopActiveWork = async (): Promise<boolean> => {
+    const children: [string | undefined, ChildProcess][] = [...background]
+    if (activeChild) children.unshift([undefined, activeChild])
+    let requested = true
+    for (const [id, child] of children) {
+      if (!await terminateJob(child)) { requested = false; continue }
+      ownerStopped.add(child)
+      if (id) await scheduler.cancel(id)
+    }
+    return requested
+  }
+
   const cancelPending = async () => {
     let count = 0
     await withStartLock(async () => {
@@ -1010,16 +1043,15 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
     if (text === '/stop') {
       const running = await runs.running(false)
       if ((running && running.pid) || background.size) {
-        try {
-          if (activeChild) { ownerStopped.add(activeChild); terminateJob(activeChild) }
-          for (const [id,child] of background) { await scheduler.cancel(id); ownerStopped.add(child); terminateJob(child) }
-        } catch {}
-        if (activeTypingTimer) {
+        let requested = false
+        try { requested = await stopActiveWork() } catch {}
+        if (requested && activeTypingTimer) {
           clearInterval(activeTypingTimer)
           activeTypingTimer = null
         }
         await ctx.reply(
-          '🛑 Stop requested for active work. Queued work remains and will run next. /cancel clears it.',
+          requested ? '🛑 Stop requested for active work. Queued work remains and will run next. /cancel clears it.'
+            : 'A stop request failed; some work remains active.',
         )
       } else {
         await ctx.reply('No active run in progress.')
@@ -1029,7 +1061,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' },
@@ -1217,7 +1251,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>).`,
@@ -1238,11 +1274,12 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       } else if (action === 'stop') {
         const running = await runs.running(false)
         if ((running && running.pid) || background.size) {
-          if (activeChild) { ownerStopped.add(activeChild); terminateJob(activeChild) }
-          for (const [id,child] of background) { await scheduler.cancel(id); ownerStopped.add(child); terminateJob(child) }
-          await ctx.answerCallbackQuery({ text: 'Run stopped' })
+          let requested = false
+          try { requested = await stopActiveWork() } catch {}
+          await ctx.answerCallbackQuery({ text: requested ? 'Stop requested' : 'Stop request failed' })
           await ctx.reply(
-            '🛑 Stop requested for active work. Queued work remains and will run next. /cancel clears it.',
+            requested ? '🛑 Stop requested for active work. Queued work remains and will run next. /cancel clears it.'
+              : 'A stop request failed; some work remains active.',
           )
         } else {
           await ctx.answerCallbackQuery({ text: 'No run active' })
@@ -1259,12 +1296,95 @@ 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 (!await 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()
-    await deliveryServer?.stop().catch(() => {})
+    let handedRecords:RunRecord[]=[]
+    // 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 (await 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 { handedRecords=[...handoff.values()];await saveRunHandoff(config.controlDir, handedRecords) }
+      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') }
+    })
+    drainingHandoff=handedRecords.length>0
+    if(deliveryServer)await deliveryServer.stop()
+    else if(drainingHandoff){await outboxWork?.catch(() => {});await drainOutbox(undefined,true)}
+    if(handedRecords.length)await saveRunHandoff(config.controlDir,handedRecords)
     deliveryServer = null
     await applicationChannel.stop()
     wakePollRetry?.()
@@ -1275,8 +1395,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)
@@ -1300,13 +1419,16 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         throw new Error(`Another relay owns ${config.controlDir}; stop it before starting a second one`)
       const deliveryTcpPort = Number(process.env.EZ_DELIVERY_TCP_PORT ?? '')
       deliveryServer = await serveDeliverySocket(config.controlDir, handleDeliveryOp, {
+        beforeClose:async()=>{if(drainingHandoff){await outboxWork?.catch(()=>{});await drainOutbox(undefined,true)}},
         ...(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)
@@ -1380,7 +1502,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,7 +3,7 @@ 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 { 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'
@@ -31,7 +31,7 @@ const matchesModel = (preset: AiPreset, model: ModelChoice) =>
 // 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'))
@@ -68,6 +68,7 @@ export const createAiMenu = (control: ControlStore, cli: string, catalog = readM
     const current = state.presets.find((p) => p.id === state.selectedId)!
     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) => {