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

package/src/ai-cli.ts

@@ -1,38 +1,51 @@
 import { parseArgs } from 'node:util'
 import { randomBytes } from 'node:crypto'
 import { join } from 'node:path'
-import { readFile } from 'node:fs/promises'
-import { readModels, presetProvider, validateSelection, type AiPreset } from './ai.js'
+import { mkdir, readFile } from 'node:fs/promises'
+import { authProfileStatus, readModels, presetProvider, sameChoice, sameEngine, validateSelection, type AiPreset, type ModelChoice } from './ai.js'
+import { cliHome } from './auth-profile.js'
 import { ControlStore } from './control-state.js'
 
-const {values,positionals}=parseArgs({allowPositionals:true,options:{help:{type:'boolean'},cli:{type:'string'},provider:{type:'string'},model:{type:'string'},effort:{type:'string'}}})
+const usage='Usage: ezenciel-agents-ai list | select --cli <installed-cli> [--auth-profile <name>] [--provider <provider>] [--model <model>] [--effort <effort>] | default | profiles | profile add --cli codex|claude --auth-profile <name>'
+const {values,positionals}=parseArgs({allowPositionals:true,options:{help:{type:'boolean'},cli:{type:'string'},'auth-profile':{type:'string'},provider:{type:'string'},model:{type:'string'},effort:{type:'string'}}})
 if(values.help){
-  console.log('Usage: ezenciel-agents-ai list | select --cli <installed-cli> [--provider <provider>] [--model <model>] [--effort <effort>] | default\nChoose only values returned by list. Selection affects subsequent messages; default makes the selected AI the choice for new conversations. Queued work is unchanged.')
+  console.log(`${usage}\nChoose only values returned by list. Selection affects subsequent messages; default makes the selected AI the choice for new conversations. Queued work is unchanged.\nAuth profiles are separate owner-provisioned Codex/Claude logins with their own configuration and sessions; changing profile starts a new conversation. profile add creates an empty home and prints the native login command for the owner to run; profiles reports read-only login status without secrets.`)
   process.exit(0)
 }
 if (!process.env.EZ_CONTROL_DIR) throw new Error('Use this agent’s bound control directory')
-const catalog=await readFile(join(process.env.EZ_CONTROL_DIR,'host-executor','models.json'),'utf8')
-  .then(text=>JSON.parse(text)).catch(()=>readModels(undefined,undefined,join(process.env.EZ_CONTROL_DIR!,'cli','codex'),undefined,undefined,undefined,process.env.EZ_CONTROL_DIR))
-if(positionals[0]==='list')console.log(JSON.stringify(catalog))
+const controlDir=process.env.EZ_CONTROL_DIR
+const authProfile=values['auth-profile']
+const catalog=():Promise<ModelChoice[]>=>readFile(join(controlDir,'host-executor','models.json'),'utf8')
+  .then(text=>JSON.parse(text)).catch(()=>readModels(undefined,undefined,join(controlDir,'cli','codex'),undefined,undefined,undefined,controlDir))
+if(positionals[0]==='list')console.log(JSON.stringify(await catalog()))
+else if(positionals[0]==='profiles')console.log(JSON.stringify(await authProfileStatus(controlDir)))
+else if(positionals[0]==='profile' && positionals[1]==='add'){
+  if(!authProfile)throw new Error('profile add requires --auth-profile <name>')
+  const home=cliHome(controlDir,values.cli||'',authProfile)
+  const created=await mkdir(home,{recursive:true,mode:0o700})
+  const login=values.cli==='codex' ? `CODEX_HOME=${home} codex login`
+    : `CLAUDE_CONFIG_DIR=${home} claude auth login (or store a \`claude setup-token\` token in ${home}/oauth-token, mode 600)`
+  console.log(JSON.stringify({cli:values.cli,authProfile,home,created:created!==undefined,ownerLogin:login}))
+}
 else if(positionals[0]==='default'){
-  const control=new ControlStore(process.env.EZ_CONTROL_DIR,900000)
+  const control=new ControlStore(controlDir,900000)
   const state=await control.status()
   const selected=state.ai?.presets.find(p=>p.id===state.ai?.selectedId)
   if(!selected)throw new Error('No selected AI')
-  await validateSelection(selected,catalog)
+  await validateSelection(selected,await catalog())
   await control.defaultPreset(selected.id)
   console.log(JSON.stringify({default:selected,applies:'new conversations; current and queued work unchanged'}))
 }
 else if(positionals[0]==='select'){
-  const preset:AiPreset={id:randomBytes(8).toString('hex'),name:[values.provider,values.model||values.cli,values.effort].filter(Boolean).join(' · '),cli:values.cli||'',provider:values.provider,model:values.model,effort:values.effort}
-  await validateSelection(preset,catalog)
-  const control=new ControlStore(process.env.EZ_CONTROL_DIR,900000)
+  const preset:AiPreset={id:randomBytes(8).toString('hex'),name:[values.provider,values.model||values.cli,values.effort].filter(Boolean).join(' · ')+(authProfile ? ` @${authProfile}` : ''),cli:values.cli||'',provider:values.provider,...(authProfile ? {authProfile} : {}),model:values.model,effort:values.effort}
+  await validateSelection(preset,await catalog())
+  const control=new ControlStore(controlDir,900000)
   const state=await control.status()
   if(!state.ai)throw new Error('Agent AI settings are not initialized')
-  const existing=state.ai.presets.find(p=>p.cli===preset.cli&&p.provider===preset.provider&&p.model===preset.model&&p.effort===preset.effort)
+  const existing=state.ai.presets.find(p=>sameChoice(p,preset))
   const selected=existing||preset
   if(!existing)await control.savePreset(selected)
   const current=state.ai.presets.find(p=>p.id===state.ai!.selectedId)!
-  await control.selectPreset(selected.id,state.activeSession?.sessionId??null,current.cli!==selected.cli||presetProvider(current)!==presetProvider(selected)||Boolean(state.activeSession&&!state.activeSession.cli))
+  await control.selectPreset(selected.id,state.activeSession?.sessionId??null,!sameEngine(current,selected)||presetProvider(current)!==presetProvider(selected)||Boolean(state.activeSession&&!state.activeSession.cli))
   console.log(JSON.stringify({selected,defaultUnchanged:true,applies:'subsequent messages; queued work keeps its captured choice'}))
-}else throw new Error('Use list, select --cli <installed-cli> [--provider <provider>] [--model <model>] [--effort <effort>], or default')
+}else throw new Error(usage)

