@jc_stack/ez-agents 0.1.0-beta.52 → 0.1.0-beta.58

package/src/control-state.ts

@@ -2,8 +2,9 @@ import { assertEffort } from './model-policy.js'
 import { createHash, randomBytes, timingSafeEqual } from 'node:crypto'
 import { mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { isPreset, persistedPreset, presetProvider, sameEngine, type AiPreset, type ExecutionChoice, type ModelChoice } from './ai.js'
+import { isPreset, persistedPreset, presetProvider, resolveFallbacks, sameEngine, type AiPreset, type ExecutionChoice, type ModelChoice } from './ai.js'
 import { isAuthProfile } from './auth-profile.js'
+import { quotaScope, quotaBlockedUntil, quotaCategory, validSetupHealth, type SetupAttempt, type SetupHealth } from './setup-fallback.js'
 
 export type Owner = {
   id?: string
@@ -55,6 +56,10 @@ type ApplicationPairingRequest = {
 
 export type PairingRequest = TelegramPairingRequest | ApplicationPairingRequest
 
+// A fallback login's own native conversation beside a conversation's engine.
+export type LinkedSession = { cli: string; authProfile?: string; sessionId: string; nativeSessionId?: string; hasStarted: boolean }
+type Engine = { cli: string; authProfile?: string }
+
 export type SessionState = {
   sessionId: string
   hasStarted: boolean
@@ -67,6 +72,8 @@ export type SessionState = {
   preset?: AiPreset
   applicationScope?: string
   telegramShared?: boolean
+  // One native session per other engine that served this conversation.
+  linked?: LinkedSession[]
 }
 
 export type ControlGuard = { owner: Owner; authorize: () => Promise<unknown>; expectedSession?: string | null; applicationScope?: string }
@@ -76,8 +83,12 @@ type ControlState = {
   owner: Owner | null
   pending: PairingRequest[]
   activeSession?: SessionState | null
-  ai?: { presets: AiPreset[]; defaultId: string; selectedId: string; recentIds?: string[] }
+  // fallbacks: the owner's ordered chat/application chain after the selected AI.
+  ai?: { presets: AiPreset[]; defaultId: string; selectedId: string; recentIds?: string[]; fallbacks?: AiPreset[] }
   sessions?: SessionState[]
+  setupHealth?: SetupHealth
+  // Owner opt-in for per-attempt run telemetry; absent means off.
+  runTelemetry?: true
 }
 
 type Clock = () => number
@@ -133,17 +144,26 @@ const isState = (value: unknown): value is ControlState => {
     (s.applicationScope === undefined || /^[a-f0-9]{64}$/.test(s.applicationScope)) &&
     (s.telegramShared === undefined || typeof s.telegramShared === 'boolean') &&
     (s.authProfile === undefined || (isAuthProfile(s.authProfile) && s.cli !== undefined)) &&
-    (s.preset === undefined || (isPreset(s.preset) && sameEngine(s.preset, s)))
+    (s.preset === undefined || (isPreset(s.preset) && sameEngine(s.preset, s))) &&
+    (s.linked === undefined || (Array.isArray(s.linked) && s.linked.length <= 16 && s.linked.every((l, i) =>
+      l && typeof l.cli === 'string' && /^[a-z-]{1,20}$/.test(l.cli) && (l.authProfile === undefined || isAuthProfile(l.authProfile)) &&
+      /^[0-9a-f-]{36}$/i.test(l.sessionId) && typeof l.hasStarted === 'boolean' &&
+      (l.nativeSessionId === undefined || /^[a-zA-Z0-9_-]{1,160}$/.test(l.nativeSessionId)) &&
+      !sameEngine(l, s) && !s.linked!.slice(0, i).some(other => sameEngine(other, l)))))
   return (
     candidate.version === 1 &&
     Array.isArray(candidate.pending) &&
     candidate.pending.every(pairing) &&
     (candidate.owner === null || validOwner(candidate.owner)) &&
+    (candidate.setupHealth === undefined || validSetupHealth(candidate.setupHealth)) &&
     (candidate.ai === undefined || (Array.isArray(candidate.ai.presets) &&
       candidate.ai.presets.every(isPreset) &&
       candidate.ai.presets.some((p) => p.id === candidate.ai!.defaultId) &&
       candidate.ai.presets.some((p) => p.id === candidate.ai!.selectedId) &&
-      (candidate.ai.recentIds === undefined || isRecentIds(candidate.ai.recentIds)))) &&
+      (candidate.ai.recentIds === undefined || isRecentIds(candidate.ai.recentIds)) &&
+      (candidate.ai.fallbacks === undefined || (Array.isArray(candidate.ai.fallbacks) && candidate.ai.fallbacks.length > 0 &&
+        candidate.ai.fallbacks.length <= 12 && candidate.ai.fallbacks.every(isPreset))))) &&
+    (candidate.runTelemetry === undefined || candidate.runTelemetry === true) &&
     (candidate.sessions === undefined || (Array.isArray(candidate.sessions) && candidate.sessions.every(
       session))) &&
     (candidate.activeSession == null ||
@@ -156,6 +176,15 @@ export const sessionTitle = (session: SessionState): string =>
 
 const engineOf = (preset: AiPreset) => ({ cli: preset.cli, ...(preset.authProfile ? { authProfile: preset.authProfile } : {}) })
 
+// Queued work captures the chain with its primary choice; later edits do not change it.
+const withChain = (choice: ExecutionChoice, chain?: AiPreset[]): ExecutionChoice => {
+  const fallbacks = resolveFallbacks(choice.preset, chain)
+  return fallbacks ? { ...choice, fallbacks } : choice
+}
+
+// Clients that report their own native session ID; others use the Ez-assigned ID.
+const reportsNativeSession = (cli?: string) => ['codex', 'codex-gui', 'opencode'].includes(cli ?? '')
+
 const rememberPreset = (state: ControlState) => {
   const preset = state.ai?.presets.find(p => p.id === state.ai!.selectedId)
   if (state.activeSession && preset && sameEngine(state.activeSession, preset))
@@ -438,6 +467,7 @@ export class ControlStore {
       state.activeSession = null
       state.ai = undefined
       state.sessions = undefined
+      state.setupHealth = undefined
       await this.writeState(state)
       return hadOwner
     })
@@ -450,6 +480,63 @@ export class ControlStore {
     })
   }
 
+  async scheduledSetupHealth(owner: Owner): Promise<SetupHealth> {
+    return this.withLock(async () => {
+      const state = await this.readState()
+      if (!sameOwner(owner, state.owner)) throw new Error('Scheduled setup authority revoked')
+      return structuredClone(state.setupHealth ?? {})
+    })
+  }
+
+  // Native account outcomes belong to existing owner control state. They do not
+  // change chat defaults or task definitions. Unknown resets use bounded checks.
+  async recordSetupOutcome(owner: Owner, attempt: SetupAttempt): Promise<void> {
+    if (attempt.outcome !== 'completed' && !(quotaCategory(attempt.category) || attempt.category === 'login-unavailable')) return
+    if (!isPreset(attempt.preset)) throw new Error('Invalid scheduled setup')
+    await this.withLock(async () => {
+      const state = await this.readState()
+      if (!sameOwner(owner, state.owner)) throw new Error('Scheduled setup authority revoked')
+      state.setupHealth ??= {}
+      const scope = quotaScope(attempt.preset), health = state.setupHealth[scope] ??= {}, now = this.clock()
+      if (attempt.outcome === 'completed') {
+        health.lastSuccessAt = new Date(now).toISOString()
+        // An older concurrent run's success cannot erase a future quota reset.
+        if (!(quotaBlockedUntil(health) > now)) {
+          delete health.resetAt; delete health.retryAt; delete health.quotaFailures
+        }
+      } else {
+        delete health.lastSuccessAt
+        if (attempt.category !== 'login-unavailable') {
+          if (attempt.category?.startsWith('credits-required')) health.manualRetry = true
+          else if (Date.parse(attempt.resetAt ?? '') > now) {
+            if (Date.parse(attempt.resetAt!) > (Date.parse(health.resetAt ?? '') || 0)) health.resetAt = new Date(attempt.resetAt!).toISOString()
+          } else if (!(quotaBlockedUntil(health) > now)) {
+            // A reset may pass during shutdown: probe once promptly, then back off.
+            // Concurrent rejections share one check rather than accelerating it.
+            const elapsedReset = Number.isFinite(Date.parse(attempt.resetAt ?? '')) && health.quotaFailures === undefined
+            health.quotaFailures = elapsedReset ? 0 : Math.min(4, (health.quotaFailures ?? 0) + 1)
+            const delay = elapsedReset ? 1000 : [5, 15, 30, 60][health.quotaFailures - 1] * 60_000
+            health.retryAt = new Date(now + delay).toISOString()
+          }
+        }
+      }
+      if (!Object.keys(health).length) delete state.setupHealth[scope]
+      await this.writeState(state)
+    })
+  }
+
+  async clearQuotaWait(owner: Owner, scopes: string[]): Promise<void> {
+    await this.withLock(async () => {
+      const state = await this.readState()
+      if (!sameOwner(owner, state.owner)) throw new Error('Scheduled setup authority revoked')
+      for (const scope of scopes) {
+        const health = state.setupHealth?.[scope]
+        if (health) { delete health.resetAt; delete health.retryAt; delete health.quotaFailures; delete health.manualRetry }
+      }
+      await this.writeState(state)
+    })
+  }
+
   async ensureActiveSession(): Promise<SessionState> {
     return this.withLock(async () => {
       const state = await this.readState()
@@ -635,7 +722,7 @@ export class ControlStore {
         presetProvider(session.preset) !== presetProvider(settledPreset)) &&
       (!sameEngine(session, settledPreset) || JSON.stringify(session.preset) === JSON.stringify(settledPreset)) &&
       Boolean(session.title || session.hasStarted || !title?.trim()))
-      return { sessionId: session.sessionId, preset: settledPreset }
+      return withChain({ sessionId: session.sessionId, preset: settledPreset }, settledAi?.fallbacks)
     return this.withLock(async () => {
       const state = await this.readState()
       state.ai ??= { presets: [persistedPreset(initial)], defaultId: initial.id, selectedId: initial.id, recentIds: [] }
@@ -657,7 +744,7 @@ export class ControlStore {
       if (!state.activeSession.title && !state.activeSession.hasStarted && title?.trim())
         state.activeSession.title = title.replace(/\s+/g, ' ').trim().slice(0, 80)
       await this.writeState(state)
-      return { sessionId: state.activeSession.sessionId, preset }
+      return withChain({ sessionId: state.activeSession.sessionId, preset }, state.ai.fallbacks)
     })
   }
 
@@ -686,14 +773,14 @@ export class ControlStore {
         if (requested) previous.preset = requested
         activate(previous)
         if (shareTelegram || requested) await this.writeState(state)
-        return { sessionId: previous.sessionId, preset: previous.preset }
+        return withChain({ sessionId: previous.sessionId, preset: previous.preset }, state.ai.fallbacks)
       }
       const preset = requested ?? state.ai.presets.find(item => item.id === state.ai!.selectedId)!
       const session: SessionState = { sessionId: crypto.randomUUID(), hasStarted: false, ...engineOf(preset), preset, applicationScope: scope }
       state.sessions.push(session)
       activate(session)
       await this.writeState(state)
-      return { sessionId: session.sessionId, preset }
+      return withChain({ sessionId: session.sessionId, preset }, state.ai.fallbacks)
     })
   }
 
@@ -755,6 +842,84 @@ export class ControlStore {
     })
   }
 
