@jc_stack/ez-agents 0.1.0-beta.24 → 0.1.0-beta.26

package/CHANGELOG.md

@@ -1,5 +1,22 @@
 # Changelog
 
+## 0.1.0-beta.26
+
+- Start local software-maintenance wakeups in independent ephemeral sessions,
+  including after a relay restart, without trying to resume or persist a
+  normal owner conversation. This prevents successful upgrades from producing
+  false "failed to start" notifications across direct relays.
+
+## 0.1.0-beta.25
+
+- Enable Codex Luna `max` reasoning for durable work, schedules and deferred
+  owner handoffs. New durable work defaults to Luna/max while responsive chat
+  remains Sol/medium.
+- Preserve the strict cap for every other model and expose Luna/max from the
+  installed model catalog.
+- Persist Luna/max defaults in rollback-readable form; launch-time policy still
+  resolves Luna without an explicit effort to `max`.
+
 ## 0.1.0-beta.24
 
 - Preserve host-owned private plugin networks across generated Compose services,

package/docs/architecture/ai-selection.md

@@ -39,7 +39,7 @@ opaque wrappers remain explicitly “client default”. No credentials are store
 no inference runs, no new dependency, and no cross-CLI session transfer.
 
 New Codex CLI and desktop agents seed **Responsive chat** (`gpt-5.6-sol`,
-`medium`). Durable work keeps its independent `gpt-5.6-terra` / `high` default;
+`medium`). Durable work keeps its independent `gpt-5.6-luna` / `max` default;
 workers can explicitly select another model and effort for the job. Native
 choices for other executors remain unchanged. No fallback is selected when a
 model is unavailable.

package/docs/releasing.md

@@ -17,8 +17,9 @@ separate release bot is not required.
 3. Build both Docker targets from a clean checkout:
    `docker build --target test -t ez-release-tests .` and
    `docker build --target runtime -t ez-release-runtime .`.
-   Main: `EZ_RELAY_IMAGE=ez-release-runtime node docker/smoke.mjs`.
-   WhatsApp: `EZ_WHATSAPP_IMAGE=ez-release-runtime node docker/smoke.mjs`.
+   Main relay: `EZ_RELAY_IMAGE=ez-release-runtime node docker/smoke.mjs`.
+   The WhatsApp Compose overlay has no separate relay image; verify its
+   provider integration with the synthetic plugin smoke in `docs/plugins.md`.
 4. Create an artifact with `npm pack --ignore-scripts`. Inspect its file list,
    hash it, extract into a fresh directory, copy `docker/pnpm-lock.yaml` to
    `pnpm-lock.yaml`, and run `pnpm install --frozen-lockfile`.

package/docs/responsive-channels.md

@@ -8,12 +8,12 @@ the handoff is saved, instead of waiting for the worker. This is agent guidance,
 not a keyword classifier, automatic acknowledgement, or latency guarantee.
 
 New Codex agents use Sol / medium for chat. Scheduled work defaults independently
-to Terra / high; the agent can choose another model and effort for complex work.
-`ezenciel-agents-schedule create --now --text-file FILE --model MODEL --effort high`
+to Luna / max; the agent can choose another model and effort for complex work.
+`ezenciel-agents-schedule create --now --text-file FILE --model MODEL --effort max`
 uses the existing scheduler (include `--name` for a useful task label). Busy owner
 reply sessions expose the same independent model/effort choice through `defer`.
 Its retry returns the first saved schedule; changing arguments does not revise
-an accepted job. `xhigh` is available only for Luna; other models remain capped at high.
+an accepted job. `xhigh` and `max` are available only for Luna; other models remain capped at high.
 
 A handoff includes the objective, relevant context and paths, constraints,
 authorized actions, acceptance checks and delivery destination. Background

package/docs/scheduling.md

@@ -33,11 +33,11 @@ times fire once, at the earlier instant. Search is bounded to eight years.
 Public-holiday calendars and arbitrary RRULE syntax are not implemented.
 
 New tasks, including work deferred by a busy reply session, default to Codex
-`gpt-5.6-terra` with `high` reasoning independently of the creating chat.
+`gpt-5.6-luna` with `max` reasoning independently of the creating chat.
 New chats use the separate Sol/medium preset. Busy reply `defer` accepts optional
 `model` and `effort` fields; retries preserve the first saved task choice.
-Use `--cli`, `--model`, and `--effort` to specify another choice. `xhigh` is
-available only with Codex `gpt-5.6-luna`; every other model remains capped at
+Use `--cli`, `--model`, and `--effort` to specify another choice. `xhigh` and
+`max` are available only with Codex `gpt-5.6-luna`; every other model remains capped at
 `high`. Non-Codex adapters inherit native effort when unset. Editing preserves the existing AI
 choice unless those flags override it. Stored choices are checked again at
 launch, including schedules saved before a policy change.

package/docs/setup.md

@@ -56,17 +56,17 @@ New agents using `codex` or `codex-gui` start with `gpt-5.6-sol` and `medium`
 reasoning, including when initialized with `ezenciel-agents-setup init`. This
 Ez default takes precedence over discovered host client defaults. Saved agent
 selections permitted by the current policy are preserved; use the AI settings to choose another model or effort.
-Ez accepts `xhigh` only for `gpt-5.6-luna`; every other model rejects explicit
+Ez accepts `xhigh` and `max` only for `gpt-5.6-luna`; every other model rejects explicit
 reasoning above `high` at selection and execution, including old saved or queued choices.
 Unset Codex model/effort resolves to
