@jc_stack/ez-agents 0.1.0-beta.41 → 0.1.0-beta.42

package/CHANGELOG.md

@@ -1,5 +1,11 @@
 # Changelog
 
+## 0.1.0-beta.42
+
+- Keep recurring schedule edits at their next pending or future occurrence, so
+  an old start date cannot replay historical work. Schedule readback now shows
+  the same pending cursor used by dispatch.
+
 ## 0.1.0-beta.41
 
 - Run owner-scheduled tasks from the bound agent workspace so native instructions

package/docs/scheduling.md

@@ -21,6 +21,10 @@ ezenciel-agents-schedule cancel RUN_ID
 
 Use `--text-file` for longer instructions. `edit ID` replaces the complete schedule
 with a new revision; use the same trigger/name/text flags as `create`.
+An edit keeps a future pending occurrence when its trigger is unchanged;
+otherwise the edited rule begins at its next future occurrence. Editing does
+not replay missed work from an old start date. Use `--now` to request a new
+one-time run explicitly. `show` reports the pending occurrence used by dispatch.
 Intervals use `--every-seconds` (minimum 60), optional `--start`, and optional
 `--until`. Cron also supports start/end bounds. All absolute timestamps require
 an explicit offset. `--now` starts on the next relay tick, not synchronously.

package/package.json

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

package/src/schedule-cli.ts

@@ -11,7 +11,7 @@ import { initialPreset, isPreset } from './ai.js'
 import { executionOverrides } from './model-policy.js'
 import { holdsSchedule, Scheduler } from './scheduler.js'
 import { ownsRun } from './identity.js'