+  // The native session an engine resumes for this conversation: the
+  // conversation's own for its engine, otherwise that login's linked session,
+  // created on first use. A session never resumes under another credential home.
+  async engineSession(sessionId: string, engine: Engine): Promise<{ sessionId: string; nativeSessionId?: string; hasStarted: boolean }> {
+    return this.withLock(async () => {
+      const state = await this.readState()
+      const session = this.conversation(state, sessionId)
+      if (sameEngine(session, engine)) return session
+      let linked = session.linked?.find(item => sameEngine(item, engine))
+      if (!linked) {
+        linked = { cli: engine.cli, ...(engine.authProfile ? { authProfile: engine.authProfile } : {}), sessionId: crypto.randomUUID(), hasStarted: false }
+        session.linked = [...session.linked ?? [], linked].slice(-16)
+        await this.writeState(state)
+      }
+      return linked
+    })
+  }
+
+  async saveEngineSession(sessionId: string, engine: Engine, nativeSessionId: string): Promise<void> {
+    if (!/^[a-zA-Z0-9_-]{1,160}$/.test(nativeSessionId)) throw new Error('Invalid native session ID')
+    await this.withLock(async () => {
+      const state = await this.readState()
+      const session = this.conversation(state, sessionId)
+      const target = sameEngine(session, engine) ? session : session.linked?.find(item => sameEngine(item, engine))
+      if (!target) throw new Error('Unknown conversation engine')
+      if (target.nativeSessionId && target.nativeSessionId !== nativeSessionId) throw new Error('Native session changed unexpectedly')
+      target.nativeSessionId = nativeSessionId
+      target.hasStarted = true
+      await this.writeState(state)
+    })
+  }
+
+  // After an ordered attempt: a session that began work resumes next time. A
+  // client that rejected an unstarted session may already have claimed its ID,
+  // so a client using Ez-assigned IDs gets a fresh one for its next attempt.
+  async settleEngineSession(sessionId: string, engine: Engine, started: boolean): Promise<void> {
+    await this.withLock(async () => {
+      const state = await this.readState()
+      const session = state.activeSession?.sessionId === sessionId ? state.activeSession : state.sessions?.find(s => s.sessionId === sessionId)
+      const target = !session ? undefined : sameEngine(session, engine) ? session : session.linked?.find(item => sameEngine(item, engine))
+      // Reporting clients start only through saveEngineSession.
+      if (!target || target.hasStarted || reportsNativeSession(target.cli)) return
+      if (started) target.hasStarted = true
+      else if (target === session) session.nativeSessionId = crypto.randomUUID()
+      else target.sessionId = crypto.randomUUID()
+      await this.writeState(state)
+    })
+  }
+
+  private conversation(state: ControlState, sessionId: string): SessionState {
+    const session = state.activeSession?.sessionId === sessionId ? state.activeSession : state.sessions?.find(s => s.sessionId === sessionId)
+    if (!session?.cli) throw new Error('Unknown conversation')
+    return session
+  }
+
+  // Applies to work queued afterwards; queued work keeps its captured chain.
+  async setChatFallbacks(chain: AiPreset[] | undefined): Promise<void> {
+    if (chain !== undefined && (!chain.length || chain.length > 12 || !chain.every(isPreset) ||
+      new Set(chain.map(p => p.id)).size !== chain.length)) throw new Error('Invalid fallback chain')
+    for (const preset of chain ?? []) assertEffort(preset.effort, preset.model, preset.cli)
+    await this.withLock(async () => {
+      const state = await this.readState()
+      if (!state.ai) throw new Error('AI settings not initialized')
+      if (chain) state.ai.fallbacks = chain.map(persistedPreset)
+      else delete state.ai.fallbacks
+      await this.writeState(state)
+    })
+  }
+
+  async setRunTelemetry(enabled: boolean): Promise<void> {
+    await this.withLock(async () => {
+      const state = await this.readState()
+      if (enabled) state.runTelemetry = true
+      else delete state.runTelemetry
+      await this.writeState(state)
+    })
+  }
+
   async savePreset(preset: AiPreset, guard?: ControlGuard): Promise<void> {
     if (!isPreset(preset)) throw new Error('Invalid AI preset')
     assertEffort(preset.effort, preset.model, preset.cli)

package/src/delivery-socket.ts

@@ -13,6 +13,7 @@ import { telegramOwner } from './control-state.js'
 import { Scheduler } from './scheduler.js'
 import {Tasks} from './tasks.js'
 import { runEvidence, type EvidenceOptions } from './run-evidence.js'
+import { runningWork } from './running-work.js'
 
 // Stateless pipe transport. The relay owns the runs/outbox ledger in process
 // memory; engine children, plugin children and the host executor reach it
@@ -34,6 +35,7 @@ export type DeliverySocketOp =
   | { op: 'status' }
   | { op: 'schedulePreflight'; payload?: Record<string, unknown> }
   | { op: 'triggerSchedule'; payload: { scheduleId: string; revision: string; key: string; callerRunId?: string } }
+  | { op: 'retryScheduleQuota'; payload: { runId?: string; callerRunId?: string } }
   | { op: 'enqueue'; payload: Record<string, unknown> }
   | { op: 'wait'; payload: { id: string; timeoutMs?: number } }
   | { op: 'get'; payload: { runId: string } }
@@ -45,6 +47,7 @@ export type DeliverySocketOp =
   | { op: 'history'; payload: { runId: string; limit?: number; messageId?: number } }
   | { op: 'deliveryStatus'; payload?: Record<string, never> }
   | { op: 'evidence'; payload: EvidenceOptions }
+  | { op: 'runningWork'; payload?: { callerRunId?: string } }
   | { op: 'approvalCheck'; payload: { actionId: string } }
   | { op: 'latestReply'; payload?: Record<string, never> }
 
@@ -255,6 +258,19 @@ export const createLedgerHandler = (controlDir: string, hooks: LedgerHooks): Del
         hooks.wake()
         return run
       }