-Terra/high at launch. This governs Ez-managed launches; it is not an account-wide
+Luna/max at launch. This governs Ez-managed launches; it is not an account-wide
 limit on independently launched native clients or executor-created native subagents.
 Other adapters inherit their native effort when none is selected in Ez. That
 inherited configuration is not capped by Ez; explicit above-high Ez selections
-are rejected unless they are Codex Luna/xhigh. Conversation presets pin Sol/medium; the lower-level
-Codex fallback remains Terra/high for work without an explicit choice.
+are rejected unless they are Codex Luna/xhigh or Luna/max. Conversation presets pin Sol/medium; the lower-level
+Codex fallback is Luna/max for work without an explicit choice.
 
-New scheduled and one-off background tasks default to Codex Terra/high independently
+New scheduled and one-off background tasks default to Codex Luna/max independently
 of the creating chat. Use scheduler `--cli`, `--model`, and `--effort` flags for
 explicit overrides. Editing a schedule preserves its settings unless overridden.
 Restricted messaging tasks use Sol/medium while retaining their approved tool

package/docs/upgrades.md

@@ -185,6 +185,12 @@ written by the new one. Increment it for incompatible writes; this updater will
 refuse that migration. `mainProtocol` identifies the supported updater/registry
 contract, currently 1. Plugin package and manifest versions must match.
 
+The Luna/max durable default keeps this contract: persisted Codex Luna presets
+omit the effort field so older runtimes can read and fail over to their native
+safe default, while the current launcher resolves an omitted Luna effort to
+`max`. The execution choice, rather than the storage encoding, is the policy
+surface.
+
 Verify upgrade from the previous supported artifact, retained identity/state,
 failed-health rollback, and rejection of incompatible candidates. Main runtime
 changes also need supervisor restart and requesting-process-exit tests. Run

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jc_stack/ez-agents",
-  "version": "0.1.0-beta.24",
+  "version": "0.1.0-beta.26",
   "private": false,
   "type": "module",
   "description": "A lightweight foundation for persistent business AI assistants using existing AI harnesses, workspaces and plugins.",

package/src/ai.ts

@@ -21,7 +21,9 @@ 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))
 }
-export const presetLabel = (p: AiPreset) => `${p.cli} · ${p.model || 'client default'} · ${p.effort || 'default effort'}`
+export const presetLabel = (p: AiPreset) => `${p.cli} · ${p.model || 'client default'} · ${p.effort || (
+  ['codex', 'codex-gui'].includes(p.cli) && p.model === 'gpt-5.6-luna' ? DEFAULT_EFFORT : 'default effort'
+)}`
 // The seed delegates model selection to the native client. Project its resolved
 // settings for status without pinning future conversations to that snapshot.
 export const statusPreset = (preset: AiPreset, discovered: AiPreset[]): AiPreset =>
@@ -39,6 +41,14 @@ export const initialPreset = (cli: string): AiPreset => {
   }
 }
 