package/src/ai.ts

@@ -5,12 +5,19 @@ import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
 import { homedir } from 'node:os'
 import { join, delimiter } from 'node:path'
-import { executorEnvironment, executorInvocation, executorKey, resolveExecutor } from './executor.js'
+import { CliUnavailableError, executorEnvironment, executorInvocation, executorKey, resolveExecutor } from './executor.js'
 import { desktopCodexPath } from './desktop-bridge.js'
+import { AUTH_PROFILE_CLIS, claudeAuthEnvironment, cliHome, isAuthProfile, listAuthProfiles } from './auth-profile.js'
 
-export type AiPreset = { id: string; name: string; cli: string; provider?: string; model?: string; effort?: string }
-export type ExecutionChoice = { sessionId: string; preset: AiPreset }
-export type ModelChoice = { cli: string; provider?: string; model?: string; name: string; efforts: string[] }
+export type AiPreset = { id: string; name: string; cli: string; provider?: string; authProfile?: string; model?: string; effort?: string }
+// Optional ordered fallbacks are tried only for a scheduled occurrence that never started work.
+export type ExecutionChoice = { sessionId: string; preset: AiPreset; fallbacks?: AiPreset[] }
+export type ModelChoice = { cli: string; provider?: string; authProfile?: string; model?: string; name: string; efforts: string[] }
+type Engine = { cli?: string; authProfile?: string }
+// A native conversation belongs to one client and one credential home.
+export const sameEngine = (a: Engine, b: Engine) => a.cli === b.cli && a.authProfile === b.authProfile
+export const sameChoice = (a: Omit<AiPreset, 'id' | 'name'>, b: Omit<AiPreset, 'id' | 'name'>) =>
+  sameEngine(a, b) && a.provider === b.provider && a.model === b.model && a.effort === b.effort
 const safe = (s: unknown): s is string => typeof s === 'string' && /^[a-zA-Z0-9_./:-]{1,160}$/.test(s)
 const knownClis = ['grok', 'codex', 'codex-gui', 'claude', 'opencode', 'pi']
 const nativeEffort = (cli: string, effort: string) =>
@@ -20,13 +27,15 @@ export const isPreset = (p: unknown): p is AiPreset => {
   const v = p as AiPreset
   return safe(v.id) && typeof v.name === 'string' && v.name.length > 0 && v.name.length <= 80 &&
     knownClis.includes(v.cli) &&
-    (v.provider === undefined || safe(v.provider)) && (v.model === undefined || safe(v.model)) && (v.effort === undefined || safe(v.effort))
+    (v.provider === undefined || safe(v.provider)) && (v.model === undefined || safe(v.model)) && (v.effort === undefined || safe(v.effort)) &&
+    (v.authProfile === undefined || (isAuthProfile(v.authProfile) && AUTH_PROFILE_CLIS.includes(v.cli)))
 }
 export const isExecutionChoice = (v: unknown): v is ExecutionChoice => {
   const c = v as ExecutionChoice | undefined
-  return Boolean(c && /^[0-9a-f-]{36}$/i.test(c.sessionId) && isPreset(c.preset))
+  return Boolean(c && /^[0-9a-f-]{36}$/i.test(c.sessionId) && isPreset(c.preset) &&
+    (c.fallbacks === undefined || (Array.isArray(c.fallbacks) && c.fallbacks.length > 0 && c.fallbacks.every(isPreset))))
 }
-export const presetLabel = (p: AiPreset) => `${p.cli}${p.provider ? ` (${p.provider})` : ''} · ${p.model || 'client default'} · ${p.effort || 'default effort'}`
+export const presetLabel = (p: AiPreset) => `${p.cli}${p.authProfile ? `@${p.authProfile}` : ''}${p.provider ? ` (${p.provider})` : ''} · ${p.model || 'client default'} · ${p.effort || 'default effort'}`
 // OpenCode encodes its provider in the native provider/model identifier.
 export const presetProvider = (p: AiPreset) => p.cli === 'opencode' ? p.model?.split('/')[0] : p.provider
 // The seed delegates model selection to the native client. Project its resolved
