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

package/src/plugins/manager.mjs

@@ -7,7 +7,8 @@ import { fileURLToPath } from 'node:url';
 import { createHash, randomUUID, randomBytes } from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { callDeliverySocket } from '../delivery-socket-client.mjs';
-import { readFileSync, realpathSync } from 'node:fs';
+import { TOOLS_LINE } from '../tools-line.mjs';
+import { readFileSync, readlinkSync, realpathSync } from 'node:fs';
 
 const reserved = new Set(['status','updates','plugins','tools','message','owner','approval','react','setup','help','version']);
 const id = value => { if(typeof value !== 'string' || !/^[a-z][a-z0-9-]{0,39}$/.test(value)) throw Error('Invalid identifier'); return value; };
@@ -41,39 +42,31 @@ export async function stewardOwned(file) {
   const parent = await fs.stat(path.dirname(file));
   await fs.chown(file, parent.uid, parent.gid);
 }
-// Native instructions keep only the registry locator and one crucial routing
-// hint. Inventory and full scheduler usage are generated on read.
-export async function toolDiscoveryBlock(home,hostConfig) {
-  home=await fs.realpath(home);
-  let launcher=path.join(home,'bin','ez');
-  const config=hostConfig?{hostConfig}:await json(path.join(home,'config.json')).catch(error=>{if(error.code==='ENOENT')return undefined;throw error;});
-  if(config?.hostConfig) {
-    const host=await json(config.hostConfig);
-    if(host.isolation==='isolated') launcher='ez';
-  }
+// Retire the former `ez tools` footer once: replace the marked block with
+// TOOLS_LINE and leave every other byte untouched. The name is kept because
+// upgraders released before this change call it on the target package;
+// remove it when no installed core predates the change.
+export async function bindToolDiscovery(_home,workspace) {
+  workspace=await fs.realpath(workspace);
   const start='<!-- ez tools: begin -->',end='<!-- ez tools: end -->';
-  const block=start+'\nUse `'+launcher+'`; run it with `--help` or `tools list --details` to discover installed capabilities, and read the matching skill when needed.\nKeep the channel responsive: during a foreground owner turn, prefer `ezenciel-agents-schedule create --now ...` when work can continue independently. A `[schedule ...]` turn executes its assigned work directly and must not schedule it again.\n'+end;
-  if(Buffer.byteLength(block)>600)throw Error('Tool discovery guidance exceeds the 600-byte core budget');
-  return {block,start,end};
-}
-export async function bindToolDiscovery(home,workspace) {
-  home=await fs.realpath(home);workspace=await fs.realpath(workspace);
-  const {block,start,end}=await toolDiscoveryBlock(home);
   for(const name of ['AGENTS.md','AGENTS.override.md']) {
     const file=path.join(workspace,name);
     const stat=await fs.lstat(file).catch(e=>{if(e.code==='ENOENT')return null;throw e;});
-    if(!stat && name!=='AGENTS.md')continue;
-    if(stat && !stat.isFile())throw Error('Tool instructions must be a regular file');
-    const prior=stat?await fs.readFile(file,'utf8'):'';
+    if(!stat)continue;
+    if(!stat.isFile())throw Error('Tool instructions must be a regular file');
+    const prior=await fs.readFile(file,'utf8');
     const from=prior.indexOf(start),to=prior.indexOf(end);
-    if((from<0)!==(to<0)||(from>=0&&(to<from||prior.indexOf(start,from+start.length)>=0||prior.indexOf(end,to+end.length)>=0)))throw Error('Malformed tool discovery block');
-    const next=from<0?prior+'\n'+block+'\n':prior.slice(0,from)+block+prior.slice(to+end.length);
-    if(next===prior)continue;
+    if(from<0&&to<0)continue;
+    if((from<0)!==(to<0)||to<from||prior.indexOf(start,from+start.length)>=0||prior.indexOf(end,to+end.length)>=0)throw Error('Malformed tool discovery block');
+    const next=prior.slice(0,from)+(prior.includes(TOOLS_LINE)?'':TOOLS_LINE)+prior.slice(to+end.length);
     const tmp=file+'.'+randomUUID()+'.tmp';
     try {await fs.writeFile(tmp,next,{mode:0o600,flag:'wx'});await fs.rename(tmp,file);}finally{await fs.rm(tmp,{force:true});}
   }
 }
 const invocationDirectory = home => path.join(home,'command-invocations');
+// A lease pid is only meaningful inside the PID namespace that wrote it. The
+// isolated broker writes leases from its container, which the host cannot probe.
+const pidNamespace=(()=>{try{return readlinkSync('/proc/self/ns/pid');}catch{return undefined;}})();
 async function activeInvocations(home) {
   const directory=invocationDirectory(home),files=await fs.readdir(directory).catch(error=>{if(error.code==='ENOENT')return [];throw error;});
   for(const file of files) {
@@ -81,8 +74,11 @@ async function activeInvocations(home) {
     const lease=await json(path.join(directory,file)).catch(error=>{if(error.code==='ENOENT')return null;throw error;});
     if(!lease)continue;
     if(!Number.isSafeInteger(lease.pid)||lease.pid<1||typeof lease.container!=='string'||!lease.container)throw Error('Invalid command invocation lease; inspect before recovery');
-    try {process.kill(lease.pid,0);return true;} catch(error) {if(error.code!=='ESRCH'&&error.code!=='EPERM')throw error;}
-    const state=await run(['container','inspect',lease.container],{capture:true});
+    const foreign=typeof lease.pidNamespace==='string'&&lease.pidNamespace!==pidNamespace;
+    if(!foreign) {try {process.kill(lease.pid,0);return true;} catch(error) {if(error.code!=='ESRCH'&&error.code!=='EPERM')throw error;}}
+    const state=await run(['container','inspect','--format','{{.State.Running}}',lease.container],{capture:true});
+    // Foreign leases: the call container's own state is the only liveness signal.
+    if(state.code===0&&foreign&&state.stdout.trim()==='true')return true;
     if(state.code===0)throw Error(`Stale command invocation lease; inspect container ${lease.container} before recovery`);
     if(!/No such (?:object|container)/i.test(state.stderr+state.stdout))throw Error('Unable to verify a stale command invocation lease; inspect Docker before recovery');
     await fs.rm(path.join(directory,file));
@@ -91,7 +87,7 @@ async function activeInvocations(home) {
 }
 async function invocationLease(home,container) {
   const directory=invocationDirectory(home);await privateDir(directory);
-  const file=path.join(directory,randomUUID()+'.json');await fs.writeFile(file,JSON.stringify({pid:process.pid,container}),{mode:0o600,flag:'wx'});
+  const file=path.join(directory,randomUUID()+'.json');await fs.writeFile(file,JSON.stringify({pid:process.pid,container,...(pidNamespace?{pidNamespace}:{})}),{mode:0o600,flag:'wx'});
   await stewardOwned(file);
   return async()=>{await fs.rm(file,{force:true});};
 }
@@ -150,9 +146,11 @@ export async function snapshot(source) {
   return {source,files,manifest,deployment,sharedRevisions,revision:`sha256:${digest.digest('hex')}`};
 }
 export function validate(m,d,files) {
-  keys(m,['schemaVersion','id','version','description','commands','skills']);
+  keys(m,['schemaVersion','id','version','description','commands','skills','example']);
   if(m.schemaVersion!==1 || (typeof m.version!=='string' || !/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-((?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|\d*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/.test(m.version))) throw Error('Unsupported manifest version');
   id(m.id); strings(m.skills);
+  // One representative call shown by `tools list --details`; usage stays in --help/skill.
+  if(m.example!==undefined && (typeof m.example!=='string' || m.example.length>160 || /[\0-\x1f\x7f]/.test(m.example) || !Object.hasOwn(m.commands||{},m.example.split(' ')[0]))) throw Error('Manifest example must be one line of at most 160 characters starting with a declared command');
   keys(d,['schemaVersion','services','commands','exports',...(d.schemaVersion>=2?['secrets']:[]),...(d.schemaVersion===3?['sharedServices']:[])]);
   if(![1,2,3].includes(d.schemaVersion) || !d.services || !d.commands) throw Error('Unsupported deployment descriptor');
   for(const [name,s] of Object.entries(d.services)) {
@@ -397,11 +395,13 @@ export function run(argv,{capture=false,container,signal,stdin,onStdout,onStart,
     child.once('close',async(code,childSignal)=>{process.off('SIGTERM',term);process.off('SIGINT',int);
       clearTimeout(killTimer);
       clearTimeout(timeout);signal?.removeEventListener('abort',term);
-      if(cancelled&&container) {
+      // --rm only removes a container that ran. Compose stopping between
+      // create and start (cancelled, signalled or failed) strands it Created.
+      if(container&&(cancelled||code!==0)) {
         try {
           await removeCommandContainer(container);
         } catch(error) {
-          const uncertain=error instanceof Error?error:Error('Cancelled command container cleanup failed');
+          const uncertain=error instanceof Error?error:Error('Command container cleanup failed');
           uncertain.containerCleanupUncertain=true;return reject(uncertain);
         }
       }
@@ -409,7 +409,7 @@ export function run(argv,{capture=false,container,signal,stdin,onStdout,onStart,
       resolve({code:cancelled?130:code??(childSignal?130:1),stdout,stderr});});
   });
 }
-// Compose --rm can race cancellation. Confirm disappearance instead of treating
+// Compose --rm can race this cleanup. Confirm disappearance instead of treating
 // Docker's in-progress removal as either failure or completed cleanup.
 export async function removeCommandContainer(container,execute=run) {
   const cleanup=await execute(['container','rm','--force',container],{capture:true});
@@ -422,7 +422,7 @@ export async function removeCommandContainer(container,execute=run) {
       await new Promise(resolve=>setTimeout(resolve,100));
     }
   }
-  throw Error(`Cancelled command container cleanup failed: ${cleanup.stderr||cleanup.stdout}`);
+  throw Error(`Command container cleanup failed: ${cleanup.stderr||cleanup.stdout}`);
 }
 
 async function checked(args) {
@@ -530,7 +530,6 @@ export async function init(home,workspace,catalogFile,hostConfig,standalone=fals
   if(standalone && hostConfig) throw Error('Standalone setup cannot bind a relay host config');
   if(typeof home!=='string'||typeof workspace!=='string'||!path.isAbsolute(home)||!path.isAbsolute(workspace)||/[\r\n\0$:,]/.test(home+workspace)) throw Error('Explicit absolute home/workspace required');
   workspace=await fs.realpath(workspace);await privateDir(home);home=await fs.realpath(home);if(hostConfig)hostConfig=await fs.realpath(hostConfig);
-  await toolDiscoveryBlock(home,hostConfig);
   if(await fs.lstat(path.join(home,'registry.json')).catch(()=>null)) throw Error('Registry already exists; refusing replacement');
   catalogFile=path.resolve(catalogFile||fileURLToPath(new URL('../../default-plugins.json',import.meta.url)));
   const sources=await json(catalogFile);
@@ -563,7 +562,6 @@ export async function init(home,workspace,catalogFile,hostConfig,standalone=fals
       agent.binDir=bin;agent.toolsHome=home;await atomic(hostConfig,host);
     }
   });
-  await bindToolDiscovery(home,workspace);
   if(hostConfig && path.basename(hostConfig)==='host-executor.json') await (await import('../updates/binding.mjs')).bindUpdates(home,hostConfig);
   return {ok:true,launcher:path.join(home,'bin','ez'),workspace};
 }
@@ -651,12 +649,17 @@ export async function main(args) {
       return emit({plugin:name,revision:record.revision,path:skill,content:await fs.readFile(file,'utf8')});
     }
     if(action==='list') {
-      if(group==='tools' && args.length===1 && args[0]==='--details')return emit(Object.fromEntries(Object.entries(r.plugins).map(([name,p])=>[name,{
-        description:typeof p.manifest.description==='string'?p.manifest.description.replace(/\s+/g,' ').trim().slice(0,200):'',
-        commands:Object.keys(p.manifest.commands).map(alias=>`ez ${alias} --help`),
-        skills:p.manifest.skills.map(skill=>path.join(p.source,skill)),
-        skillReads:p.manifest.skills.map(skill=>['ez','tools','skill',name,skill]),
-      }])));
+      // Self-sufficient index: aliases, purpose, skill and one call per plugin.
+      if(group==='tools' && args.length===1 && args[0]==='--details')return emit(Object.fromEntries(Object.entries(r.plugins).map(([name,p])=>{
+        const aliases=Object.keys(p.manifest.commands);
+        return [name,{
+          aliases,
+          purpose:typeof p.manifest.description==='string'?p.manifest.description.replace(/\s+/g,' ').trim().slice(0,200):'',
+          skills:p.manifest.skills.map(skill=>path.join(p.source,skill)),
+          skillReads:p.manifest.skills.map(skill=>['ez','tools','skill',name,skill]),
+          example:`ez ${p.manifest.example ?? `${aliases[0]} --help`}`,
+        }];
+      })));
       if(args.length)throw Error('Use tools list [--details] or plugins list');
       return emit(group==='tools'?r.commands:r.plugins);
     }

package/src/plugins/workspace-lease.mjs

@@ -23,7 +23,7 @@ export async function recoverNativeLease(home) {
 export async function workspaceLease(home,owner={kind:'plugin'}) {
   const file=path.join(home,'workspace-writer.lock'),temp=file+'.'+randomUUID()+'.tmp';
   await fs.writeFile(temp,JSON.stringify({...owner,pid:process.pid}),{flag:'wx',mode:0o600});
-  try {await fs.link(temp,file);}catch(error){if(error.code!=='EEXIST')throw error;let prior;try {prior=await leaseOwner(file);}catch(error){if(error.code==='ENOENT')return undefined;throw error;}if(!prior.alive)throw Error('Stale workspace-writer.lock: inspect stopped owner and command containers, then restart for recovery');return undefined;}
+  try {await fs.link(temp,file);}catch(error){if(error.code!=='EEXIST')throw error;let prior;try {prior=await leaseOwner(file);}catch(error){if(error.code==='ENOENT')return undefined;throw error;}if(!prior.alive)throw Error('Stale workspace-writer.lock: inspect stopped owner and command containers, then restart for recovery');if(owner.kind==='native'&&prior.owner.kind==='native')return async()=>{};return undefined;}
   finally {await fs.rm(temp);}
   return async()=>{await fs.rm(file);};
 }

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,53 @@ 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`
+  const ids=new Set(records.map(run=>run.id))
+  const receipts=[...outboxFor(controlDir).values()].filter(item=>item.runId&&ids.has(item.runId)&&(item.state==='sent'||item.state==='failed'))
+  await writeFile(temporary, JSON.stringify({ version: 1, writtenAt: new Date().toISOString(), runs: records, receipts }), { 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; receipts?: 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)
+    const ids=new Set(valid.map(run=>run.id))
+    if(Array.isArray(value.receipts)&&value.receipts.length<=MAX_TERMINAL_OUTBOX){
+      for(const item of value.receipts as StoredOutboxItem[])if(item&&typeof item.id==='string'&&/^[a-zA-Z0-9_-]+$/.test(item.id)&&item.runId&&ids.has(item.runId)&&(item.state==='sent'||item.state==='failed'))outboxFor(controlDir).set(item.id,item)
+    }
+    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 +215,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 +248,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 +262,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,14 +72,19 @@ 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.
-Edit replaces the full schedule. Pause/remove affect future work; cancel stops a particular run.
+Edit replaces the full schedule but keeps its paused/enabled state; only pause/resume toggle it.
+Pause/remove affect future work; cancel stops a particular run.
 Cron uses numeric five-field syntax, lists/ranges/steps, and traditional day/weekday OR semantics.`);return}
   const config=loadControlConfig(), control=new ControlStore(config.controlDir,config.pairingTtlMs)
   const owner=(await control.status()).owner
@@ -190,13 +196,15 @@ 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}
     if(v['clear-preflight'] && v['preflight-file']) throw Error('Choose one preflight operation')
     const previousSchedule = action === 'edit' ? await scheduler.get(id!) : undefined
+    // Edit keeps the paused/enabled state; only pause/resume toggle it.
+    const enabled = previousSchedule?.enabled ?? true
     const preflight = v['clear-preflight'] ? undefined : v['preflight-file'] ? JSON.parse(await readFile(v['preflight-file'],'utf8')) : previousSchedule?.preflight
     const origin = caller?.application ?? caller?.delivery
     const delivery = previousSchedule ? previousSchedule.delivery : (origin ? {bindingId:origin.bindingId,scope:origin.scope} : undefined)
     if (!delivery && !owner.telegramChatId) throw new Error('Create the schedule from an authenticated channel turn to bind its reply destination')
     if (v.script) {
       result=await show(await scheduler.save({id:id || 's_'+randomUUID(),name:v.name || v.script,preflight,
-        originRunId:previousSchedule?.originRunId ?? caller?.scheduled?.originRunId ?? caller?.id,delivery,text:'',when:v.when as 'unreviewed-failures' | undefined,trigger,enabled:true,owner,
+        originRunId:previousSchedule?.originRunId ?? caller?.scheduled?.originRunId ?? caller?.id,delivery,text:'',when:v.when as 'unreviewed-failures' | undefined,trigger,enabled,owner,
         script:{id:v.script,args:v.arg ?? []}},action==='create'))
       console.log(JSON.stringify(result,null,2));return
     }
@@ -207,10 +215,11 @@ 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,
+      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,owner,
       execution:{sessionId:previous?.sessionId || randomUUID(),preset,...(fallbacks ? {fallbacks} : {})}},action==='create'))
   }else{
     if(!id)throw new Error('ID required')

package/src/scheduled-tasks.ts

@@ -1,7 +1,8 @@
 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'
+import type { Schedule, ScheduledTaskView } from './scheduler.js'
 
 const ownsSchedule = (owner: Owner, schedule: Schedule) =>
   schedule.owner.telegramUserId === owner.telegramUserId &&
@@ -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
+const engineLabel = (schedule: ScheduledTaskView) => 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']
@@ -36,41 +67,46 @@ const preview = (schedule: Schedule) => {
   return chars.length > 140 ? chars.slice(0,139).join('')+'…' : sentence
 }
 
-const currentState = (schedule: ActiveSchedule) =>
-  schedule.runState === 'running' ? '▶ Running' : schedule.runState === 'queued' ? '◌ Queued' : '● Active'
+const currentState = (schedule: ScheduledTaskView) =>
+  [schedule.runState === 'running' ? '▶ Running' : schedule.runState === 'queued' ? '◌ Queued' : undefined,
+    !schedule.enabled ? '⏸ Paused' : undefined].filter(Boolean).join(' · ') || '● Active'
 
-const lastRun = (schedule: ActiveSchedule) => {
+const lastRun = (schedule: ScheduledTaskView) => {
   if (!schedule.lastRun) return '— Not run yet'
   const status = schedule.lastRun.status === 'completed' ? '✓ Completed' : schedule.lastRun.status === 'failed' ? '✕ Failed' : '⊘ Cancelled'
   return `${status} · ${time(schedule.lastRun.at)}${schedule.lastRun.currentRevision ? '' : ' · previous version'}`
 }
 
-export const ownedScheduledTasks = (schedules: ActiveSchedule[], owner: Owner) =>
+export const ownedScheduledTasks = (schedules: ScheduledTaskView[], owner: Owner) =>
   schedules.filter((schedule) => ownsSchedule(owner, schedule))
     .sort((a, b) => a.name.localeCompare(b.name))
 
-export const scheduledTasksText = (schedules: ActiveSchedule[], owner: Owner) => {
+export const scheduledTasksText = (schedules: ScheduledTaskView[], 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)}`
+  if (!owned.length) return '📅 Scheduled tasks\n\nNo scheduled tasks.'
+  const paused = owned.filter(schedule => !schedule.enabled).length
+  return [`📅 Scheduled tasks · ${owned.length - paused} active · ${paused} paused`, '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')
 }
 
-export const scheduledTaskDetailText = (schedule: ActiveSchedule, number: number, total?: number) => {
+export const scheduledTaskDetailText = (schedule: ScheduledTaskView, number: number, total?: number) => {
   const instructions = schedule.script ? preview(schedule) : schedule.text.trim()
   const capped = instructions.length > 2000 ? instructions.slice(0, 2000) + '… (truncated; full text lives in the workspace)' : instructions
   return [
     `📅 ${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

@@ -29,7 +29,7 @@ export type ScheduledRunSummary = {
   at: string
   currentRevision: boolean
 }
-export type ActiveSchedule = Schedule & { nextAt: number | null; runState?: 'queued' | 'running'; lastRun?: ScheduledRunSummary; scriptRevision?: string }
+export type ScheduledTaskView = Schedule & { nextAt: number | null; runState?: 'queued' | 'running'; lastRun?: ScheduledRunSummary; scriptRevision?: string }
 export type ScheduledOrigin = { id: string; revision: string; dueAt: string; pairedAt: string; originRunId?: string }
 export const validScheduledOrigin = (v: unknown): v is ScheduledOrigin => {
   const s = v as ScheduledOrigin
@@ -102,10 +102,9 @@ export class Scheduler {
       return nextOccurrence(s.trigger,-1)
     }
   }
-  async listActiveReadOnly(runs: RunRecord[]): Promise<ActiveSchedule[]> {
-    const active: ActiveSchedule[] = []
+  async listTasksReadOnly(runs: RunRecord[]): Promise<ScheduledTaskView[]> {
+    const active: ScheduledTaskView[] = []
     for (const s of await this.listReadOnly()) {
-      if (!s.enabled) continue
       const current = runs.filter(r => r.scheduled?.id === s.id && r.scheduled.revision === s.revision && ownsRun(s.owner,r))
       const history = runs.filter(r => r.scheduled?.id === s.id && r.scheduled.pairedAt === s.owner.pairedAt && ownsRun(s.owner,r))
         .filter((r): r is RunRecord & { status: ScheduledRunSummary['status'] } =>
@@ -113,11 +112,11 @@ export class Scheduler {
         .sort((a,b) => (b.endedAt ?? b.startedAt ?? b.createdAt).localeCompare(a.endedAt ?? a.startedAt ?? a.createdAt))
       const last = history[0]
       const runState = current.some(r => r.status === 'running') ? 'running' : current.some(r => r.status === 'queued') ? 'queued' : undefined
-      if (!runState && current.some(r => holdsSchedule(s,r))) continue
+      if (s.enabled && !runState && current.some(r => holdsSchedule(s,r))) continue
       try {
-        const nextAt = await this.pendingOccurrence(s)
+        const nextAt = s.enabled ? await this.pendingOccurrence(s) : null
         const scriptRevision = s.script ? await new Scripts(this.controlDir).get(s.script.id).then(r => r.revision, () => undefined) : undefined
-        if (runState || nextAt !== null) active.push({...s,nextAt,runState,...(scriptRevision ? {scriptRevision} : {}),...(last ? {
+        if (!s.enabled || runState || nextAt !== null) active.push({...s,nextAt,runState,...(scriptRevision ? {scriptRevision} : {}),...(last ? {
           lastRun: {status:last.status,at:last.endedAt ?? last.startedAt ?? last.createdAt,currentRevision:last.scheduled!.revision===s.revision},
         } : {})})
       }
@@ -144,7 +143,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 })
+}