+// Keep persisted state readable by older releases. Luna/max is an execution
+// default; the launcher resolves an omitted Luna effort back to max.
+export const persistedPreset = (preset: AiPreset): AiPreset => {
+  if (!['codex', 'codex-gui'].includes(preset.cli) || preset.model !== 'gpt-5.6-luna' || preset.effort !== 'max') return preset
+  const { effort: _effort, ...rollbackReadable } = preset
+  return rollbackReadable
+}
+
 // Conversation defaults are independent of durable work and explicit saved choices.
 export const chatPreset = (cli: string): AiPreset => {
   const preset = initialPreset(cli)

package/src/control-state.ts

@@ -1,7 +1,7 @@
 import { assertEffort } from './model-policy.js'
 import { mkdir, open, readFile, rename, rm, writeFile } from 'node:fs/promises'
 import path from 'node:path'
-import { isPreset, type AiPreset, type ExecutionChoice } from './ai.js'
+import { isPreset, persistedPreset, type AiPreset, type ExecutionChoice } from './ai.js'
 
 export type Owner = {
   kind?: 'group'
@@ -94,6 +94,7 @@ export class ControlStore {
     try {
       const parsed: unknown = JSON.parse(await readFile(this.statePath, 'utf8'))
       if (!isState(parsed)) throw new Error('Control state has an unsupported shape')
+      if (parsed.ai) parsed.ai.presets = parsed.ai.presets.map(persistedPreset)
       return parsed
     } catch (error: unknown) {
       if ((error as NodeJS.ErrnoException).code === 'ENOENT') return emptyState()
@@ -261,7 +262,7 @@ export class ControlStore {
   async aiState(initial: AiPreset) {
     return this.withLock(async () => {
       const state = await this.readState()
-      state.ai ??= { presets: [initial], defaultId: initial.id, selectedId: initial.id }
+      state.ai ??= { presets: [persistedPreset(initial)], defaultId: initial.id, selectedId: initial.id }
       await this.writeState(state)
       return state.ai
     })
@@ -273,13 +274,13 @@ export class ControlStore {
       const state = await this.readState()
       const first = initial.cli === 'codex' || initial.cli === 'codex-gui'
         ? initial : discovered.find((p) => p.cli === initial.cli) ?? initial
-      state.ai ??= { presets: [first], defaultId: first.id, selectedId: first.id }
+      state.ai ??= { presets: [persistedPreset(first)], defaultId: first.id, selectedId: first.id }
       const ai = state.ai
       // Refresh discovery entries, but never rewrite an active/default or user-saved choice.
       const preserved = ai.presets.filter((p) => !p.id.startsWith('detected_') ||
-        p.id === ai.selectedId || p.id === ai.defaultId)
-      ai.presets = [...preserved, ...discovered.filter((p) => !preserved.some((old) => old.id === p.id))]
-      if (initial.id === 'chat-default' && !ai.presets.some(p => p.id === initial.id)) ai.presets.push(initial)
+        p.id === ai.selectedId || p.id === ai.defaultId).map(persistedPreset)
+      ai.presets = [...preserved, ...discovered.map(persistedPreset).filter((p) => !preserved.some((old) => old.id === p.id))]
+      if (initial.id === 'chat-default' && !ai.presets.some(p => p.id === initial.id)) ai.presets.push(persistedPreset(initial))
       await this.writeState(state)
     })
   }
@@ -287,7 +288,7 @@ export class ControlStore {
   async captureChoice(initial: AiPreset): Promise<ExecutionChoice> {
     return this.withLock(async () => {
       const state = await this.readState()
-      state.ai ??= { presets: [initial], defaultId: initial.id, selectedId: initial.id }
+      state.ai ??= { presets: [persistedPreset(initial)], defaultId: initial.id, selectedId: initial.id }
       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
@@ -331,7 +332,7 @@ export class ControlStore {
       if (!state.ai) throw new Error('AI settings not initialized')
       if (state.ai.presets.length >= 12 && !state.ai.presets.some((p) => p.id === preset.id))
         throw new Error('Keep it small: at most 12 saved AIs.')
-      state.ai.presets = [...state.ai.presets.filter((p) => p.id !== preset.id), preset]
+      state.ai.presets = [...state.ai.presets.filter((p) => p.id !== preset.id), persistedPreset(preset)]
       await this.writeState(state)
     })
   }

package/src/index.ts

@@ -31,7 +31,7 @@ import { transcribeAudio, synthesizeSpeech } from './audio.js'
 import { normalizeReactionEmoji } from './reaction.js'
 import { downloadTelegramFile } from './read-request.js'
 import { createAiMenu, mainCommands, mainKeyboard } from './menu.js'
-import { chatPreset, presetLabel, statusPreset } from './ai.js'
+import { chatPreset, initialPreset, persistedPreset, presetLabel, statusPreset } from './ai.js'
 import { discoverDefaults } from './client-defaults.js'
 import { initializeWorkspace } from './workspace.js'
 import { softwareStatus } from './software-status.js'
@@ -65,6 +65,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
   let drainTimer: ReturnType<typeof setInterval> | undefined
   const codexHome = join(config.controlDir, 'cli', 'codex')
   const aiMenu = createAiMenu(control, config.executorCli, undefined, config.workspace, codexHome)
+  const durableWorkerChoice = () => ({ sessionId: randomUUID(), preset: persistedPreset(initialPreset('codex')) })
   const binDir = join(dirname(fileURLToPath(import.meta.url)), '..', 'bin')
   const pagerDuty = config.pagerDutyRoutingKey && config.pagerDutyStocksHealthUrl
     ? new PagerDutyStocksMonitor({
@@ -192,7 +193,9 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         const launchStarted = performance.now()
         const started = await runs.patch(run.id, { status: 'running', startedAt: new Date().toISOString() })
         if (!started.execution && !run.taskId) throw new Error('Legacy queued work has no pinned AI. Resend the request after /new.')
-        const session = run.external || run.taskId || run.scheduled || run.replyOnly
+        const maintenanceWakeup = run.id.startsWith('r_update_')
+        const startsOwnSession = Boolean(run.external || run.taskId || run.scheduled || run.replyOnly || maintenanceWakeup)
+        const session = startsOwnSession
           ? { sessionId: randomUUID(), hasStarted: false, nativeSessionId: undefined }
           : await control.executionSession(started.execution!)
         const selected = run.taskId ? chatPreset('codex') : started.execution!.preset
@@ -210,7 +213,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           sessionId: session.nativeSessionId || session.sessionId,
           isResume: session.hasStarted,
           eventSource: run.external?.sourceId,
-          onSession: run.external || run.taskId || run.replyOnly ? undefined : async (id) => { await runs.patch(run.id,{nativeSessionId:id}); if (!run.scheduled) await control.saveNativeSession(session.sessionId,id) },
+          onSession: run.external || run.taskId || run.replyOnly || maintenanceWakeup ? undefined : async (id) => { await runs.patch(run.id,{nativeSessionId:id}); if (!run.scheduled) await control.saveNativeSession(session.sessionId,id) },
         })
         const executionStarted = performance.now()
         // Attach before disk writes: a fast child can close while PID persistence
@@ -310,7 +313,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       for (const task of await tasks.list()) if (task.state === 'pending' || task.state === 'active' || task.unwatchPending) {
         try { await tasks.decide(task.id) } catch { /* Failed or stale grants cannot launch. */ }
       }
-      await queueUpdateAttention(config.controlDir,owner,runs,await control.captureChoice(aiMenu.initial))
+      await queueUpdateAttention(config.controlDir,owner,runs,durableWorkerChoice())
       }
       for (const source of config.channelBackendUrl ? [] : await sources.available(owner)) {
         try {
@@ -327,7 +330,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
               await runs.create({
               taskId: task?.id,
               id: eventRunId(source, events), chatId: owner.telegramChatId, telegramUserId: owner.telegramUserId,
-              texts: [], execution: await control.captureChoice(aiMenu.initial),
+              texts: [], execution: durableWorkerChoice(),
               external: { sourceId: source.id, bindingId: source.bindingId, eventIds: events.map(e => e.id) },
             })
             }

package/src/model-policy.ts

@@ -1,18 +1,33 @@
 export const CODEX_CHAT_MODEL = 'gpt-5.6-sol'
 export const CHAT_EFFORT = 'medium'
-export const CODEX_DEFAULT_MODEL = 'gpt-5.6-terra'
-export const DEFAULT_EFFORT = 'high'
+export const CODEX_DEFAULT_MODEL = 'gpt-5.6-luna'
+export const DEFAULT_EFFORT = 'max'
 export const allowedEffort = (effort?: string, model?: string, cli?: string) => effort === undefined ||
   ['none', 'minimal', 'low', 'medium', 'high'].includes(effort) ||
-  (effort === 'xhigh' && model === 'gpt-5.6-luna' && ['codex', 'codex-gui'].includes(cli || ''))
+  (['xhigh', 'max'].includes(effort) && model === 'gpt-5.6-luna' && ['codex', 'codex-gui'].includes(cli || ''))
 export function assertEffort(effort?: string, model?: string, cli?: string) {
-  if (!allowedEffort(effort, model, cli)) throw new Error('Reasoning effort is capped at high, except Codex Luna/xhigh; choose none, minimal, low, medium, high, or xhigh with gpt-5.6-luna.')
+  if (!allowedEffort(effort, model, cli)) throw new Error('Reasoning effort is capped at high, except Codex Luna/xhigh/max; choose none, minimal, low, medium, high, xhigh, or max with gpt-5.6-luna.')
 }
 export function executionDefaults<T extends { model?: string; effort?: string }>(cli: string, options: T): T {
   assertEffort(options.effort, options.model, cli)
+  const model = options.model || CODEX_DEFAULT_MODEL
   return { ...options,
-    ...(['codex', 'codex-gui'].includes(cli) ? { model: options.model || CODEX_DEFAULT_MODEL } : {}),
+    ...(['codex', 'codex-gui'].includes(cli) ? { model } : {}),
     ...(['codex', 'codex-gui'].includes(cli)
-      ? { effort: options.effort || DEFAULT_EFFORT } : {}),
+      ? { effort: options.effort || (model === 'gpt-5.6-luna' ? DEFAULT_EFFORT : 'high') } : {}),
   }
 }
+
+export function executionOverrides<T extends { model?: string; effort?: string }>(
+  cli: string,
+  base: T,
+  model?: string,
+  effort?: string,
+): T {
+  const options = {
+    ...base,
+    ...(model !== undefined ? { model, ...(effort === undefined ? { effort: undefined } : {}) } : {}),
+    ...(effort !== undefined ? { effort } : {}),
+  } as T
+  return executionDefaults(cli, options)
+}

package/src/reply-context.ts

@@ -1,4 +1,4 @@
-import { assertEffort } from './model-policy.js'
+import { executionOverrides } from './model-policy.js'
 import { randomUUID } from 'node:crypto'
 import { initialPreset, isPreset } from './ai.js'
 import { readFile, readdir, lstat } from 'node:fs/promises'
@@ -40,9 +40,8 @@ export async function replyCall(controlDir: string, runId: string, workspace: st
   if (name === 'send') return runs.enqueueMessage(runId, args.text, { id: `${runId}_busy_reply`, replyToMessageId: run.messageId })
   if (name === 'defer') {
     if (!run.execution) throw new Error('Missing execution choice')
-    const preset = { ...initialPreset('codex'), ...(args.model !== undefined ? { model: args.model } : {}), ...(args.effort !== undefined ? { effort: args.effort } : {}) }
+    const preset = executionOverrides('codex', initialPreset('codex'), args.model as string | undefined, args.effort as string | undefined)
     if (!isPreset(preset)) throw new Error('Invalid worker model or effort')
-    assertEffort(preset.effort, preset.model, preset.cli)
     const owner = (await new ControlStore(controlDir, 900000).status()).owner!
     const scheduler = new Scheduler(controlDir), id = `s_reply_${runId}`
     try { return { id: (await scheduler.get(id)).id } } catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }

package/src/reply-mcp.ts

@@ -3,7 +3,7 @@ import { replyCall } from './reply-context.js'
 const [controlDir, runId, workspace] = process.argv.slice(2)
 const tools = [
   { name: 'context', description: 'Read this owner request, recent conversation, active and historical runs, and task progress.', inputSchema: { type: 'object', properties: {}, additionalProperties: false } },
-  ...['send', 'defer'].map(name => ({ name, description: name === 'send' ? 'Send one answer to the paired owner. Repeated calls reuse the same receipt.' : 'Queue the current owner request for a writer session. Include needed context and acceptance checks in text. Optional model and effort select the worker independently; defaults are gpt-5.6-terra/high. Repeated calls return the same schedule.', inputSchema: { type: 'object', properties: { text: { type: 'string', maxLength: 8000 }, ...(name === 'defer' ? { model: { type: 'string', maxLength: 160 }, effort: { type: 'string', enum: ['none', 'minimal', 'low', 'medium', 'high'] } } : {}) }, required: ['text'], additionalProperties: false } })),
+  ...['send', 'defer'].map(name => ({ name, description: name === 'send' ? 'Send one answer to the paired owner. Repeated calls reuse the same receipt.' : 'Queue the current owner request for a writer session. Include needed context and acceptance checks in text. Optional model and effort select the worker independently; defaults are gpt-5.6-luna/max. Repeated calls return the same schedule.', inputSchema: { type: 'object', properties: { text: { type: 'string', maxLength: 8000 }, ...(name === 'defer' ? { model: { type: 'string', maxLength: 160 }, effort: { type: 'string', enum: ['none', 'minimal', 'low', 'medium', 'high', 'xhigh', 'max'] } } : {}) }, required: ['text'], additionalProperties: false } })),
 ]
 for await (const line of createInterface({ input: process.stdin })) {
   let request: any

package/src/schedule-cli.ts

@@ -6,6 +6,7 @@ import { loadControlConfig } from './config.js'
 import { ControlStore } from './control-state.js'
 import { RunStore } from './runs.js'
 import { initialPreset, isPreset } from './ai.js'
+import { executionOverrides } from './model-policy.js'
 import { Scheduler } from './scheduler.js'
 import { ownsRun } from './identity.js'
 import { nextOccurrence, type Trigger } from './schedule-time.js'
@@ -22,11 +23,11 @@ async function main() {
   review RUN_ID --failed-at ISO --status resolved|attention --diagnosis TEXT --recovery TEXT --outcome TEXT
   create [ID] | edit ID --name NAME (--text TEXT | --text-file FILE)
     --now | --at ISO_WITH_OFFSET | --every-seconds N | --cron 'MIN HOUR DAY MONTH WEEKDAY' --timezone IANA
-    [--cli EXECUTOR] [--model MODEL] [--effort none|minimal|low|medium|high|xhigh (Luna only)]
+    [--cli EXECUTOR] [--model MODEL] [--effort none|minimal|low|medium|high|xhigh|max (Luna only)]
     [--start ISO_WITH_OFFSET] [--until ISO_WITH_OFFSET] [--when unreviewed-failures]
 Failures default to unreviewed owner runs. Review records a diagnosis; it never changes execution status or retries work.
 A conditional review schedule consumes no model run when there are no unreviewed failures.
-New tasks default to Codex Terra/high, independently of the current chat. Explicit settings override these defaults; edit preserves existing settings unless overridden.
+New tasks default to Codex Luna/max, independently of the current chat. Explicit settings override these defaults; edit preserves existing settings unless overridden.
 Creates a durable, asynchronous CLI task. Instructions are text, never shell commands.
 Use --now to delegate long work and return to chat. Run completion is not delivery proof.
 Edit replaces the full schedule. Pause/remove affect future work; cancel stops a particular run.
@@ -73,7 +74,7 @@ Cron uses numeric five-field syntax, lists/ranges/steps, and traditional day/wee
       v.cron ? {cron:v.cron,timezone:v.timezone!,start,until:v.until} : {everySeconds:Number(v['every-seconds']),start,until:v.until}
     const previous = action === 'edit' ? (await scheduler.get(id!)).execution : undefined
     const base = v.cli ? initialPreset(v.cli) : previous?.preset || initialPreset('codex')
-    const preset = {...base, ...(v.model ? {model:v.model} : {}), ...(v.effort ? {effort:v.effort} : {})}
+    const preset = executionOverrides(base.cli, base, v.model, v.effort)
     if (!isPreset(preset)) throw new Error('Invalid task AI selection')
     result=await show(await scheduler.save({id:id || 's_'+randomUUID(),name:v.name || 'Task',
       text:v.text || await readFile(v['text-file']!,'utf8'),when:v.when as 'unreviewed-failures' | undefined,trigger,enabled:true,owner,

package/src/scheduler.ts

@@ -5,7 +5,7 @@ import { randomUUID, createHash } from 'node:crypto'
 import { join } from 'node:path'
 import type { Owner } from './control-state.js'
 import { assertId, ownsRun } from './identity.js'
-import { type ExecutionChoice, isExecutionChoice } from './ai.js'
+import { type ExecutionChoice, isExecutionChoice, persistedPreset } from './ai.js'
 import { type Trigger, validateTrigger, nextOccurrence } from './schedule-time.js'
 import { RunStore, type RunRecord } from './runs.js'
 
@@ -64,9 +64,10 @@ export class Scheduler {
   async save(input: Omit<Schedule,'version'|'revision'>, exclusive = false): Promise<Schedule> {
     await this.ensure(); assertId(input.id)
     if (input.when !== undefined && input.when !== 'unreviewed-failures') throw new Error('Unknown schedule condition')
-    if (!input.name || !input.text?.trim() || !isExecutionChoice(input.execution)) throw new Error('Schedule needs name, text and an AI selection')
-    assertEffort(input.execution.preset.effort, input.execution.preset.model, input.execution.preset.cli)
-    const s: Schedule = {...input,trigger:validateTrigger(input.trigger),version:1,revision:randomUUID()}
+    const execution: ExecutionChoice = {...input.execution, preset: persistedPreset(input.execution.preset)}
+    if (!input.name || !input.text?.trim() || !isExecutionChoice(execution)) throw new Error('Schedule needs name, text and an AI selection')
+    assertEffort(execution.preset.effort, execution.preset.model, execution.preset.cli)
+    const s: Schedule = {...input, execution, trigger:validateTrigger(input.trigger),version:1,revision:randomUUID()}
     if (nextOccurrence(s.trigger,Date.now()-1) === null) throw new Error('Schedule has no future occurrence within eight years')
     await atomic(join(this.dir,s.id+'.json'),s,exclusive)
     return s

package/test/ai.test.ts

@@ -8,6 +8,7 @@ import { initialPreset, chatPreset, readModels, isPreset } from '../src/ai.js'
 import { createAiMenu } from '../src/menu.js'
 import { EXECUTOR_REGISTRY, nativeSessionId } from '../src/executor.js'
 import { InboxStore } from '../src/inbox.js'
+import { executionDefaults } from '../src/model-policy.js'
 import type { Update } from 'grammy/types'
 
 test('AI choices pin model, effort and session; defaults and CLI switches do not reroute old work', async () => {
@@ -87,7 +88,7 @@ test('model catalog projects native metadata only, excluding hidden entries and
     ] }))
     assert.deepEqual(await readModels(home, async (cli) => cli === 'codex'), [
       { cli: 'codex', model: 'fixture-model', name: 'Fixture', efforts: ['medium'] },
-      { cli: 'codex', model: 'gpt-5.6-luna', name: 'Luna', efforts: ['high', 'xhigh'] },
+      { cli: 'codex', model: 'gpt-5.6-luna', name: 'Luna', efforts: ['high', 'xhigh', 'max'] },
     ])
     assert.equal(isPreset({ id: 'x', name: 'x', cli: 'grok', model: '--shell escape' }), false)
   } finally { await rm(home, { recursive: true, force: true }) }
@@ -165,7 +166,7 @@ test('native executor flags carry the exact model and effort; only structured me
 })
 
 for (const cli of ['codex', 'codex-gui']) {
-  test(`${cli} initializes Terra high ahead of host defaults and preserves saved choices`, async () => {
+  test(`${cli} initializes Luna max ahead of host defaults and preserves saved choices`, async () => {
     const dir = await mkdtemp(join(tmpdir(), 'ez-ai-default-'))
     try {
       const store = new ControlStore(dir, 1000)
@@ -174,8 +175,9 @@ for (const cli of ['codex', 'codex-gui']) {
         model: 'host-model', effort: 'low' }]
       await store.syncClientPresets(initial, discovered)
       const first = await store.captureChoice(initial)
-      assert.equal(first.preset.model, 'gpt-5.6-terra')
-      assert.equal(first.preset.effort, 'high')
+      assert.equal(first.preset.model, 'gpt-5.6-luna')
+      assert.equal(first.preset.effort, undefined)
+      assert.equal(executionDefaults(cli, first.preset).effort, 'max')
       assert.equal(first.preset.cli, cli)
       const saved = { id: 'custom', name: 'Custom', cli, model: 'custom-model', effort: 'medium' }
       await store.savePreset(saved)
@@ -197,8 +199,8 @@ for (const cli of ['codex', 'codex-gui']) {
       const chat = await store.captureChoice(chatPreset(cli))
       assert.equal(chat.preset.model, 'gpt-5.6-sol')
       assert.equal(chat.preset.effort, 'medium')
-      assert.equal(initialPreset(cli).model, 'gpt-5.6-terra')
-      assert.equal(initialPreset(cli).effort, 'high')
+      assert.equal(initialPreset(cli).model, 'gpt-5.6-luna')
+      assert.equal(initialPreset(cli).effort, 'max')
       const old = initialPreset(cli)
       await store.savePreset(old)
       await store.defaultPreset(old.id)

package/test/client-defaults.test.ts

@@ -70,7 +70,7 @@ test('status projects the native client default without pinning the seed', () =>
   assert.deepEqual(statusPreset({ ...initial, id: 'detected_empty' }, [discovered]), discovered)
   const explicit = { ...discovered, id: 'saved', model: 'chosen-codex', effort: 'high' }
   assert.equal(statusPreset(explicit, [discovered]), explicit)
-  assert.equal(statusPreset(initialPreset('codex-gui'), [{ ...discovered, cli: 'codex-gui' }]).model, 'gpt-5.6-terra')
+  assert.equal(statusPreset(initialPreset('codex-gui'), [{ ...discovered, cli: 'codex-gui' }]).model, 'gpt-5.6-luna')
 })
 
 test('seed uses the configured executor; repeated refresh preserves current/default and queued snapshots', async () => {

package/test/model-policy.test.ts

@@ -3,10 +3,10 @@ import assert from 'node:assert/strict'
 import { mkdtemp, rm } from 'node:fs/promises'
 import { tmpdir } from 'node:os'
 import { join } from 'node:path'
-import { executionDefaults } from '../src/model-policy.js'
+import { executionDefaults, executionOverrides } from '../src/model-policy.js'
 import { startExecutorJob } from '../src/executor.js'
 import { ControlStore } from '../src/control-state.js'
-import { initialPreset, readModels, validateSelection } from '../src/ai.js'
+import { initialPreset, persistedPreset, readModels, validateSelection } from '../src/ai.js'
 import { taskArguments } from '../src/task-executor.js'
 import { runCodexSession } from '../src/codex-session.js'
 import { runDesktopTurn } from '../src/desktop-bridge.js'
@@ -23,24 +23,34 @@ test('all non-Luna model selections and launches reject effort above high before
   await assert.rejects(runDesktopTurn({workspace:'/unused',controlDir:'/unused',binDir:'/unused',runId:'unused',prompt:'',effort:'ultra'}), /capped at high/)
 })
 
-test('Codex Luna accepts xhigh while every other model and CLI remains capped', async () => {
-  const luna = { id:'luna', name:'Luna', cli:'codex', model:'gpt-5.6-luna', effort:'xhigh' }
-  await validateSelection(luna, [{ cli:'codex', model:'gpt-5.6-luna', name:'Luna', efforts:['high','xhigh'] }], async () => true)
-  assert.deepEqual(executionDefaults('codex', { model:'gpt-5.6-luna', effort:'xhigh' }), { model:'gpt-5.6-luna', effort:'xhigh' })
-  assert.throws(() => executionDefaults('grok', { model:'gpt-5.6-luna', effort:'xhigh' }), /capped at high/)
-  assert.throws(() => executionDefaults('codex', { model:'gpt-5.6-terra', effort:'xhigh' }), /capped at high/)
+test('Codex Luna accepts xhigh and max while every other model and CLI remains capped', async () => {
+  for (const effort of ['xhigh', 'max']) {
+    const luna = { id:'luna', name:'Luna', cli:'codex', model:'gpt-5.6-luna', effort }
+    await validateSelection(luna, [{ cli:'codex', model:'gpt-5.6-luna', name:'Luna', efforts:['high','xhigh','max'] }], async () => true)
+    assert.deepEqual(executionDefaults('codex', { model:'gpt-5.6-luna', effort }), { model:'gpt-5.6-luna', effort })
+    assert.throws(() => executionDefaults('grok', { model:'gpt-5.6-luna', effort }), /capped at high/)
+    assert.throws(() => executionDefaults('codex', { model:'gpt-5.6-terra', effort }), /capped at high/)
+  }
 })
 
-test('restricted tasks pin Terra high, preserve explicit choices and reject higher effort', () => {
+test('restricted tasks pin Luna max, preserve explicit choices and reject higher effort', () => {
   const args = taskArguments('/unused', ['broker'], 'prompt')
-  assert.equal(args[args.indexOf('--model')+1], 'gpt-5.6-terra')
-  assert.ok(args.includes('model_reasoning_effort="high"'))
+  assert.equal(args[args.indexOf('--model')+1], 'gpt-5.6-luna')
+  assert.ok(args.includes('model_reasoning_effort="max"'))
   const custom = taskArguments('/unused', ['broker'], 'prompt', undefined, {model:'custom-model',effort:'low'})
   assert.equal(custom[custom.indexOf('--model')+1], 'custom-model')
   assert.ok(custom.includes('model_reasoning_effort="low"'))
   assert.throws(() => taskArguments('/unused', ['broker'], 'prompt', undefined, {effort:'xhigh'}), /capped at high/)
   assert.deepEqual(executionDefaults('codex', {model:'custom-model',effort:'medium'}), {model:'custom-model',effort:'medium'})
-  assert.deepEqual(executionDefaults('codex', {}), {model:'gpt-5.6-terra',effort:'high'})
+  assert.deepEqual(executionDefaults('codex', {model:'gpt-6-astra'}), {model:'gpt-6-astra',effort:'high'})
+  assert.deepEqual(executionDefaults('codex', {model:'gpt-5.6-terra'}), {model:'gpt-5.6-terra',effort:'high'})
+  assert.deepEqual(executionDefaults('codex', {model:'gpt-5.6-luna'}), {model:'gpt-5.6-luna',effort:'max'})
+  assert.deepEqual(executionDefaults('codex', {}), {model:'gpt-5.6-luna',effort:'max'})
+  assert.deepEqual(executionOverrides('codex', {model:'gpt-5.6-luna',effort:'max'}, 'gpt-6-astra'), {model:'gpt-6-astra',effort:'high'})
+  assert.deepEqual(executionOverrides('codex', {model:'gpt-5.6-luna',effort:'max'}, 'gpt-5.6-luna'), {model:'gpt-5.6-luna',effort:'max'})
+  const stored = persistedPreset({id:'luna',name:'Luna',cli:'codex',model:'gpt-5.6-luna',effort:'max'})
+  assert.equal(stored.effort, undefined)
+  assert.deepEqual(executionDefaults('codex', stored), {id:'luna',name:'Luna',cli:'codex',model:'gpt-5.6-luna',effort:'max'})
 })
 
 test('preset persistence rejects above-high choices without changing current settings', async () => {

package/test/reply.test.ts

@@ -44,7 +44,7 @@ test('reply native adapter exposes only context send defer with shell and networ
  assert.doesNotMatch(args,/--add-dir/)
 })
 
-test('reply handoff deduplicates the owner request and defaults independently to Terra high', async () => {
+test('reply handoff deduplicates the owner request and defaults independently to Luna max', async () => {
  const root=await mkdtemp(join(tmpdir(),'ez-reply-defer-')), runs=new RunStore(root)
  try {
   const control=new ControlStore(root,900000)
@@ -55,11 +55,17 @@ test('reply handoff deduplicates the owner request and defaults independently to
   const first=await replyCall(root,'tg_4',root,'defer',{text:'Prepare the report using the canonical sources'})
   assert.deepEqual(await replyCall(root,'tg_4',root,'defer',{text:'retry'}),first)
   const saved=JSON.parse(await readFile(join(root,'schedules','s_reply_tg_4.json'),'utf8'))
-  assert.equal(saved.execution.preset.model,'gpt-5.6-terra')
-  assert.equal(saved.execution.preset.effort,'high')
+  assert.equal(saved.execution.preset.model,'gpt-5.6-luna')
+  assert.equal(saved.execution.preset.effort,undefined)
   assert.notEqual(saved.execution.sessionId,execution.sessionId)
   assert.match(saved.text,/Make the report/)
   assert.equal(saved.owner.telegramChatId,101)
+  await runs.create({id:'tg_11',chatId:101,telegramUserId:101,texts:['Use Astra'],execution})
+  await runs.patch('tg_11',{status:'running',replyOnly:true})
+  await replyCall(root,'tg_11',root,'defer',{text:'Use Astra for this worker',model:'gpt-6-astra'})
+  const astra=JSON.parse(await readFile(join(root,'schedules','s_reply_tg_11.json'),'utf8'))
+  assert.equal(astra.execution.preset.model,'gpt-6-astra')
+  assert.equal(astra.execution.preset.effort,'high')
  }finally{await rm(root,{recursive:true,force:true})}
 })
 

package/test/schedule-cli.test.ts

@@ -22,10 +22,12 @@ test('public scheduler CLI saves literal text, reads back, edits, pauses, and re
  const args=['create','test','--at','2027-09-09T09:00:00+04:00','--text','Literal $(do-not-execute) /goal objective']
  const saved=JSON.parse((await exec(process.execPath,[bin,...args],{env})).stdout)
  assert.equal(saved.text,args.at(-1));assert.equal(saved.execution.preset.cli,'codex')
- assert.equal(saved.execution.preset.model,'gpt-5.6-terra');assert.equal(saved.execution.preset.effort,'high')
- await assert.rejects(exec(process.execPath,[bin,'create','blocked','--at','2027-09-09T09:00:00+04:00','--text','test','--effort','xhigh'],{env}),/capped at high/)
- const luna=JSON.parse((await exec(process.execPath,[bin,'create','luna','--at','2027-09-10T09:00:00+04:00','--text','Luna xhigh task','--model','gpt-5.6-luna','--effort','xhigh'],{env})).stdout)
- assert.equal(luna.execution.preset.model,'gpt-5.6-luna');assert.equal(luna.execution.preset.effort,'xhigh')
+ assert.equal(saved.execution.preset.model,'gpt-5.6-luna');assert.equal(saved.execution.preset.effort,undefined)
+ await assert.rejects(exec(process.execPath,[bin,'create','blocked','--at','2027-09-09T09:00:00+04:00','--text','test','--model','gpt-5.6-terra','--effort','xhigh'],{env}),/capped at high/)
+ const astra=JSON.parse((await exec(process.execPath,[bin,'create','astra','--at','2027-09-09T10:00:00+04:00','--text','Astra task','--model','gpt-6-astra'],{env})).stdout)
+ assert.equal(astra.execution.preset.model,'gpt-6-astra');assert.equal(astra.execution.preset.effort,'high')
+ const luna=JSON.parse((await exec(process.execPath,[bin,'create','luna','--at','2027-09-10T09:00:00+04:00','--text','Luna max task','--model','gpt-5.6-luna','--effort','max'],{env})).stdout)
+ assert.equal(luna.execution.preset.model,'gpt-5.6-luna');assert.equal(luna.execution.preset.effort,undefined)
  assert.equal(saved.nextEligibleAt,'2027-09-09T05:00:00.000Z')
  await assert.rejects(exec(process.execPath,[bin,...args],{env}),/exists/)
  assert.equal(JSON.parse((await exec(process.execPath,[bin,'pause','test'],{env})).stdout).enabled,false)

package/test/scheduler-relay.test.ts

@@ -11,8 +11,33 @@ import { ControlStore } from '../src/control-state.js'
 import { RunStore } from '../src/runs.js'
 import { Scheduler } from '../src/scheduler.js'
 import { initialPreset } from '../src/ai.js'
+import { randomUUID } from 'node:crypto'
 
 const until=async(check:()=>Promise<boolean>)=>{for(let i=0;i<200;i++){if(await check())return;await new Promise(r=>setTimeout(r,20))}throw new Error('Timed out')}
+
+test('maintenance wakeups use an independent ephemeral session after a relay restart',async()=>{
+ const dir=await mkdtemp(join(tmpdir(),'ez-maintenance-session-')),control=new ControlStore(dir,1000),runs=new RunStore(dir)
+ let launchSession='',onSessionCalls=0
+ const relay=createRelay({workspace:dir,controlDir:dir,pairingTtlMs:1000,executorTimeoutMs:0,executorCli:'codex',telegramBotToken:'fixture'},async(_texts,options)=>{
+  launchSession=options.sessionId ?? ''
+  if(options.onSession){onSessionCalls++;await options.onSession('native-maintenance')}
+  const child=spawn(process.execPath,['-e','setTimeout(()=>{},10)'],{detached:process.platform!=='win32'})
+  await once(child,'spawn')
+  return {child,cleanup:async()=>{},stdout:''}
+ })
+ relay.bot.botInfo={id:999,is_bot:true,first_name:'Fixture',username:'fixture_bot'} as typeof relay.bot.botInfo
+ relay.bot.api.config.use(async()=>({ok:true,result:{message_id:42}}) as never)
+ try{
+  await control.requestPairing(101,101);await control.approveOwner(101)
+  const execution={sessionId:randomUUID(),preset:initialPreset('codex')}
+  await runs.create({id:'r_update_fixture',chatId:101,telegramUserId:101,texts:['maintenance'],execution})
+  await relay.drainSources()
+  await until(async()=> (await runs.get('r_update_fixture'))?.status==='completed')
+  assert.notEqual(launchSession,execution.sessionId)
+  assert.equal(onSessionCalls,0)
+}finally{await relay.stop();await rm(dir,{recursive:true,force:true})}
+})
+
 test('chat replies through the real ingress/outbox while scheduled CLI remains alive; targeted cancellation',async()=>{
  const dir=await mkdtemp(join(tmpdir(),'ez-scheduler-relay-')), children:ReturnType<typeof spawn>[]=[]
  const runs=new RunStore(dir),scheduler=new Scheduler(dir),control=new ControlStore(dir,1000)