@@ -206,7 +215,11 @@ export const readModels = async (home = homedir(), available = installed, codexH
   // establish which models Pi can execute.
   if (!allow && await available('pi')) models.push({ cli: 'pi', name: 'Pi · client default', efforts: [] })
   const curated = await readCuratedModels(curationDir)
-  if (!curated.length) return models
+  const profiles = await listAuthProfiles(curationDir)
+  // Each provisioned profile offers its client's entries under its own home.
+  const withProfiles = (listed: ModelChoice[]) => [...listed, ...profiles.flatMap(({ cli, authProfile }) =>
+    listed.filter((model) => model.cli === cli).map((model) => ({ ...model, authProfile, name: `${authProfile} · ${model.name}`.slice(0, 80) })))]
+  if (!curated.length) return withProfiles(models)
   const scoped: ModelChoice[] = []
   for (const entry of curated) {
     if (!(await available(entry.cli))) continue
@@ -216,7 +229,7 @@ export const readModels = async (home = homedir(), available = installed, codexH
   }
   const key = (m: { cli: string; provider?: string; model?: string }) => `${m.cli}‖${m.provider ?? ''}‖${m.model ?? ''}`
   const curatedKeys = new Set(scoped.map(key))
-  return [...scoped, ...models.filter((m) => !curatedKeys.has(key(m)))]
+  return withProfiles([...scoped, ...models.filter((m) => !curatedKeys.has(key(m)))])
 }
 export const opencodeCatalogModels = async (
   opencodeRunner?: (args: string[]) => Promise<string>,
@@ -250,11 +263,74 @@ export const opencodeProviderAllowlist = (env: NodeJS.ProcessEnv = process.env):
   return validateOpencodeProviders([...new Set(raw.split(',').map((p) => p.trim()).filter(Boolean))])
 }
 
+// Shared by native menus and application controls; a rejected choice never mutates state.
+export const catalogSelection = (p: {cli?: unknown; provider?: unknown; authProfile?: unknown; model?: unknown; effort?: unknown}, catalog: ModelChoice[]): ModelChoice => {
+  const candidate = {...p, id: 'selection', name: 'Selection'}
+  if (!isPreset(candidate)) throw new Error('Invalid AI selection fields')
+  const model = catalog.find(m => sameEngine(m, candidate) && m.provider === candidate.provider && m.model === candidate.model)
+  if (!model) {
+    if (!catalog.some(m => sameEngine(m, candidate)))
+      throw new Error(`No models advertised for ${candidate.cli}${candidate.authProfile ? `@${candidate.authProfile}` : ''} in the installed client catalog; current selection unchanged.`)
+    throw new Error(`Model ${candidate.model ?? '(client default)'} is not in the installed client catalog for ${candidate.cli}; current selection unchanged.`)
+  }
+  if (candidate.effort !== undefined && !model.efforts.includes(candidate.effort))
+    throw new Error(`Effort ${candidate.effort} is not supported for ${candidate.cli} ${candidate.model ?? '(client default)'}. Supported efforts: ${model.efforts.join(', ') || 'none (omit effort)'}; current selection unchanged.`)
+  return model
+}
+
 export const validateSelection = async (p: AiPreset, catalog: ModelChoice[], available = installed): Promise<void> => {
   assertEffort(p.effort, p.model, p.cli)
-  if (!isPreset(p) || !(await available(p.cli))) throw new Error('This CLI is not installed.')
-  if (!p.provider && !p.model && !p.effort) return
-  const model = catalog.find((m) => m.cli === p.cli && m.provider === p.provider && m.model === p.model)
-  if (!model || (p.effort && !model.efforts.includes(p.effort)))
-    throw new Error('This model/effort is not in the installed client catalog. Refresh the client and try again; no fallback was selected.')
+  if (!isPreset(p)) throw new Error('This CLI is not installed.')
+  if (!(await available(p.cli))) throw new CliUnavailableError('This CLI is not installed.')
+  if (!p.provider && !p.authProfile && !p.model && !p.effort) return
+  if (p.authProfile && !p.provider && !p.model && !p.effort) {
+    if (!catalog.some((m) => sameEngine(m, p))) throw new Error('This auth profile is not provisioned for the selected CLI.')
+    return
+  }
+  catalogSelection(p, catalog)
+}
+
+export type AuthProfileStatus = { cli: string; authProfile: string | null; provisioned: boolean; sharesHostLogin: boolean
+  credentialFiles: string[]; loggedIn: boolean | null; method: string | null }
+type StatusRunner = (command: string, args: string[], env: NodeJS.ProcessEnv, cwd: string) => Promise<{ code: number | null; stdout: string; stderr: string }>
+const nativeStatus: StatusRunner = (command, args, env, cwd) => new Promise((resolve) => {
+  const invocation = executorInvocation(command, args)
+  execFile(invocation.command, invocation.args, { env, cwd, timeout: 8000, maxBuffer: 1024 * 1024 }, (error, stdout, stderr) =>
+    resolve({ code: error ? (typeof error.code === 'number' ? error.code : null) : 0, stdout: String(stdout), stderr: String(stderr) }))
+})
+const credentialNames: Record<string, string[]> = { codex: ['auth.json'], claude: ['oauth-token', '.credentials.json'] }
+
+// Read-only auth diagnostics per credential home. Native status runs with the
+// same home and credential environment as execution; only whitelisted fields
+// are projected, never tokens, account identifiers or raw native output.
+export const authProfileStatus = async (controlDir: string, available = installed, run = nativeStatus,
+  isolated = process.env.EZ_ISOLATION === 'isolated'): Promise<AuthProfileStatus[]> => {
+  const homes: { cli: string; authProfile?: string }[] = [...AUTH_PROFILE_CLIS.map((cli) => ({ cli })), ...await listAuthProfiles(controlDir)]
+  const statuses: AuthProfileStatus[] = []
+  for (const { cli, authProfile } of homes) {
+    if (!authProfile && !(await available(cli))) continue
+    const home = cliHome(controlDir, cli, authProfile)
+    const provisioned = await access(home).then(() => true, () => false)
+    const credentialFiles: string[] = []
+    for (const name of credentialNames[cli]) if (await access(join(home, name)).then(() => true, () => false)) credentialFiles.push(name)
+    let loggedIn: boolean | null = null, method: string | null = null
+    if (provisioned) {
+      try {
+        if (cli === 'codex') {
+          const result = await run('codex', ['login', 'status'], { ...executorEnvironment(), CODEX_HOME: home }, home)
+          loggedIn = result.code === null ? null : result.code === 0
+          // Codex prints its login status on stderr.
+          const text = result.stdout + result.stderr
+          method = loggedIn ? /chatgpt/i.test(text) ? 'chatgpt' : /api key/i.test(text) ? 'api-key' : 'other' : null
+        } else {
+          const result = await run('claude', ['auth', 'status', '--json'], { ...executorEnvironment(), ...await claudeAuthEnvironment(home, authProfile, isolated) }, home)
+          const status = result.code === null ? undefined : JSON.parse(result.stdout) as { loggedIn?: unknown; authMethod?: unknown }
+          loggedIn = status ? status.loggedIn === true : null
+          method = loggedIn && safe(status?.authMethod) ? status.authMethod : null
+        }
+      } catch { loggedIn = false }
+    }
+    statuses.push({ cli, authProfile: authProfile ?? null, provisioned, sharesHostLogin: !isolated && !authProfile, credentialFiles, loggedIn, method })
+  }
+  return statuses
 }

package/src/application-channel.ts

@@ -2,11 +2,11 @@ import { createServer, type Server, type IncomingMessage, type ServerResponse }
 import { createHash, randomUUID, timingSafeEqual } from 'node:crypto'
 import { mkdir, readFile, writeFile, rename, open, unlink, stat, chown } from 'node:fs/promises'
 import { join } from 'node:path'
-import { ControlStore, sessionTitle, telegramOwner, type ControlGuard, type Owner, sameOwner, validOwner, ownerId, ownerEpoch } from './control-state.js'
+import { ControlStore, sessionTitle, telegramOwner, type ControlGuard, type Owner, type SessionState, sameOwner, validOwner, ownerId, ownerEpoch } from './control-state.js'
 import { RunStore, type RunRecord, type OutboxItem } from './runs.js'
 import { ownsRun } from './identity.js'
 import { applicationId, validApplicationOrigin } from './application-origin.js'
-import { isPreset, type AiPreset, type ModelChoice } from './ai.js'
+import { isPreset, sameChoice, catalogSelection, type AiPreset, type ModelChoice } from './ai.js'
 import { MAX_INCOMING_ATTACHMENT_BYTES, stageChatAttachment } from './files.js'
 import { assertEffort } from './model-policy.js'
 import { ApprovalStore } from './approval.js'
@@ -97,6 +97,8 @@ export class ApplicationChannel {
   constructor(private options: {
     controlDir: string; workspace?: string; isolation?: string; initial: AiPreset
     wake: () => void
+    // Queues the replaced conversation's silent close turn (session-close.ts).
+    closeSession?: (session: SessionState | null) => Promise<void>
     cancel: (id: string) => Promise<void>
     speech?: (text: string, language: 'en' | 'es') => Promise<{ buffer: Buffer; mimeType: string }>
     createTelegramPairing?: (bindingId: string, owner: Owner) => Promise<{ connected: true } | { connected: false; url: string; expiresAt: string }>
@@ -155,10 +157,10 @@ export class ApplicationChannel {
     const owner = await this.sharedBinding(bindingId)
     const controls = this.options.aiControls
     if (!controls) throw new Error('Application controls unavailable')
-    const value = input as {action?: unknown; expectedSession?: unknown; sessionId?: unknown; presetId?: unknown; cli?: unknown; provider?: unknown; model?: unknown; effort?: unknown}
+    const value = input as {action?: unknown; expectedSession?: unknown; sessionId?: unknown; presetId?: unknown; cli?: unknown; provider?: unknown; authProfile?: unknown; model?: unknown; effort?: unknown}
     if (!value || !['new','switch','select','model'].includes(String(value.action)) ||
       !(value.expectedSession === null || (typeof value.expectedSession === 'string' && /^[a-f0-9-]{36}$/.test(value.expectedSession)))) throw new Error('Invalid application control request')
-    const fields = {new:[],switch:['sessionId'],select:['presetId'],model:['cli','provider','model','effort']}[value.action as 'new'|'switch'|'select'|'model']!
+    const fields = {new:[],switch:['sessionId'],select:['presetId'],model:['cli','provider','authProfile','model','effort']}[value.action as 'new'|'switch'|'select'|'model']!
     if (Object.keys(value).some(key => !['action','expectedSession',...fields].includes(key))) throw new Error('Invalid application control fields')
     const control = new ControlStore(this.options.controlDir, 900000)
     const expected = value.expectedSession as string | null
@@ -168,7 +170,11 @@ export class ApplicationChannel {
       const live = (await this.bindings.list()).find(item=>item.bindingId===bindingId)
       if (!live?.shareTelegram || !sameOwner(owner, live.owner)) throw new Error('Application authority revoked')
     }}
-    if (value.action === 'new') await control.resetSession(expected, guard)
+    if (value.action === 'new') {
+      const previous = await control.getActiveSession()
+      await control.resetSession(expected, guard)
+      await this.options.closeSession?.(previous)
+    }
     if (value.action === 'switch') {
       if (typeof value.sessionId !== 'string') throw new Error('Invalid application conversation')
       // switchSession enforces the same visibility/engine restrictions as /chats.
@@ -181,8 +187,7 @@ export class ApplicationChannel {
       await controls.select(preset, expected, guard)
     }
     if (value.action === 'model') {
-      const model = (await controls.catalog()).find(item => item.cli === value.cli && item.provider === value.provider && item.model === value.model)
-      if (!model || (value.effort !== undefined && (typeof value.effort !== 'string' || !model.efforts.includes(value.effort)))) throw new Error('Invalid application model selection')
+      const model = catalogSelection(value, await controls.catalog())
       await this.sharedBinding(bindingId)
       const preset = await controls.saveSelection(model, value.effort as string | undefined, guard)
       await this.sharedBinding(bindingId)
@@ -211,10 +216,10 @@ export class ApplicationChannel {
     const owner = await this.sharedBinding(bindingId, false)
     const controls = this.options.aiControls
     if (!controls) throw new Error('Application controls unavailable')
-    const value = input as {action?:unknown; expectedSession?:unknown; presetId?:unknown; cli?:unknown; provider?:unknown; model?:unknown; effort?:unknown}
+    const value = input as {action?:unknown; expectedSession?:unknown; presetId?:unknown; cli?:unknown; provider?:unknown; authProfile?:unknown; model?:unknown; effort?:unknown}
     if (!value || !['new','select','model'].includes(String(value.action)) ||
       !(value.expectedSession===null || (typeof value.expectedSession==='string' && /^[a-f0-9-]{36}$/.test(value.expectedSession)))) throw new Error('Invalid application control request')
-    const fields = {new:[],select:['presetId'],model:['cli','provider','model','effort']}[value.action as 'new'|'select'|'model']!
+    const fields = {new:[],select:['presetId'],model:['cli','provider','authProfile','model','effort']}[value.action as 'new'|'select'|'model']!
     if (Object.keys(value).some(key=>!['action','expectedSession',...fields].includes(key))) throw new Error('Invalid application control fields')
     const hashedScope = applicationScope(bindingId,scope)
     const guard:ControlGuard = {owner,applicationScope:hashedScope,expectedSession:value.expectedSession as string|null,
@@ -231,8 +236,7 @@ export class ApplicationChannel {
       await controls.validate(preset)
     }
     if (value.action==='model') {
-      const model = (await controls.catalog()).find(item=>item.cli===value.cli && item.provider===value.provider && item.model===value.model)
-      if (!model || (value.effort!==undefined && (typeof value.effort!=='string' || !model.efforts.includes(value.effort)))) throw new Error('Invalid application model selection')
+      const model = catalogSelection(value, await controls.catalog())
       preset = await controls.saveSelection(model,value.effort as string|undefined,guard)
     }
     await control.changeApplicationSession(hashedScope,guard,preset)
@@ -257,7 +261,7 @@ export class ApplicationChannel {
         const run=await this.runs.create({id,ownerId:ownerId(access.task.owner),ownerEpoch:ownerEpoch(access.task.owner),taskId:access.task.id,texts:[v.text],execution:access.execution,application:{bindingId,scope,requestId:v.requestId,taskAccess:ticketHash}})
         this.options.wake();return run
       }
-      const value = input as { requestId?: unknown; scope?: unknown; text?: unknown; attachment?: { name?: unknown; data?: unknown }; context?: Record<string, unknown>; expectedNativeSessionId?: unknown; activateTelegram?: unknown; followTelegram?: unknown; ai?: { cli?: unknown; provider?: unknown; model?: unknown; effort?: unknown } }
+      const value = input as { requestId?: unknown; scope?: unknown; text?: unknown; attachment?: { name?: unknown; data?: unknown }; context?: Record<string, unknown>; expectedNativeSessionId?: unknown; activateTelegram?: unknown; followTelegram?: unknown; ai?: { cli?: unknown; provider?: unknown; authProfile?: unknown; model?: unknown; effort?: unknown } }
       if (!value || !applicationId(value.requestId) || !applicationId(value.scope) || typeof value.text !== 'string' || (!value.text.trim() && value.attachment === undefined) || value.text.length > 16000 || Object.keys(value).some(key => !['requestId','scope','text','attachment','context','expectedNativeSessionId','activateTelegram','followTelegram','ai'].includes(key))) throw new Error('Invalid application request')
       if (value.expectedNativeSessionId !== undefined && (typeof value.expectedNativeSessionId !== 'string' || !/^[a-zA-Z0-9_-]{1,160}$/.test(value.expectedNativeSessionId))) throw new Error('Invalid application native session assertion')
       if (value.activateTelegram !== undefined && typeof value.activateTelegram !== 'boolean') throw new Error('Invalid application Telegram activation')
@@ -266,7 +270,7 @@ export class ApplicationChannel {
       let requestedPreset: AiPreset | undefined
       if (value.ai !== undefined) {
         const candidate = { ...value.ai, id: 'application', name: 'Application selection' }
-        if (!value.ai || Object.keys(value.ai).some(key => !['cli', 'provider', 'model', 'effort'].includes(key)) || !isPreset(candidate)) throw new Error('Invalid application AI selection')
+        if (!value.ai || Object.keys(value.ai).some(key => !['cli', 'provider', 'authProfile', 'model', 'effort'].includes(key)) || !isPreset(candidate)) throw new Error('Invalid application AI selection')
         assertEffort(candidate.effort, candidate.model, candidate.cli)
         requestedPreset = candidate
       }
@@ -289,7 +293,7 @@ export class ApplicationChannel {
       const existing = await this.runs.get(id)
       if (existing) {
         await this.bindings.authorize(existing)
-        if (requestedPreset && (existing.execution?.preset.cli !== requestedPreset.cli || existing.execution?.preset.provider !== requestedPreset.provider || existing.execution?.preset.model !== requestedPreset.model || existing.execution?.preset.effort !== requestedPreset.effort)) throw new Error('Application request ID conflicts with prior AI selection')
+        if (requestedPreset && (!existing.execution || !sameChoice(existing.execution.preset, requestedPreset))) throw new Error('Application request ID conflicts with prior AI selection')
         if (Boolean(existing.application?.followTelegram) !== Boolean(value.followTelegram) || existing.application?.scope !== value.scope || (existing.application?.inputText ?? existing.texts[0]) !== value.text || existing.application?.attachmentHash !== attachmentHash) throw new Error('Application request ID conflicts with prior scope or text')
         return existing // Retried context never replaces already admitted capabilities.
       }

package/src/auth-profile.ts

@@ -0,0 +1,53 @@
+import { lstat, readdir, readFile } from 'node:fs/promises'
+import path from 'node:path'
+
+// Owner-provisioned named credential homes beside the agent default binding.
+// Unset keeps control/cli/<cli>; a name selects control/cli/profiles/<name>/<cli>
+// with its own credentials, configuration and native sessions. Ez never stores,
+// copies or prints credentials; the native CLI logs in inside the home.
+export const AUTH_PROFILE_CLIS: readonly string[] = ['codex', 'claude']
+export const isAuthProfile = (value: unknown): value is string =>
+  typeof value === 'string' && /^[a-z][a-z0-9-]{0,31}$/.test(value)
+
+export const cliHome = (controlDir: string, cli: string, authProfile?: string): string => {
+  if (authProfile === undefined) return path.join(controlDir, 'cli', cli)
+  if (!isAuthProfile(authProfile) || !AUTH_PROFILE_CLIS.includes(cli)) throw new Error('Invalid auth profile selection')
+  return path.join(controlDir, 'cli', 'profiles', authProfile, cli)
+}
+
+const realDirectory = (directory: string) => lstat(directory).then(stat => stat.isDirectory(), () => false)
+
+// A named home exists only once the owner provisioned it as a real directory.
+// Execution never creates, links or falls back from it.
+export const provisionedHome = async (controlDir: string, cli: string, authProfile?: string): Promise<string> => {
+  const home = cliHome(controlDir, cli, authProfile)
+  if (authProfile !== undefined && !await realDirectory(home)) throw new Error(`Auth profile ${authProfile} is not provisioned for ${cli}`)
+  return home
+}
+
+export const listAuthProfiles = async (controlDir?: string): Promise<{ cli: string; authProfile: string }[]> => {
+  if (!controlDir) return []
+  const names = await readdir(path.join(controlDir, 'cli', 'profiles')).catch(() => [] as string[])
+  const found: { cli: string; authProfile: string }[] = []
+  for (const authProfile of names.filter(isAuthProfile).sort())
+    for (const cli of AUTH_PROFILE_CLIS)
+      if (await realDirectory(cliHome(controlDir, cli, authProfile))) found.push({ cli, authProfile })
+  return found
+}
+
+// Claude credentials for one home. Host-capable default homes share the
+// installer login in place; named homes and isolated agents use only their
+// own store, plus an optional owner-provisioned long-lived `oauth-token`.
+export const claudeAuthEnvironment = async (home: string, authProfile?: string, isolated = process.env.EZ_ISOLATION === 'isolated'): Promise<NodeJS.ProcessEnv> => {
+  const environment: NodeJS.ProcessEnv = { CLAUDE_CONFIG_DIR: home }
+  if (!isolated && authProfile === undefined) environment.CLAUDE_SECURESTORAGE_CONFIG_DIR = ''
+  const token = await readFile(path.join(home, 'oauth-token'), 'utf8').then(value => value.trim(), (error: NodeJS.ErrnoException) => {
+    if (error.code === 'ENOENT') return undefined
+    throw error
+  })
+  if (token !== undefined) {
+    if (!/^[A-Za-z0-9._-]{20,512}$/.test(token)) throw new Error('Invalid Claude token binding')
+    environment.CLAUDE_CODE_OAUTH_TOKEN = token
+  }
+  return environment
+}

package/src/codex-session.ts

@@ -5,6 +5,7 @@ import { createInterface } from 'node:readline'
 import { fileURLToPath } from 'node:url'
 import path from 'node:path'
 import { terminateJob, validateCodexProvider, type CodexProviderBinding } from './executor.js'
+import { codexRejection, codexResetAt, startupLine } from './setup-fallback.js'
 
 type Options = {workspace:string;controlDir:string;toolsHome?:string;sharedWorkspace?:string;additionalWorkspaces?:string[];model?:string;effort?:string;prompt:string;codexSandbox?:'external';codexProvider?:CodexProviderBinding}
 type Message = {id?:number;method?:string;params?:any;result?:any;error?:{message:string;code?:number}}
@@ -17,7 +18,7 @@ export async function runCodexSession(options:Options, io:{launch?:()=>ChildProc
   const provider = options.codexProvider ? validateCodexProvider(options.codexProvider) : undefined
   const child=io.launch?.() ?? spawn('codex',['app-server','--stdio','--disable','memories','--enable','skip_host_skill_discovery'],{cwd:options.workspace,env:process.env,stdio:['pipe','pipe','pipe']})
   const emit=io.emit ?? (line=>process.stdout.write(line+'\n'))
-  let id=0,threadId:string|undefined,activeTurn:string|undefined,finished=false,sawTurn=false,hadGoal=false
+  let id=0,threadId:string|undefined,activeTurn:string|undefined,finished=false,sawTurn=false,hadGoal=false,workBegan=false,resetAt:string|undefined
   let resolveDone!:(code:number)=>void
   const done=new Promise<number>(resolve=>{resolveDone=resolve})
   const pending=new Map<number,{resolve:(value:any)=>void;reject:(error:Error)=>void;timer:ReturnType<typeof setTimeout>}>()
@@ -38,7 +39,10 @@ export async function runCodexSession(options:Options, io:{launch?:()=>ChildProc
     finish(0)
   }
   child.stderr?.pipe(process.stderr)
-  child.on('error',fail)
+  child.on('error',error=>{
+    if((error as NodeJS.ErrnoException).code==='ENOENT')emit(startupLine({workBegan:false,rejection:{category:'cli-unavailable'}}))
+    fail(error)
+  })
   child.stdin?.on('error',fail)
   child.once('close',()=>{
     for(const p of pending.values()){clearTimeout(p.timer);p.reject(new Error('Codex app-server closed'))}
@@ -57,16 +61,23 @@ export async function runCodexSession(options:Options, io:{launch?:()=>ChildProc
       // Never turn an unexpected approval/elicitation request into permission.
       send({id:message.id,error:{code:-32601,message:`Unsupported unattended request: ${message.method}`}});fail(new Error(`Codex requires attention: ${message.method}`));return
     }
+    if(message.method==='account/rateLimits/updated')resetAt=codexResetAt(message.params?.rateLimits) ?? resetAt
     if(message.params?.threadId!==threadId)return
     if(message.method==='turn/started'){activeTurn=message.params.turn.id;sawTurn=true}
+    // Any item beyond the echoed input means the provider accepted the turn.
+    if(message.method==='item/started' && message.params.item?.type!=='userMessage' && !workBegan){workBegan=true;emit(startupLine({workBegan}))}
     if(message.method==='thread/goal/updated')settled(message.params.goal)
     if(message.method==='thread/goal/cleared')settled(null)
     if(message.method==='turn/completed'){
       if(activeTurn===message.params.turn.id)activeTurn=undefined
       if(message.params.turn.status!=='completed'){
         if(message.params.turn.status==='interrupted')finish(130)
-        else fail(new Error(redactFailure(typeof message.params.turn.error?.message==='string'
+        else {
+          const category=workBegan ? undefined : codexRejection(message.params.turn.error?.codexErrorInfo)
+          if(category)emit(startupLine({workBegan,rejection:{category,...(category==='quota' && resetAt ? {resetAt} : {})}}))
+          fail(new Error(redactFailure(typeof message.params.turn.error?.message==='string'
           ? message.params.turn.error.message : 'Native turn failed without error details')))
+        }
         return
       }
       // Completion of a turn is not completion of a native goal. The native

package/src/control-state.ts

@@ -2,7 +2,8 @@ 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, type AiPreset, type ExecutionChoice, type ModelChoice } from './ai.js'
+import { isPreset, persistedPreset, presetProvider, sameEngine, type AiPreset, type ExecutionChoice, type ModelChoice } from './ai.js'
+import { isAuthProfile } from './auth-profile.js'
 
 export type Owner = {
   id?: string
@@ -58,6 +59,8 @@ export type SessionState = {
   sessionId: string
   hasStarted: boolean
   cli?: string
+  // Bound with cli at creation: a native session never resumes under another home.
+  authProfile?: string
   nativeSessionId?: string
   title?: string
   archived?: boolean
@@ -129,7 +132,8 @@ const isState = (value: unknown): value is ControlState => {
     (s.archived === undefined || typeof s.archived === 'boolean') &&
     (s.applicationScope === undefined || /^[a-f0-9]{64}$/.test(s.applicationScope)) &&
     (s.telegramShared === undefined || typeof s.telegramShared === 'boolean') &&
-    (s.preset === undefined || (isPreset(s.preset) && s.preset.cli === s.cli))
+    (s.authProfile === undefined || (isAuthProfile(s.authProfile) && s.cli !== undefined)) &&
+    (s.preset === undefined || (isPreset(s.preset) && sameEngine(s.preset, s)))
   return (
     candidate.version === 1 &&
     Array.isArray(candidate.pending) &&
@@ -150,9 +154,11 @@ const isState = (value: unknown): value is ControlState => {
 export const sessionTitle = (session: SessionState): string =>
   session.title || `Conversation ${session.sessionId.slice(0, 8)}`
 
+const engineOf = (preset: AiPreset) => ({ cli: preset.cli, ...(preset.authProfile ? { authProfile: preset.authProfile } : {}) })
+
 const rememberPreset = (state: ControlState) => {
   const preset = state.ai?.presets.find(p => p.id === state.ai!.selectedId)
-  if (state.activeSession && preset && state.activeSession.cli === preset.cli)
+  if (state.activeSession && preset && sameEngine(state.activeSession, preset))
     state.activeSession.preset = preset
 }
 
@@ -486,8 +492,8 @@ export class ControlStore {
       const ai = state.ai
       // Older sessions did not record their model. Reuse a known preset for the
       // same CLI; never resume an engine ID through a different client.
-      const preset = session.preset ?? ai?.presets.find(p => p.cli === session.cli)
-      if (!ai || !preset || preset.cli !== session.cli)
+      const preset = session.preset ?? ai?.presets.find(p => sameEngine(p, session))
+      if (!ai || !preset || !sameEngine(preset, session))
         throw new Error('This older conversation has no saved AI binding. Start a new conversation.')
       if (session.hasStarted && ['codex', 'codex-gui', 'opencode'].includes(session.cli!) && !session.nativeSessionId)
         throw new Error('This conversation has no native session ID. Start a new conversation.')
@@ -537,10 +543,11 @@ export class ControlStore {
       const state = await this.readState()
       await requireControlGuard(state, guard)
       if (expectedSession !== undefined && (state.activeSession?.sessionId ?? null) !== expectedSession) throw new Error('Conversation changed. Refresh controls before trying again.')
+      const fallback = state.ai?.presets.find((p) => p.id === state.ai!.defaultId)
       const next: SessionState = {
         sessionId: crypto.randomUUID(),
         hasStarted: false,
-        cli: state.ai?.presets.find((p) => p.id === state.ai!.defaultId)?.cli,
+        ...(fallback ? engineOf(fallback) : {}),
       }
       rememberPreset(state)
       if (state.activeSession) (state.sessions ??= []).push(state.activeSession)
@@ -624,25 +631,25 @@ export class ControlStore {
     const settledPreset = settledAi?.presets.find((p) => p.id === settledAi.selectedId)
     const session = settled.activeSession
     if (settledPreset && session && (session.cli || session.hasStarted) &&
-      !(session.cli === settledPreset.cli && session.hasStarted && session.preset &&
+      !(sameEngine(session, settledPreset) && session.hasStarted && session.preset &&
         presetProvider(session.preset) !== presetProvider(settledPreset)) &&
-      (session.cli !== settledPreset.cli || JSON.stringify(session.preset) === JSON.stringify(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 this.withLock(async () => {
       const state = await this.readState()
       state.ai ??= { presets: [persistedPreset(initial)], defaultId: initial.id, selectedId: initial.id, recentIds: [] }
       const preset = state.ai.presets.find((p) => p.id === state.ai!.selectedId)!
-      state.activeSession ??= { sessionId: crypto.randomUUID(), hasStarted: false, cli: preset.cli }
-      if (!state.activeSession.cli && !state.activeSession.hasStarted) state.activeSession.cli = preset.cli
-      if (state.activeSession.cli === preset.cli) {
+      state.activeSession ??= { sessionId: crypto.randomUUID(), hasStarted: false, ...engineOf(preset) }
+      if (!state.activeSession.cli && !state.activeSession.hasStarted) Object.assign(state.activeSession, engineOf(preset))
+      if (sameEngine(state.activeSession, preset)) {
         const previous = state.activeSession.preset
         // A provider change starts a separate native context. Model and effort
         // changes are native turn settings within the existing conversation.
         if (state.activeSession.hasStarted && previous &&
             presetProvider(previous) !== presetProvider(preset)) {
           ;(state.sessions ??= []).push(state.activeSession)
-          state.activeSession = { sessionId: crypto.randomUUID(), hasStarted: false, cli: preset.cli, preset }
+          state.activeSession = { sessionId: crypto.randomUUID(), hasStarted: false, ...engineOf(preset), preset }
         } else {
           state.activeSession.preset = preset
         }
@@ -675,14 +682,14 @@ export class ControlStore {
         state.ai!.selectedId = session.preset!.id
       }
       if (previous?.preset) {
-        if (requested && requested.cli !== previous.cli) throw new Error('Application request conflicts with existing session engine')
+        if (requested && !sameEngine(requested, previous)) throw new Error('Application request conflicts with existing session engine')
         if (requested) previous.preset = requested
         activate(previous)
         if (shareTelegram || requested) await this.writeState(state)
         return { sessionId: previous.sessionId, preset: previous.preset }
       }
       const preset = requested ?? state.ai.presets.find(item => item.id === state.ai!.selectedId)!
-      const session: SessionState = { sessionId: crypto.randomUUID(), hasStarted: false, cli: preset.cli, preset, applicationScope: scope }
+      const session: SessionState = { sessionId: crypto.randomUUID(), hasStarted: false, ...engineOf(preset), preset, applicationScope: scope }
       state.sessions.push(session)
       activate(session)
       await this.writeState(state)
@@ -705,7 +712,7 @@ export class ControlStore {
         throw new Error('Application scope is shared; use shared controls')
       const nextPreset = preset ?? state.ai?.presets.find(item => item.id === state.ai!.defaultId)
       if (!nextPreset || !isPreset(nextPreset)) throw new Error('Invalid application AI selection')
-      if (preset && previous?.cli === preset.cli) {
+      if (preset && previous && sameEngine(previous, preset)) {
         previous.preset = persistedPreset(preset)
         await this.writeState(state)
         return previous
@@ -714,7 +721,7 @@ export class ControlStore {
       // the old immutable session ID; private history stays absent from /chats.
       if (previous) previous.archived = true
       const next: SessionState = {sessionId:crypto.randomUUID(), hasStarted:false,
-        cli:nextPreset.cli, preset:persistedPreset(nextPreset), applicationScope:scope}
+        ...engineOf(nextPreset), preset:persistedPreset(nextPreset), applicationScope:scope}
       ;(state.sessions ??= []).push(next)
       await this.writeState(state)
       return next
@@ -725,8 +732,8 @@ export class ControlStore {
     const state = await this.status()
     const session = state.activeSession?.sessionId === choice.sessionId ? state.activeSession
       : state.sessions?.find((s) => s.sessionId === choice.sessionId)
-    if (!session || session.cli !== choice.preset.cli)
-      throw new Error('Conversation has no matching CLI binding. Use New conversation explicitly; files are preserved.')
+    if (!session?.cli || !sameEngine(session, choice.preset))
+      throw new Error('Conversation has no matching CLI binding for this client and auth profile. Use New conversation explicitly; files are preserved.')
     if (session.hasStarted && ['codex', 'codex-gui', 'opencode'].includes(session.cli) && !session.nativeSessionId)
       throw new Error('Native session ID missing. Use New conversation explicitly; no automatic reset.')
     return session
@@ -774,16 +781,16 @@ export class ControlStore {
       assertEffort(preset.effort, preset.model, preset.cli)
       if ((state.activeSession?.sessionId ?? null) !== expectedSession) throw new Error('Menu expired. Open Choose AI again.')
       const current = ai.presets.find((p) => p.id === ai.selectedId)!
-      if (state.activeSession && (current.cli !== preset.cli || presetProvider(current) !== presetProvider(preset) || !state.activeSession.cli) && !fresh) return false
+      if (state.activeSession && (!sameEngine(current, preset) || presetProvider(current) !== presetProvider(preset) || !state.activeSession.cli) && !fresh) return false
       if (fresh || !state.activeSession) {
         rememberPreset(state)
         if (state.activeSession) (state.sessions ??= []).push(state.activeSession)
-        state.activeSession = { sessionId: crypto.randomUUID(), hasStarted: false, cli: preset.cli, preset: persistedPreset(preset) }
+        state.activeSession = { sessionId: crypto.randomUUID(), hasStarted: false, ...engineOf(preset), preset: persistedPreset(preset) }
       }
       ai.selectedId = id
       // Persist the conversation's choice now, even if the owner switches chats
       // or restarts before sending another message. Queued choices are snapshots.
-      if (state.activeSession.cli === preset.cli && (!state.activeSession.preset || presetProvider(state.activeSession.preset) === presetProvider(preset)))
+      if (sameEngine(state.activeSession, preset) && (!state.activeSession.preset || presetProvider(state.activeSession.preset) === presetProvider(preset)))
         state.activeSession.preset = persistedPreset(preset)
       ai.recentIds = [id, ...(ai.recentIds ?? []).filter((recentId) => recentId !== id)].slice(0, 3)
       await this.writeState(state)

package/src/delivery-socket.ts

@@ -318,6 +318,8 @@ export const createLedgerHandler = (controlDir: string, hooks: LedgerHooks): Del
         const payload = (op.payload ?? {}) as { runId?: unknown; change?: unknown }
         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')
         return runs.patch(payload.runId, payload.change as never)
       }
       case 'taskApplication': {