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

package/src/runs.ts

@@ -1,6 +1,9 @@
 import { validApplicationOrigin, type ApplicationOrigin } from './application-origin.js'
 import { type FailureEvidence, type FailureReview, validFailureReview, failureStamp, failureEvidence } from './failure.js'
 import { randomBytes } from 'node:crypto'
+import { readFile, rename, rm, writeFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { isHostRunId } from './host-executor-protocol.js'
 import { validOrigin, type ExternalOrigin } from './event-sources.js'
 import { normalizeReactionEmoji } from './reaction.js'
 import { validScheduledOrigin, type ScheduledOrigin } from './scheduler.js'
@@ -36,6 +39,8 @@ export type RunRecord = {
   // Ordered task setups tried for this occurrence; the last one is active.
   attempts?: SetupAttempt[]
   replyOnly?: boolean
+  // Silent end-of-conversation turn in a replaced chat session (session-close.ts).
+  sessionClose?: true
   exitCode?: number | null
   failureReason?: string
   failure?: FailureEvidence
@@ -86,9 +91,10 @@ export const retainedOutbox = (controlDir: string): StoredOutboxItem[] => [...ou
 // Stateless pipe: the relay owns the ledger in process memory. Cross-process
 // producers (engine children, plugin children, host executor) reach it through
 // the delivery socket (see delivery-socket.ts), never through control/ files.
-// A restart drops in-flight runs and queued items by design; in-flight sends
-// report unknown rather than claiming success. Long-lived relays cap retained
-// terminal records so memory stays bounded.
+// A restart drops in-flight runs and queued items by design (except handed-off
+// host-transport runs, below); in-flight sends report unknown rather than
+// claiming success. Long-lived relays cap retained terminal records so memory
+// stays bounded.
 const MAX_TERMINAL_RUNS = 2000
 const MAX_TERMINAL_OUTBOX = 2000
 
@@ -142,6 +148,47 @@ export const activeSetup = (run: Pick<RunRecord, 'attempts' | 'execution'>): AiP
 
 export const newRunId = (): string => `r_${Date.now().toString(36)}_${randomBytes(3).toString('hex')}`
 
+// The one exception to memory-only runs: a graceful relay stop hands its
+// running host-transport runs to the next relay, whose executors outlive it.
+// The next relay adopts and watches them; it never relaunches one.
+const handoffFile = (controlDir: string): string => join(controlDir, 'run-handoff.json')
+const handedRun = (value: unknown): value is RunRecord => {
+  const run = value as RunRecord
+  return Boolean(run && typeof run === 'object' && (run.version === 1 || run.version === 2) && typeof run.id === 'string' && isHostRunId(run.id) &&
+    run.status === 'running' && Array.isArray(run.texts) && run.texts.every(text => typeof text === 'string') && Number.isFinite(Date.parse(run.createdAt)) &&
+    (run.execution === undefined || isExecutionChoice(run.execution)) && (run.scheduled === undefined || validScheduledOrigin(run.scheduled)) &&
+    (run.external === undefined || validOrigin(run.external)) && (run.application === undefined || validApplicationOrigin(run.application)))
+}
+
+export const saveRunHandoff = async (controlDir: string, records: RunRecord[]): Promise<void> => {
+  const file = handoffFile(controlDir), temporary = `${file}.${process.pid}.tmp`
+  await writeFile(temporary, JSON.stringify({ version: 1, writtenAt: new Date().toISOString(), runs: records }), { mode: 0o600 })
+  await rename(temporary, file)
+}
+
+const HANDOFF_MAX_AGE_MS = 24 * 60 * 60 * 1000
+
+// Reads and removes the record. An unreadable, corrupt or stale record adopts
+// nothing: those executors finish unobserved, like a restart without handoff.
+export const takeRunHandoff = async (controlDir: string, now = Date.now()): Promise<RunRecord[]> => {
+  try {
+    let raw: string
+    try { raw = await readFile(handoffFile(controlDir), 'utf8') }
+    catch (error) { if ((error as NodeJS.ErrnoException).code === 'ENOENT') return []; throw error }
+    await rm(handoffFile(controlDir))
+    const value = JSON.parse(raw) as { version?: unknown; writtenAt?: unknown; runs?: unknown }
+    const age = now - Date.parse(typeof value.writtenAt === 'string' ? value.writtenAt : '')
+    if (value.version !== 1 || !(age >= -60_000 && age <= HANDOFF_MAX_AGE_MS)) throw new Error('Invalid or stale run handoff')
+    if (!Array.isArray(value.runs) || value.runs.length > 100) throw new Error('Invalid run handoff')
+    const valid = value.runs.filter(handedRun)
+    if (valid.length !== value.runs.length) console.error('Ignoring invalid handed-off runs', value.runs.length - valid.length)
+    return [...new Map(valid.map(run => [run.id, run])).values()]
+  } catch (error) {
+    console.error('Ignoring unreadable run handoff', error instanceof Error ? error.message : 'Unknown error')
+    return []
+  }
+}
+
 export class RunStore {
   constructor(private readonly controlDir: string) {}
 
@@ -162,6 +209,7 @@ export class RunStore {
     application?: ApplicationOrigin
     delivery?: { bindingId: string; scope: string }
     script?: ScriptRunRef
+    sessionClose?: true
   }, exclusiveSchedule = false): Promise<RunRecord> {
     const store = runsFor(this.controlDir)
     if (input.id) {
@@ -194,6 +242,7 @@ export class RunStore {
       delivery: input.delivery,
       scheduled: input.scheduled,
       ...(input.script ? { script: input.script } : {}),
+      ...(input.sessionClose ? { sessionClose: true as const } : {}),
       status: 'queued',
       createdAt: new Date().toISOString(),
     }
@@ -207,6 +256,15 @@ export class RunStore {
     return runsFor(this.controlDir).get(id) ?? null
   }
 
+  // Re-admit a run from the previous relay's handoff; its executor is already running.
+  async adopt(run: RunRecord): Promise<RunRecord> {
+    if (!handedRun(run)) throw new Error('Invalid handed-off run')
+    const existing = runsFor(this.controlDir).get(run.id)
+    if (existing && existing.status !== 'running') throw new Error('Handed-off run already settled')
+    runsFor(this.controlDir).set(run.id, run)
+    return run
+  }
+
   async patch(
     id: string,
     change: Partial<Pick<RunRecord, 'status' | 'startedAt' | 'endedAt' | 'pid' | 'nativeSessionId' | 'interrupted' | 'blockReason' | 'backendSubmitted' | 'replyOnly' | 'exitCode' | 'failureReason' | 'failure' | 'failureReview' | 'externalReleased' | 'output' | 'timedOut' | 'attempts'>>,

package/src/schedule-cli.ts

@@ -8,7 +8,7 @@ import { ControlStore, sameOwner } from './control-state.js'
 import { ApplicationBindings } from './application-channel.js'
 import type { RunRecord } from './runs.js'
 import { callDeliverySocket, socketPathFor } from './delivery-socket.js'
-import { initialPreset, isPreset, presetLabel, MAX_FALLBACKS, type AiPreset } from './ai.js'
+import { initialPreset, isPreset, presetLabel, type AiPreset } from './ai.js'
 import { executionOverrides } from './model-policy.js'
 import { holdsSchedule, Scheduler, executionType } from './scheduler.js'
 import { Scripts, fileSha256, workspaceEntry, DEFAULT_SCRIPT_TIMEOUT_SECONDS } from './scripts.js'
@@ -17,17 +17,18 @@ import { provisionedHome } from './auth-profile.js'
 import { ownsRun } from './identity.js'
 import { type Trigger } from './schedule-time.js'
 
-// `cli=claude,model=sonnet,effort=medium` names one fallback setup.
+// Each fallback selects its own native engine, credential home and model.
 const fallbackSetup = (spec: string, index: number): AiPreset => {
   const fields = Object.fromEntries(spec.split(',').map(part => {
     const at = part.indexOf('=')
-    if (at < 1) throw new Error('Fallback uses cli=EXECUTOR,model=MODEL[,effort=EFFORT][,provider=ID]')
+    if (at < 1) throw new Error('Fallback uses cli=EXECUTOR,model=MODEL[,auth-profile=NAME][,effort=EFFORT][,provider=ID]')
     return [part.slice(0, at), part.slice(at + 1)]
   }))
-  if (Object.keys(fields).some(key => !['cli','model','effort','provider'].includes(key)) || !fields.cli || !fields.model)
-    throw new Error('Fallback uses cli=EXECUTOR,model=MODEL[,effort=EFFORT][,provider=ID]')
+  if (Object.keys(fields).some(key => !['cli','model','auth-profile','effort','provider'].includes(key)) || !fields.cli || !fields.model)
+    throw new Error('Fallback uses cli=EXECUTOR,model=MODEL[,auth-profile=NAME][,effort=EFFORT][,provider=ID]')
   const base = initialPreset(fields.cli)
-  const preset = executionOverrides(base.cli, {...base, ...(fields.provider ? {provider: fields.provider} : {})}, fields.model, fields.effort)
+  const preset = executionOverrides(base.cli, {...base, ...(fields.provider ? {provider: fields.provider} : {}),
+    ...(fields['auth-profile'] !== undefined ? {authProfile: fields['auth-profile']} : {})}, fields.model, fields.effort)
   const named = {...preset, id: `fallback-${index + 1}`, name: presetLabel(preset).slice(0, 80)}
   if (!isPreset(named)) throw new Error('Invalid fallback setup')
   return named
@@ -49,7 +50,7 @@ async function main() {
   create [ID] | edit ID --name NAME (--text TEXT | --text-file FILE | --script SCRIPT_ID [--arg=VALUE ...])
     --now | --at ISO_WITH_OFFSET | --every-seconds N | --cron 'MIN HOUR DAY MONTH WEEKDAY' --timezone IANA
     [--cli EXECUTOR] [--auth-profile NAME] [--model MODEL] [--effort <native-effort>]
-    [--fallback cli=EXECUTOR,model=MODEL[,effort=EFFORT][,provider=ID] ... | --clear-fallbacks]
+    [--fallback cli=EXECUTOR,model=MODEL[,auth-profile=NAME][,effort=EFFORT][,provider=ID] ... | --clear-fallbacks]
     [--preflight-file FILE | --clear-preflight]
     [--start ISO_WITH_OFFSET] [--until ISO_WITH_OFFSET] [--when unreviewed-failures]
   script list | show SCRIPT_ID | remove SCRIPT_ID
@@ -71,10 +72,14 @@ Failures default to unreviewed owner runs. Review records a diagnosis; it never
 A conditional review schedule consumes no model run when there are no unreviewed failures.
 New tasks capture the selected engine settings; edit preserves existing settings unless overridden.
 Every task requires a concrete saved model. Supply --model if the selected settings have none; existing tasks never fall back to chat or client defaults.
-Fallbacks (at most ${MAX_FALLBACKS}, in order) run only when the previous setup's CLI is unavailable or its provider
-rejected the turn before any work began. Access denial, unknown errors, cancellation and failure after work began stop
-the chain; nothing is replayed. A quota rejection skips later setups of the same client or provider (quota scope),
-even with different credentials. The run records each attempt, setup, failure category and any reported reset time.
+Fallbacks run in the saved order only when the previous setup's CLI is unavailable or its provider
+rejected the turn before any work began, including an unavailable login. A Claude usage limit the run ended on
+after work began continues on the next setup in a fresh session, told the stopped session and that its work may be
+partly applied. Account/organization access denial, unknown errors, cancellation and other failures after work
+began stop the chain; nothing is replayed.
+A login or quota rejection skips later setups of the same native login profile
+or upstream provider. Named profiles must be owner-provisioned logins for separate accounts; Ez never enables overage.
+The run records each attempt, setup, failure category and any reported reset time.
 Trigger runs an existing task once with its saved instructions, AI and delivery binding in a fresh session. Reuse the request key after an uncertain result; the regular schedule is unchanged.
 Creates a scheduled task. Instructions are text, never shell commands.
 Use --now to run once. Run completion is not delivery proof.
@@ -207,7 +212,8 @@ Cron uses numeric five-field syntax, lists/ranges/steps, and traditional day/wee
     const preset = executionOverrides(base.cli, v['auth-profile'] === undefined ? base : {...base, authProfile:v['auth-profile']}, v.model, v.effort)
     if (!isPreset(preset)) throw new Error('Invalid task AI selection')
     const fallbacks = v['clear-fallbacks'] ? undefined : v.fallback ? v.fallback.map(fallbackSetup) : previous?.fallbacks
-    if (preset.authProfile !== undefined) await provisionedHome(config.controlDir, preset.cli, preset.authProfile)
+    for (const setup of [preset, ...fallbacks ?? []])
+      if (setup.authProfile !== undefined) await provisionedHome(config.controlDir, setup.cli, setup.authProfile)
     result=await show(await scheduler.save({id:id || 's_'+randomUUID(),name:v.name || 'Task',
       preflight,
       originRunId:previousSchedule?.originRunId ?? caller?.scheduled?.originRunId ?? caller?.id,delivery,text:v.text || await readFile(v['text-file']!,'utf8'),when:v.when as 'unreviewed-failures' | undefined,trigger,enabled:true,owner,

package/src/scheduled-tasks.ts

@@ -1,5 +1,6 @@
 import { executionDefaults } from './model-policy.js'
-import { presetLabel } from './ai.js'
+import { presetLabel, type AiPreset } from './ai.js'
+import { AUTH_PROFILE_CLIS } from './auth-profile.js'
 import type { Owner } from './control-state.js'
 import type { Schedule, ActiveSchedule } from './scheduler.js'
 
@@ -11,15 +12,45 @@ const ownsSchedule = (owner: Owner, schedule: Schedule) =>
 // Saved schedules created under an earlier model policy remain inspectable. The
 // executor will apply the same defaults (and enforce its current policy) when
 // it starts the run; an outdated saved selection must not hide every menu row.
-const displayedPreset = (execution: NonNullable<Schedule['execution']>) => {
-  try { return executionDefaults(execution.preset.cli, execution.preset) }
-  catch { return execution.preset }
+const displayedPreset = (preset: AiPreset) => {
+  try { return executionDefaults(preset.cli, preset) }
+  catch { return preset }
+}
+
+const setupLabel = (preset: AiPreset) => {
+  const label = presetLabel(displayedPreset(preset))
+  return AUTH_PROFILE_CLIS.includes(preset.cli) && preset.authProfile === undefined
+    ? `${preset.cli} (default login)${label.slice(preset.cli.length)}` : label
 }
 
 // Script schedules have no AI preset; show what core actually invokes.
 const engineLabel = (schedule: ActiveSchedule) => schedule.script
   ? `Script · ${schedule.script.id} · ${schedule.scriptRevision ? `rev ${schedule.scriptRevision.slice(0, 8)}` : 'not registered'}`
-  : presetLabel(displayedPreset(schedule.execution!))
+  : [schedule.execution!.preset, ...schedule.execution!.fallbacks ?? []].map(setupLabel).join(' → ')
+
+const every = (count: number, unit: string) => `Every ${count === 1 ? '' : `${count} `}${unit}${count === 1 ? '' : 's'}`
+const frequency = (schedule: Schedule) => {
+  const trigger = schedule.trigger
+  if ('at' in trigger) return 'Once'
+  if ('everySeconds' in trigger) {
+    const seconds = trigger.everySeconds
+    for (const [size, unit] of [[86400,'day'],[3600,'hour'],[60,'minute']] as const)
+      if (seconds % size === 0) return every(seconds / size, unit)
+    return every(seconds, 'second')
+  }
+  const cron = trigger.cron.trim().replace(/\s+/g, ' ')
+  const [minute, hour, day, month, weekday] = cron.split(' ')
+  let label = `Cron ${cron}`
+  if (`${hour} ${day} ${month} ${weekday}` === '* * * *') {
+    const step = /^\*\/(\d+)$/.exec(minute)
+    if (minute === '*') label = 'Every minute'
+    else if (step && Number(step[1]) > 0 && 60 % Number(step[1]) === 0) label = every(Number(step[1]), 'minute')
+    else if (/^\d+$/.test(minute)) label = `Hourly at :${minute.padStart(2,'0')}`
+  } else if (/^\d+$/.test(minute) && /^\d+$/.test(hour) && day === '*' && month === '*' && ['*','1-5'].includes(weekday)) {
+    label = `${weekday === '*' ? 'Daily' : 'Weekdays'} at ${hour.padStart(2,'0')}:${minute.padStart(2,'0')}`
+  }
+  return `${label} · ${trigger.timezone}`
+}
 
 const weekdays = ['Sun','Mon','Tue','Wed','Thu','Fri','Sat']
 const months = ['Jan','Feb','Mar','Apr','May','Jun','Jul','Aug','Sep','Oct','Nov','Dec']
@@ -52,8 +83,8 @@ export const ownedScheduledTasks = (schedules: ActiveSchedule[], owner: Owner) =
 export const scheduledTasksText = (schedules: ActiveSchedule[], owner: Owner) => {
   const owned = ownedScheduledTasks(schedules, owner)
   if (!owned.length) return '📅 Scheduled tasks\n\nNo active scheduled tasks.'
-  return [`📅 Scheduled tasks · ${owned.length} active`, 'All times UTC. Use /tasks 1 for task details.', ...owned.map((schedule, index) =>
-    `${index + 1} · ${schedule.name}\n  ${currentState(schedule)}\n  Next · ${schedule.nextAt === null ? '—' : time(schedule.nextAt)}\n  Last · ${lastRun(schedule)}\n  ${engineLabel(schedule)}\n  ${preview(schedule)}`
+  return [`📅 Scheduled tasks · ${owned.length} active`, 'Next/last times UTC. Use /tasks 1 for task details.', ...owned.map((schedule, index) =>
+    `${index + 1} · ${schedule.name}\n  ${currentState(schedule)}\n  Schedule · ${frequency(schedule)}\n  Next · ${schedule.nextAt === null ? '—' : time(schedule.nextAt)}\n  Last · ${lastRun(schedule)}\n  Execution · ${engineLabel(schedule)}\n  ${preview(schedule)}`
   )].join('\n\n')
 }
 
@@ -64,13 +95,16 @@ export const scheduledTaskDetailText = (schedule: ActiveSchedule, number: number
     `📅 ${number}${total === undefined ? '' : ` of ${total}`} · ${schedule.name}`,
     currentState(schedule),
     '',
+    'Schedule',
+    frequency(schedule),
+    '',
     'Next run',
     schedule.nextAt === null ? '—' : time(schedule.nextAt),
     '',
     'Last run',
     lastRun(schedule),
     '',
-    schedule.script ? 'Execution' : 'Engine',
+    'Execution path',
     engineLabel(schedule),
     '',
     schedule.script ? 'Script arguments' : 'Instructions',

package/src/scheduler.ts

@@ -144,7 +144,7 @@ export class Scheduler {
         assertScheduledModel(preset.model)
         assertEffort(preset.effort, preset.model, preset.cli)
       }
-      const key = (p: AiPreset) => JSON.stringify([p.cli, p.provider, p.model, p.effort])
+      const key = (p: AiPreset) => JSON.stringify([p.cli, p.authProfile, p.provider, p.model, p.effort])
       if (new Set(setups.map(key)).size !== setups.length) throw new Error('Task setups must be distinct')
       s = {...input, execution, trigger:validateTrigger(input.trigger),version:1,revision:randomUUID()}
     }

package/src/session-close.ts

@@ -0,0 +1,17 @@
+import type { SessionState, Owner } from './control-state.js'
+import { ownerId, ownerEpoch } from './control-state.js'
+import type { RunStore, RunRecord } from './runs.js'
+
+// A chat conversation has no native end. Before one is replaced, its engine
+// gets one silent turn in that same native session to keep durable facts in
+// the workspace. Ez only transports this literal; the engine decides whether
+// anything is written. No reply mechanism is offered, so nothing is delivered.
+// Owner conversations only: a close turn carries owner authority, so a private
+// application scope (which runs under its binding's narrower authority) gets none.
+export const SESSION_CLOSE_PROMPT = '[conversation closing] This conversation is ending. Save anything a future conversation will need where AGENTS.md says to keep memory; otherwise do nothing.'
+
+export async function queueSessionClose(runs: RunStore, owner: Owner | null, session: SessionState | null | undefined): Promise<RunRecord | undefined> {
+  if (!owner || !session?.hasStarted || !session.preset || session.applicationScope) return undefined
+  return runs.create({ ownerId: ownerId(owner), ownerEpoch: ownerEpoch(owner), texts: [SESSION_CLOSE_PROMPT],
+    execution: { sessionId: session.sessionId, preset: session.preset }, sessionClose: true })
+}

package/src/setup-fallback.ts

@@ -1,11 +1,12 @@
 import { presetLabel, presetProvider, type AiPreset, type ExecutionChoice } from './ai.js'
 
 // Ordered task setups for one scheduled occurrence. Core advances only on typed
-// evidence that the engine never started work: a missing CLI or a provider
-// rejection before any model output or tool item. Anything else stops the chain.
-export type StartupCategory = 'cli-unavailable' | 'quota' | 'provider-rejected' | 'access-denied'
+// evidence: a missing CLI or a provider rejection before any model output or
+// tool item, or a usage limit the run ended on after work began (continued in a
+// fresh session that is told so). Anything else stops the chain.
+export type StartupCategory = 'cli-unavailable' | 'login-unavailable' | 'quota' | 'provider-rejected' | 'access-denied'
 export type StartupRejection = { category: StartupCategory; resetAt?: string }
-export type AttemptCategory = StartupCategory | 'after-work-began' | 'uncertain' | 'same-quota-scope'
+export type AttemptCategory = StartupCategory | 'quota-after-work-began' | 'after-work-began' | 'uncertain' | 'same-quota-scope' | 'same-login-scope'
 export type SetupAttempt = {
   preset: AiPreset
   quotaScope: string
@@ -13,36 +14,54 @@ export type SetupAttempt = {
   category?: AttemptCategory
   resetAt?: string
   exitCode?: number | null
+  sessionId?: string
   startedAt?: string
   endedAt?: string
 }
 
-const categories: StartupCategory[] = ['cli-unavailable', 'quota', 'provider-rejected', 'access-denied']
-export const advances = (rejection?: StartupRejection): boolean => Boolean(rejection && rejection.category !== 'access-denied')
+const categories: StartupCategory[] = ['cli-unavailable', 'login-unavailable', 'quota', 'provider-rejected', 'access-denied']
+
+// A failed attempt's category and reset time, and whether the occurrence
+// continues on the next setup. Once work began only a quota limit the run ended
+// on continues; access denial, other failures and unknown outcomes stop.
+export const attemptFailure = ({ workBegan, rejection }: { workBegan: boolean; rejection?: StartupRejection }): { category: AttemptCategory; resetAt?: string; continues: boolean } => {
+  const resetAt = rejection?.resetAt ? { resetAt: rejection.resetAt } : {}
+  if (!workBegan) return rejection ? { category: rejection.category, ...resetAt, continues: rejection.category !== 'access-denied' } : { category: 'uncertain', continues: false }
+  return rejection?.category === 'quota' ? { category: 'quota-after-work-began', ...resetAt, continues: true } : { category: 'after-work-began', continues: false }
+}
+
+// Transport fact for a setup that continues an occurrence after an earlier setup
+// stopped at its usage limit once work had begun. Facts only, no guidance.
+export const continuationLine = (runId: string, attempts: SetupAttempt[]): string | undefined => {
+  const limited = attempts.filter(a => a.category === 'quota-after-work-began')
+  return limited.length ? `[run ${runId} continues: ${limited.map(a => `${presetLabel(a.preset)} began work in native session ${a.sessionId} and stopped at its usage limit${a.resetAt ? ` (resets ${a.resetAt})` : ''}`).join('; ')}. That work may be partly applied.]` : undefined
+}
 
 export const setupCandidates = (execution: ExecutionChoice): AiPreset[] => [execution.preset, ...(execution.fallbacks ?? [])]
 
-// Allowance is metered per provider account, not per credential file. Setups on
-// the same native client share a scope; OpenCode/Pi share their upstream
-// provider. A different credential alone never proves independent allowance.
+// The owner provisions native profiles for separate provider accounts. Models
+// in one login share its quota scope; another named login may be tried once.
+// OpenCode/Pi still share their upstream provider scope.
 export const quotaScope = (preset: AiPreset): string => {
   if (['opencode', 'pi'].includes(preset.cli)) {
     const provider = preset.cli === 'pi' ? preset.model?.split('/')[0] : presetProvider(preset)
     return provider ? `provider:${provider}` : preset.cli
   }
-  return preset.cli === 'codex-gui' ? 'codex' : preset.cli
+  const cli = preset.cli === 'codex-gui' ? 'codex' : preset.cli
+  return preset.authProfile ? `${cli}@${preset.authProfile}` : cli
 }
 
-// The next untried setup, skipping those whose quota scope already rejected
-// this occurrence. Each candidate is tried at most once.
+// The next untried setup, skipping a login that already rejected authentication
+// or reached its quota in this occurrence. Each candidate is tried at most once.
 export const nextSetup = (candidates: AiPreset[], attempts: SetupAttempt[]): { skipped: SetupAttempt[]; preset?: AiPreset } => {
-  const exhausted = new Set(attempts.filter(a => a.category === 'quota').map(a => a.quotaScope))
+  const exhausted = new Map(attempts.filter(a => ['quota', 'quota-after-work-began', 'login-unavailable'].includes(a.category!))
+    .map(a => [a.quotaScope, a.category === 'login-unavailable' ? 'same-login-scope' as const : 'same-quota-scope' as const]))
   const skipped: SetupAttempt[] = []
   for (const preset of candidates.slice(attempts.length)) {
     const scope = quotaScope(preset)
     if (!exhausted.has(scope)) return { skipped, preset }
     const at = new Date().toISOString()
-    skipped.push({ preset, quotaScope: scope, outcome: 'skipped', category: 'same-quota-scope', startedAt: at, endedAt: at })
+    skipped.push({ preset, quotaScope: scope, outcome: 'skipped', category: exhausted.get(scope), startedAt: at, endedAt: at })
   }
   return { skipped }
 }
@@ -57,20 +76,23 @@ const epochSeconds = (value: unknown): string | undefined =>
 
 const claudeErrors: Record<string, StartupCategory> = {
   rate_limit: 'quota', billing_error: 'quota',
-  authentication_failed: 'access-denied', oauth_org_not_allowed: 'access-denied', account_on_hold: 'access-denied',
+  authentication_failed: 'login-unavailable', oauth_org_not_allowed: 'access-denied', account_on_hold: 'access-denied',
   verification_required: 'access-denied', cloud_credential_error: 'access-denied',
   overloaded: 'provider-rejected', server_error: 'provider-rejected', model_not_found: 'provider-rejected', invalid_request: 'provider-rejected',
 }
 
+const httpRejection = (status: unknown): StartupCategory | undefined =>
+  typeof status !== 'number' ? undefined : status === 401 ? 'login-unavailable' : status === 429 ? 'quota' :
+    status === 403 ? 'access-denied' : [400, 404].includes(status) || status >= 500 ? 'provider-rejected' : undefined
+
 // Codex app-server `codexErrorInfo` of a failed turn.
 export const codexRejection = (info: unknown): StartupCategory | undefined => {
   if (info === 'usageLimitExceeded' || info === 'rateLimitExceeded') return 'quota'
-  if (info === 'unauthorized') return 'access-denied'
+  if (info === 'unauthorized') return 'login-unavailable'
   if (['serverOverloaded', 'internalServerError', 'badRequest', 'flexUnavailable'].includes(info as string)) return 'provider-rejected'
   if (!info || typeof info !== 'object') return undefined
   const status = (Object.values(info)[0] as { httpStatusCode?: unknown } | undefined)?.httpStatusCode
-  if (typeof status !== 'number') return undefined
-  return status === 429 ? 'quota' : [401, 403].includes(status) ? 'access-denied' : [400, 404].includes(status) || status >= 500 ? 'provider-rejected' : undefined
+  return httpRejection(status)
 }
 
 // The latest reset among exhausted Codex rate-limit windows.
@@ -85,29 +107,44 @@ export const startupLine = (state: { workBegan: boolean; rejection?: StartupReje
 // Reads structured stdout only: Ez transport summaries (`ez.startup`) and
 // Claude stream-json envelopes. Model text is never inspected. Any event that
 // is not known pre-work metadata counts as work, so ambiguity never advances.
+// The rejection is the one the run ended on: later work supersedes it, except
+// an access denial, which always stops the chain.
 export const startupObserver = () => {
   let buffer = '', workBegan = false, rejection: StartupRejection | undefined
+  const reject = (value: StartupRejection) => { if (rejection?.category !== 'access-denied') rejection = value }
+  const work = () => { workBegan = true; if (rejection?.category !== 'access-denied') rejection = undefined }
   const line = (text: string) => {
     if (!text.trim()) return
     let event: any
-    try { event = JSON.parse(text) } catch { workBegan = true; return }
+    try { event = JSON.parse(text) } catch { work(); return }
+    // A summary is the sender's current state; one without a rejection means
+    // work superseded an earlier one.
     if (event?.type === 'ez.startup') {
       if (event.workBegan === true) workBegan = true
-      const r = event.rejection
-      if (r && categories.includes(r.category) && (r.resetAt === undefined || Number.isFinite(Date.parse(r.resetAt))))
-        rejection = { category: r.category, ...(r.resetAt ? { resetAt: r.resetAt } : {}) }
+      const r = event.rejection, reset = typeof r?.resetAt === 'string' ? Date.parse(r.resetAt) : NaN
+      // Re-render the reset time: it reaches a continuation prompt, and
+      // Date.parse also accepts arbitrary words around a date.
+      if (r && categories.includes(r.category) && (r.resetAt === undefined || Number.isFinite(reset)))
+        reject({ category: r.category, ...(r.resetAt === undefined ? {} : { resetAt: new Date(reset).toISOString() }) })
+      else if (rejection?.category !== 'access-denied') rejection = undefined
       return
     }
     if (event?.type === 'thread.started' || event?.type === 'result' ||
         (event?.type === 'system' && event.subtype === 'init')) return
     if (event?.type === 'rate_limit_event') {
       const info = event.rate_limit_info
-      if (info?.status === 'rejected') rejection = { category: 'quota', ...(epochSeconds(info.resetsAt) ? { resetAt: epochSeconds(info.resetsAt) } : {}) }
+      if (info?.status === 'rejected') reject({ category: 'quota', ...(epochSeconds(info.resetsAt) ? { resetAt: epochSeconds(info.resetsAt) } : {}) })
       return
     }
+    // Native API retry/error metadata is not model output. Do not inspect error
+    // prose; only typed HTTP status can establish a rejected startup.
+    if (event?.type === 'system' && ['api_error', 'api_retry'].includes(event.subtype)) {
+      const category = httpRejection(event.subtype === 'api_retry' ? event.error_status : event.error?.status)
+      if (category) { reject({ category }); return }
+    }
     const category = event?.type === 'assistant' && typeof event.error === 'string' ? claudeErrors[event.error] : undefined
-    if (category) rejection = { category, ...(category === 'quota' && rejection?.resetAt ? { resetAt: rejection.resetAt } : {}) }
-    else workBegan = true
+    if (category) reject({ category, ...(category === 'quota' && rejection?.resetAt ? { resetAt: rejection.resetAt } : {}) })
+    else work()
   }
   return {
     write: (chunk: string) => {

package/src/tools-line.d.mts

@@ -0,0 +1 @@
+export declare const TOOLS_LINE: string

package/src/tools-line.mjs

@@ -0,0 +1,3 @@
+// The only package-written discovery text: seeded once into a new workspace
+// and left in place of a retired `ez tools` footer. Inventory is generated on read.
+export const TOOLS_LINE = 'Tools: run `ez tools list --details`; each plugin\'s `--help` gives usage.'

package/src/updates/binding.mjs

@@ -1,16 +1,9 @@
 import * as fs from 'node:fs/promises';
 import path from 'node:path';
-import { fileURLToPath, pathToFileURL } from 'node:url';
-import { atomic } from '../plugins/manager.mjs';
+import { fileURLToPath } from 'node:url';
+import { atomic, bindToolDiscovery } from '../plugins/manager.mjs';
 import { read } from './control.mjs';
 
-async function packageToolDiscovery(packageRoot,home,workspace) {
-  const entry=path.join(packageRoot,'src/plugins/manager.mjs');
-  const manager=await import(pathToFileURL(entry).href);
-  if(typeof manager.bindToolDiscovery!=='function')throw Error('Selected package has no tool discovery binding');
-  await manager.bindToolDiscovery(home,workspace);
-}
-
 export async function bindUpdates(home,hostConfig,packageRoot=fileURLToPath(new URL('../../',import.meta.url))) {
   home=await fs.realpath(home);hostConfig=await fs.realpath(hostConfig);
   const config=await read(path.join(home,'config.json')),host=await read(hostConfig),deploymentDir=path.dirname(hostConfig),agent=host.agents[0];
@@ -28,6 +21,7 @@ export async function bindUpdates(home,hostConfig,packageRoot=fileURLToPath(new
     const dest=path.join(bin,name);await fs.rm(dest,{force:true});
     await fs.writeFile(dest,`#!${process.execPath}\nimport fs from 'node:fs';import {spawn} from 'node:child_process';const c=JSON.parse(fs.readFileSync(${configFile}));const child=spawn(c.packageRoot+'/'+${JSON.stringify(entry)},process.argv.slice(2),{stdio:'inherit',env:{...process.env,EZ_DEPLOYMENT_DIR:c.deploymentDir,EZ_CONTROL_DIR:${JSON.stringify(agent.controlDir)}}});for(const s of ['SIGTERM','SIGINT'])process.on(s,()=>child.kill(s));child.on('error',e=>{console.error(e.message);process.exitCode=1});child.on('close',c=>process.exitCode=c??1);\n`,{mode:0o700});
   }
-  await packageToolDiscovery(packageRoot,home,config.workspace);
+  // Idempotent: retires a former `ez tools` footer, never writes guidance.
+  await bindToolDiscovery(home,config.workspace);
   return {ok:true,home,deploymentDir,packageRoot,policy:'Automatic compatible beta-channel updates by default; saved stable-only or manual policies take precedence. Local candidates require an explicit owner request.'};
 }

package/src/updates/control.mjs

@@ -191,7 +191,8 @@ export async function submit(home,id,automatic) {
     if(next.old.root!==job.previousRoot||next.old.pkg.version!==job.previousVersion)throw Error('Installation changed since preparation');
     if(digest(await fs.readFile(path.join(dir,'candidate.tgz')))!==job.sha256)throw Error('Candidate changed');
     job.status='queued';job.automatic=automatic;await atomic(path.join(dir,'job.json'),job);return job;
-  });
+  // Queueing writes only the job; activation drains plugin calls before switching.
+  },{allowInvocations:true,waitMs:5000});
 }
 export async function retryRecovery(home,id) {
   const {directory}=await state(home),dir=jobPath(home,id);
@@ -201,7 +202,7 @@ export async function retryRecovery(home,id) {
     if((await jobs(home)).some(j=>['queued','applying'].includes(j.status)))throw Error('An upgrade is already pending');
     await requireSupervisor(directory);
     job.status='queued';job.recoveryRequested=true;await atomic(path.join(dir,'job.json'),job);return {id,status:job.status,recoveryRequested:true};
-  });
+  },{allowInvocations:true,waitMs:5000});
 }
 export async function command(home,args) {
   const [action,...rest]=args;

package/src/updates/supervisor.mjs

@@ -139,7 +139,7 @@ export async function supervise(deployment,signal,{discover=check}={}) {
         const apply=async()=>{
           try {
             const activate=async()=>{const latest=await read(path.join(jobPath(home,pending.id),'job.json'));return perform(home,latest,{stopHost,startHost,signal,refreshPluginBroker});};
-            return pending.target==='main'?await locked(home,activate):await activate();
+            return pending.target==='main'?await locked(home,activate,{drainInvocations:true,signal}):await activate();
           } catch(error) {
             // A pre-switch rejection is terminal. Applying jobs keep their journal for recovery.
             const latest=await read(path.join(jobPath(home,pending.id),'job.json'));

package/src/workspace.ts

@@ -2,6 +2,17 @@ import { installAgentGuidance } from './agent-guidance.js'
 import { link, lstat, mkdir, readFile, rm, writeFile } from 'node:fs/promises'
 import { randomUUID } from 'node:crypto'
 import path from 'node:path'
+import { TOOLS_LINE } from './tools-line.mjs'
+
+// Engine-neutral memory: every native CLI loads AGENTS.md, so both read the
+// same plain files. The agent owns the folder and the section after seeding.
+const MEMORY_SEED = `## Memory
+
+Keep durable facts (people, preferences, decisions, standing commitments) in
+\`memory/\`, one fact per file, each listed on one line in \`memory/MEMORY.md\`.
+Read \`memory/MEMORY.md\` when a conversation starts. Save or update a fact as
+soon as you learn something a future conversation will need; skip what other
+workspace files already hold.`
 
 // Publish each complete seed exclusively. Reinstall never replaces the agent's mind.
 export const initializeWorkspace = async (workspace: string, purposeFile: string | undefined = process.env.EZ_AGENT_PURPOSE_FILE): Promise<string[]> => {
@@ -22,7 +33,7 @@ export const initializeWorkspace = async (workspace: string, purposeFile: string
   try {
     const purpose = (await readFile(purposeFile, 'utf8')).trim()
     if (!purpose) throw new Error('Purpose file must not be empty.')
-    await writeFile(temporary, `## Purpose\n\n${purpose}\n`, { mode: 0o600, flag: 'wx' })
+    await writeFile(temporary, `## Purpose\n\n${purpose}\n\n${MEMORY_SEED}\n\n${TOOLS_LINE}\n`, { mode: 0o600, flag: 'wx' })
     try {
       await link(temporary, target)
       created.push(name)