-import { nextOccurrence, type Trigger } from './schedule-time.js'
+import { type Trigger } from './schedule-time.js'
 
 async function main() {
   const { values:v, positionals:[action='list',id] } = parseArgs({allowPositionals:true,options:{
@@ -69,7 +69,7 @@ Cron uses numeric five-field syntax, lists/ranges/steps, and traditional day/wee
     const held=(await runs.listBestEffort()).filter(r=>holdsSchedule(s,r))
     const interruptedRunIds=held.filter(r=>r.interrupted).map(r=>r.id)
     const failedReviewRunIds=held.filter(r=>!r.interrupted).map(r=>r.id)
-    const next=s.enabled && !held.length ? nextOccurrence(s.trigger,Date.now()) : null
+    const next=s.enabled && !held.length ? await scheduler.pendingOccurrence(s) : null
     return {...s,interruptedRunIds,failedReviewRunIds,nextEligibleAt:next===null ? null : new Date(next).toISOString(),
       ...(held.length ? {recovery:'Inspect the failed run and explicitly edit this schedule to resume; pause/resume does not clear the stop.'} : {})}
   }

package/src/scheduler.ts

@@ -75,7 +75,7 @@ export class Scheduler {
     }
     return result
   }
-  private async pendingOccurrence(s: Schedule): Promise<number | null> {
+  async pendingOccurrence(s: Schedule): Promise<number | null> {
     try {
       const saved = JSON.parse(await readFile(join(this.dir,`${s.id}.${s.revision}.cursor`),'utf8'))
       if (saved.next !== null && !Number.isFinite(saved.next)) throw new Error('Invalid schedule cursor')
@@ -114,7 +114,23 @@ export class Scheduler {
     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')
+    const now = Date.now()
+    let next = nextOccurrence(s.trigger,now-1)
+    if (next === null) throw new Error('Schedule has no future occurrence within eight years')
+    if (!exclusive) {
+      let previous: Schedule | null = null
+      try { previous = await this.get(s.id) }
+      catch (error) { if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error }
+      if (previous) {
+        if (sameOwner(previous.owner,s.owner) && JSON.stringify(previous.trigger) === JSON.stringify(s.trigger)) {
+          const pending = await this.pendingOccurrence(previous)
+          if (pending !== null && pending >= now) next = pending
+        }
+        // Publish the cursor first so a crash cannot expose a new revision with
+        // a missing cursor that falls back to the trigger's historical start.
+        await atomic(join(this.dir,`${s.id}.${s.revision}.cursor`),{next})
+      }
+    }
     await atomic(join(this.dir,s.id+'.json'),s,exclusive)
     return s
   }

package/test/schedule-cli.test.ts

@@ -2,7 +2,7 @@ import test from 'node:test'
 import assert from 'node:assert/strict'
 import { execFile } from 'node:child_process'
 import { promisify } from 'node:util'
-import { mkdtemp, rm } from 'node:fs/promises'
+import { mkdtemp, rm, writeFile } from 'node:fs/promises'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { fileURLToPath } from 'node:url'
@@ -52,6 +52,9 @@ test('public scheduler CLI saves literal text, reads back, edits, pauses, and re
  await runs.patch(task.id,{status:'running'})
  await assert.rejects(exec(process.execPath,[bin,'list'],{env:{...env,EZ_RUN_ID:task.id}}),/owner-authorized/)
  const schedule=JSON.parse((await exec(process.execPath,[bin,'show','test'],{env})).stdout)
+ const pending=Date.parse('2027-09-22T05:00:00Z')
+ await writeFile(join(dir,'schedules',`test.${schedule.revision}.cursor`),JSON.stringify({next:pending}))
+ assert.equal(JSON.parse((await exec(process.execPath,[bin,'show','test'],{env})).stdout).nextEligibleAt,new Date(pending).toISOString())
  const interrupted=await runs.create({chatId:101,telegramUserId:101,texts:['old'],execution,scheduled:{id:'test',revision:schedule.revision,dueAt:new Date().toISOString(),pairedAt:schedule.owner.pairedAt}})
  await runs.patch(interrupted.id,{status:'failed',interrupted:true})
  const held=JSON.parse((await exec(process.execPath,[bin,'show','test'],{env})).stdout)

package/test/scheduler.test.ts

@@ -55,6 +55,47 @@ test('missed recurrences coalesce; an active occurrence cannot overlap another',
  await f.scheduler.tick(f.owner,f.runs,f.now+800000)
  assert.equal((await f.runs.list()).length,2)
 })
+test('recurring edits preserve a future cursor or start the changed rule in the future',async t=>{
+ const f=await fixture(t), start=new Date(Date.now()-86400000).toISOString()
+ const original=await f.scheduler.save({...f.input,trigger:{everySeconds:60,start}},true)
+ const future=nextOccurrence(original.trigger,Date.now()+120000)!
+ await writeFile(join(f.dir,`schedules/${original.id}.${original.revision}.cursor`),JSON.stringify({next:future}))
+ const same=await f.scheduler.save({...f.input,text:'Edited text',trigger:original.trigger})
+ assert.notEqual(same.revision,original.revision)
+ assert.equal(await f.scheduler.pendingOccurrence(same),future)
+ await f.scheduler.tick(f.owner,f.runs,future-1)
+ assert.equal((await f.runs.list()).length,0)
+ await f.scheduler.tick(f.owner,f.runs,future)
+ const [first]=await f.runs.list()
+ assert.equal(first.scheduled?.dueAt,new Date(future).toISOString())
+ assert.equal(first.texts[1],'Edited text')
+ await f.runs.patch(first.id,{status:'completed'})
+
+ const changed=await f.scheduler.save({...f.input,text:'Changed cadence',trigger:{everySeconds:120,start}})
+ const nextDue=await f.scheduler.pendingOccurrence(changed)
+ assert.ok(nextDue !== null && nextDue >= Date.now())
+ await f.scheduler.tick(f.owner,f.runs,nextDue-1)
+ assert.equal((await f.runs.list()).length,1,'edit must not replay the old start')
+ await f.scheduler.tick(f.owner,f.runs,nextDue)
+ const second=(await f.runs.list()).find(r=>r.scheduled?.revision===changed.revision)
+ assert.equal(second?.scheduled?.dueAt,new Date(nextDue).toISOString())
+ assert.equal(second?.texts[1],'Changed cadence')
+})
+test('an explicit one-time edit still dispatches at its requested time',async t=>{
+ const f=await fixture(t), first=await f.scheduler.save(f.input,true)
+ const due=Date.now()+2000
+ const edited=await f.scheduler.save({...f.input,trigger:{at:new Date(due).toISOString()},text:'Run now'})
+ assert.notEqual(first.revision,edited.revision)
+ await f.scheduler.tick(f.owner,f.runs,due)
+ assert.equal((await f.runs.list()).find(r=>r.scheduled?.revision===edited.revision)?.texts[1],'Run now')
+})
+test('an unreadable prior cursor rejects an edit without publishing its revision',async t=>{
+ const f=await fixture(t), start=new Date(Date.now()-86400000).toISOString()
+ const saved=await f.scheduler.save({...f.input,trigger:{everySeconds:60,start}},true)
+ await writeFile(join(f.dir,`schedules/${saved.id}.${saved.revision}.cursor`),'{broken')
+ await assert.rejects(f.scheduler.save({...f.input,text:'Edited',trigger:saved.trigger}))
+ assert.equal((await f.scheduler.get(saved.id)).revision,saved.revision)
+})
 test('pause, edit, removal, owner revocation, corrupt records and traversal fail closed',async t=>{
  const f=await fixture(t), s=await f.scheduler.save(f.input)
  await f.scheduler.enable(s.id,false);await f.scheduler.tick(f.owner,f.runs,f.now)