+      case 'retryScheduleQuota': {
+        const { runId, callerRunId } = op.payload ?? {}
+        if (runId !== undefined && !nonEmptyString(runId)) throw new Error('Run ID is invalid')
+        if (callerRunId !== undefined) {
+          const caller = await requireOwnerExecution(controlDir, callerRunId)
+          if (caller.replyOnly || caller.script) throw new Error('Quota retry requires an active owner-authorized run')
+        }
+        const owner = await readOnlyOwner(controlDir)
+        if (!owner) throw new Error('Pair an owner before retrying')
+        const result = await new Scheduler(controlDir).retryQuota(owner, runs, runId)
+        hooks.wake()
+        return result
+      }
       case 'enqueue': {
         const envelope = (op.payload ?? {}) as Record<string, unknown>
         if (envelope.kind === 'owner') {
@@ -333,7 +349,7 @@ export const createLedgerHandler = (controlDir: string, hooks: LedgerHooks): Del
         if (typeof payload.runId !== 'string' || !payload.runId) throw new Error('Run ID is required')
         if (!payload.change || typeof payload.change !== 'object') throw new Error('Patch change is required')
         // Setup attempts select what the host admits; only the relay records them.
-        if ('attempts' in payload.change) throw new Error('Setup attempts are relay-owned')
+        if (['attempts', 'attemptRound', 'quotaWait', 'telemetry'].some(key => key in (payload.change as Record<string, unknown>))) throw new Error('Setup attempts, telemetry and quota admission are relay-owned')
         return runs.patch(payload.runId, payload.change as never)
       }
       case 'taskApplication': {
@@ -360,6 +376,7 @@ export const createLedgerHandler = (controlDir: string, hooks: LedgerHooks): Del
         })
       }
       case 'evidence': return runEvidence(controlDir, op.payload ?? {})
+      case 'runningWork': return runningWork(controlDir, op.payload ?? {})
       case 'deliveryStatus': return runs.deliveryStatus()
       case 'approvalCheck': {
         const actionId = (op.payload as { actionId?: unknown } | undefined)?.actionId

package/src/executor.ts

@@ -36,6 +36,10 @@ export type ExecutorOptions = {
   // Caller-owned routing flags. The core only spawns and streams.
   taskRun?: boolean
   nativeSession?: boolean
+  // Ordered setups and telemetry read structured client events; stdout is never chat.
+  structuredOutput?: boolean
+  // Owner-enabled run telemetry; Codex native sessions forward usage summaries.
+  telemetry?: boolean
   toolsHome?: string
   sharedWorkspace?: string
   additionalWorkspaces?: string[]
@@ -131,7 +135,7 @@ export type CliAdapter = {
   command: string
   description: string
   buildArgs: (
-    options: Pick<ExecutorOptions, 'workspace' | 'sessionId' | 'isResume' | 'model' | 'effort' | 'toolsHome' | 'sharedWorkspace' | 'additionalWorkspaces' | 'codexAutoCompactTokens' | 'codexSandbox' | 'codexProvider' | 'nativeSession'> & { controlDir?: string },
+    options: Pick<ExecutorOptions, 'workspace' | 'sessionId' | 'isResume' | 'model' | 'effort' | 'toolsHome' | 'sharedWorkspace' | 'additionalWorkspaces' | 'codexAutoCompactTokens' | 'codexSandbox' | 'codexProvider' | 'nativeSession' | 'structuredOutput'> & { controlDir?: string },
     promptFile: string,
     promptText: string,
   ) => string[]
@@ -178,9 +182,9 @@ export const EXECUTOR_REGISTRY: Record<string, CliAdapter> = {
         args.push('--session-id', opts.sessionId)
       }
       args.push('--print', '--dangerously-skip-permissions')
-      // Scheduled runs stream structured events so core can tell a provider
-      // rejection before work from a failure after work began.
-      if (opts.nativeSession) args.push('--output-format', 'stream-json', '--verbose')
+      // Scheduled runs and ordered chat setups stream structured events so core
+      // can tell a provider rejection before work from a failure after work began.
+      if (opts.nativeSession || opts.structuredOutput) args.push('--output-format', 'stream-json', '--verbose')
       for (const directory of [opts.controlDir, opts.sharedWorkspace, ...(opts.additionalWorkspaces ?? []), opts.toolsHome])
         if (directory) args.push('--add-dir', directory)
       if (opts.model) args.push('--model', opts.model)
@@ -448,6 +452,9 @@ export const startExecutorJob = async (
     // token (`claude setup-token`) never refreshes, so one file can be copied
     // to every agent without them invalidating each other's OAuth session.
     Object.assign(environment, await claudeAuthEnvironment(home, options.authProfile))
+    // Print mode otherwise kills unfinished background work after 10 idle minutes.
+    // Keep native background work alive until completion or cancellation.
+    environment.CLAUDE_CODE_PRINT_BG_WAIT_CEILING_MS = '0'
   }
   if (!host && !gui && key === 'opencode') {
     // Point OpenCode at the agent-bound data home (cli/opencode/auth.json)

package/src/host-executor.ts

@@ -10,6 +10,7 @@ import { fileURLToPath } from 'node:url'
 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 { telemetryObserver } from './run-telemetry.js'
 import { parseIsolationClass, type IsolationClass } from './isolation.js'
 import { readModels, sameEngine, validateSelection, validateOpencodeProviders, type ModelChoice } from './ai.js'
 import type { ChildProcess } from 'node:child_process'
@@ -236,16 +237,22 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
                 job=await launch(request.texts,options)
               } else {
                 const cli = opts.cli || installation.cli
+                // Ordered runs (scheduled, captured chat chain or telemetry) record
+                // attempts; only the relay's active attempt is admitted.
+                const ordered = Boolean(run?.scheduled || run?.attempts?.length)
                 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'
+                } else if (ordered) {
+                  const setup = activeSetup(run!)
+                  if (!setup || opts.model !== setup.model || cli !== setup.cli || opts.effort !== setup.effort) throw new Error('Run setup does not match its captured AI selection')
                 }
+                observeClaude = ordered && 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
+                const captured = ordered ? 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')
@@ -265,7 +272,8 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
                 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)}
+                  codexSandbox:containerId && installation.isolation==='isolated' && cli==='codex' && !run?.taskId && process.env.EZ_CODEX_SANDBOX==='external' ? 'external' : undefined,
+                  promptSuffix:runPromptSuffix(run),taskRun:Boolean(run?.taskId),nativeSession:Boolean(run?.scheduled),structuredOutput:ordered,telemetry:Boolean(run?.telemetry)}
                 job=await launch(request.texts,options)
               }
               active.set(base,job.child)
@@ -275,13 +283,16 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
                 ? 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.
+              // Ordered Claude streams every event; forward only the startup and,
+              // when enabled, telemetry summaries (counts and categories only).
               const startup = observeClaude ? startupObserver() : undefined
+              const telemetry = startup && run?.telemetry ? telemetryObserver() : 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'}) }
+                startup.write(chunk); telemetry?.write(chunk)
+                const next = [startup.summary(), ...(telemetry ? [telemetry.summary()] : [])].join('\n')
+                if (next !== summary) { summary = next; emit({stream:'stdout',text:summary+'\n'}) }
               })
               job.child.stderr?.on('data',chunk=>emit({stream:'stderr',text:chunk.toString()}))
               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})