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

package/AGENTS.md

@@ -121,7 +121,7 @@ round merely to seek more criticism, tests or hypothetical edge cases.
 
 ## 6. Concurrency & Workspace Invariants
 - **1 Writer Job per Workspace:** The agent's Markdown folder (`./agent/`) is its mind. Never run concurrent background processes writing to the same workspace simultaneously.
-- Main-conversation jobs queue sequentially in the relay's memory ledger; the delivery socket carries every cross-process enqueue/receipt, never control/ files. Scheduled/background work uses separate task directories under the control directory and native CLI sessions (up to four alongside chat). Never share a mutable task directory. Delegation decisions and goal persistence belong to the agent/executor; there is no automatic planner or canned chat ACK. Production executor runs have no wall-clock timeout; cancellation is explicit.
+- Main-conversation and owner-scheduled jobs write the same mind workspace one at a time; the delivery socket carries every cross-process enqueue/receipt, never control/ files. Scheduled jobs keep separate native CLI sessions and control-side task state. Restricted contact tasks retain their separate authorization boundary. Delegation decisions and goal persistence belong to the agent/executor; there is no automatic planner or canned chat ACK. Production executor runs have no wall-clock timeout; cancellation is explicit.
 
 ## 7. Fail-Closed Authority (Channel Access ≠ Execution)
 - Incoming messages outside the approved owner binding must **never** spawn the executor. A first DM or group message records a pending request only. Explicitly approved owner groups grant owner access to all human members in that exact chat; bots and anonymous posts are ignored.

package/CHANGELOG.md

@@ -1,5 +1,16 @@
 # 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
+  and relative context are available, while serializing writes with owner turns.
+
 ## 0.1.0-beta.40
 
 - Apply eligible npm releases under each agent's saved automatic update policy

package/README.md

@@ -327,6 +327,6 @@ main/plugin replacement. See [upgrade setup, tools and recovery](docs/upgrades.m
 
 The core `ezenciel-agents-schedule` CLI accepts instruction text for one-off dates,
 intervals and timezone-aware cron schedules. `create --now` delegates a task to a
-separate CLI session so the owner conversation remains available. Long work has
+separate CLI session queued with owner turns in the bound workspace. Long work has
 no production wall-clock timeout; goals and subagents remain native executor
 features. See [scheduling, recovery and QA](docs/scheduling.md).

package/docs/responsive-channels.md

@@ -3,11 +3,12 @@
 Owner input passes unchanged to the selected engine. The agent decides when to
 delegate or schedule long work to remain available. ez queues foreground input
 while a foreground run is active; it does not create a separate busy-reply agent.
-Independent scheduled task directories retain deterministic writer isolation.
+Owner-scheduled turns use the bound mind workspace under the same single-writer
+limit as foreground turns.
 
-Background tasks receive literal task text. Their directories contain no generated
-role instructions or copied identity files; native workspace instructions and
-existing Markdown provide context. The agent chooses what to read and when to use
+Background tasks receive literal task text. Their native sessions contain no
+generated role instructions or copied identity files; native workspace instructions
+and existing Markdown provide context. The agent chooses what to read and when to use
 the message CLI. Native final text is not automatically delivered to Telegram.
 
 Restricted correspondence receives a typed activation event and scoped tools.

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.
@@ -40,18 +44,18 @@ available through `ezenciel-agents-schedule context`.
 ## Execution and authority
 
 Due occurrences enter the durable queue with stable IDs and literal task text.
-Background runs use fresh native sessions in `work/tasks/RUN_ID/`. No identity
-files or role instructions are generated there. Existing workspace Markdown
-provides context; the engine chooses what to read. Codex uses `AGENTS.md` or `.git`
-as its native project-root marker, so a nested task sees the existing agent scope. Task folders remain for
-inspection and artifact delivery.
-
-One writer runs per task directory. Up to four background tasks can run alongside
-the main conversation. Foreground inputs queue while a foreground turn runs;
+Owner-scheduled runs use fresh native sessions in the bound agent workspace.
+No identity files or role instructions are generated. Existing workspace Markdown
+provides context, including native `AGENTS.md` discovery and relative links; the
+engine chooses what to read. Per-run native state stays under `control/`.
+
+One writer runs in the agent workspace: owner schedules and foreground turns
+queue behind each other. Foreground inputs queue while another turn runs;
 ez does not create another reply agent. The agent can delegate or schedule long
 work and return to chat. It decides when to send through the message CLI.
 A recurring schedule has at most one pending or active occurrence. Shared
-provider resources still need writer coordination.
+provider resources still need writer coordination. The former four background
+slots are no longer used for owner schedules.
 
 Production relay/host execution has no wall-clock timeout. The old
 `EZ_EXECUTOR_TIMEOUT_SECONDS` setting is ignored. Individual network/tool waits
@@ -70,7 +74,7 @@ goal is not reported as successful. Native RPC requests have a response deadline
 running tasks do not.
 Each scheduled task has its own Codex state under `control/cli/codex/tasks/RUN_ID`,
 with a snapshot of the agent's Codex configuration and the existing auth link.
-Foreground chat and background tasks do not initialize or migrate one shared
+Foreground chat and scheduled tasks do not initialize or migrate one shared
 native database concurrently.
 
 The foreground chat still uses `codex exec`. That invocation exits after one

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jc_stack/ez-agents",
-  "version": "0.1.0-beta.40",
+  "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/host-executor.ts

@@ -11,7 +11,6 @@ import { startExecutorJob, terminateJob, resolveExecutor, validateCodexProvider,
 import { parseIsolationClass, type IsolationClass } from './isolation.js'
 import { readModels, validateSelection, validateOpencodeProviders, type ModelChoice } from './ai.js'
 import type { ChildProcess } from 'node:child_process'
-import { taskWorkspace } from './task-workspace.js'
 import { packageVersion } from './version.js'
 import { installedPluginVersions } from './software-status.js'
 import { processSnapshot } from './process-tree.js'
@@ -52,6 +51,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
   let catalogRefresh: Promise<void> | undefined
   const locks: string[] = []
   const sharedWorkspaces = new Map<HostBinding, string>()
+  const activeWorkspaces = new Set<HostBinding>()
   const additionalWorkspaces = new Map<HostBinding, string[]>()
   const catalog = async (agent: HostBinding) => {
     const discovered = await readModels(undefined, undefined, path.join(agent.controlDir, 'cli', 'codex'),
@@ -158,11 +158,13 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
           }
           const sharedWorkspace=sharedWorkspaces.get(agent)
           const base=path.join(directory,id)
-          const releaseWorkspace = !run?.scheduled && agent.toolsHome
+          if (activeWorkspaces.has(agent)) continue
+          const releaseWorkspace = agent.toolsHome
             ? await (await import('./plugins/workspace-lease.mjs')).workspaceLease(agent.toolsHome,{kind:'native',runId:id}) : undefined
-          if (!run?.scheduled && agent.toolsHome && !releaseWorkspace) continue
+          if (agent.toolsHome && !releaseWorkspace) continue
+          activeWorkspaces.add(agent)
           try { await rename(base+'.request.json',base+'.running.json') }
-          catch (error) { await releaseWorkspace?.(); throw error }
+          catch (error) { activeWorkspaces.delete(agent); await releaseWorkspace?.(); throw error }
           const task=(async()=>{
             let job: Awaited<ReturnType<typeof startExecutorJob>> | undefined
             let cancellation: ReturnType<typeof setInterval> | undefined
@@ -193,7 +195,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               // transient native-client probe failure must not reject a model
               // that the host just advertised to the relay and application.
               if (cli !== installation.cli) await validateSelection({id:'selected',name:'Selected model',cli,provider:opts.provider,model,effort:opts.effort},JSON.parse(await readFile(path.join(directory,'models.json'),'utf8')))
-              const options:ExecutorOptions={workspace:run?.scheduled ? await taskWorkspace(agent.controlDir,id) : agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,sharedWorkspace,additionalWorkspaces:additionalWorkspaces.get(agent),cli,
+              const options:ExecutorOptions={workspace:agent.workspace,controlDir:agent.controlDir,binDir:agent.binDir,toolsHome:agent.toolsHome,sharedWorkspace,additionalWorkspaces:additionalWorkspaces.get(agent),cli,
                 runId:path.basename(base),timeoutMs:0,repairEnabled:opts.repairEnabled,
                 sessionId:opts.sessionId,isResume:opts.isResume,model,effort:opts.effort,provider:opts.provider,codexAutoCompactTokens:opts.codexAutoCompactTokens,codexProvider:provider,
                 promptSuffix:runPromptSuffix(run),taskRun:Boolean(run?.taskId),nativeSession:Boolean(run?.scheduled)}
@@ -218,7 +220,7 @@ export const serveHostExecutor = async (installation: HostInstallation, signal:
               await rm(base+'.process.json',{force:true})
               await rm(base+'.cancel',{force:true})
               active.delete(base)
-              await releaseWorkspace?.()
+              try { await releaseWorkspace?.() } finally { activeWorkspaces.delete(agent) }
             }
           })()
           tasks.add(task); void task.finally(()=>tasks.delete(task))

package/src/index.ts

@@ -12,7 +12,6 @@ import { randomUUID } from 'node:crypto'
 import { stat } from 'node:fs/promises'
 import { Scheduler } from './scheduler.js'
 import { ownedScheduledTasks, scheduledTaskDetailText, scheduledTasksText } from './scheduled-tasks.js'
-import { taskWorkspace } from './task-workspace.js'
 import { EventSources, eventRunId, batchReady, type SourceEvent } from './event-sources.js'
 import {removeTaskAttachments} from './task-attachments.js'
 import { dirname, join, basename } from 'node:path'
@@ -206,7 +205,8 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         return
       }
       if (run.scheduled && !(await scheduler.get(run.scheduled.id)).enabled) return
-      if (run.scheduled ? background.size >= 4 : activeChild) return
+      // Owner turns and schedules write the same mind. Keep one native writer.
+      if (activeChild || background.size) return
       let texts = run.texts
       if (run.external) {
         // Availability failures leave durable queued work for a later check.
@@ -240,7 +240,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
           : await control.executionSession(started.execution!)
         const selected = run.taskId ? (started.execution?.preset.cli === 'codex' ? started.execution.preset : initialPreset('codex')) : started.execution!.preset
         const { child, cleanup } = await launch(texts, {
-          workspace: run.scheduled ? await taskWorkspace(config.controlDir,run.id) : config.workspace,
+          workspace: config.workspace,
           timeoutMs: config.executorTimeoutMs,
           repairEnabled: config.repairEnabled,
           runId: started.id,
@@ -319,7 +319,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
               }
             })
             console.info('run ended', { run_id: started.id, code })
-            const next = await runs.nextQueued(false)
+            const next = await runs.nextQueued()
             if (next && !shuttingDown) await startJob(next)
           })().catch((error) => console.error('Run completion failed', error.message))
         })
@@ -336,7 +336,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
         if (bot && !run.application && !run.delivery && run.chatId !== undefined) await sendChat(run.chatId, `Run ${run.id} failed to start. Check the local relay log.`)
         setImmediate(() => {
           void runs
-            .nextQueued(false)
+            .nextQueued()
             .then((next) => next && startJob(next))
             .catch(console.error)
         })
@@ -571,7 +571,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
             ])
             console.info('run reaction sent', { run_id: item.runId, emoji })
           } else if (item.type === 'document' && item.documentPath) {
-            const docPath = await workspaceFile(origin?.scheduled ? await taskWorkspace(config.controlDir,origin.id) : config.workspace, item.documentPath)
+            const docPath = await workspaceFile(config.workspace, item.documentPath)
             await paceSend()
             await authorizeChannelDelivery()
             attemptedDelivery = true
@@ -1206,7 +1206,7 @@ export const createRelay = (config: Config, launch = startExecutorJob) => {
       }
       const currentRunning = await runs.running(false)
       if (!currentRunning) {
-        const pendingRun = await runs.nextQueued(false)
+        const pendingRun = await runs.nextQueued()
         if (pendingRun) {
           console.info('Processing queued run on startup:', pendingRun.id)
           void startJob(pendingRun)

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/host-executor.test.ts

@@ -284,18 +284,23 @@ test('one installed CLI executes two agent bindings with separate minds and sani
       assert.match(output, /"stream":"exit","code":0/)
       return output.trim().split('\n').map(line=>JSON.parse(line))
     }
-    // A running scheduled engine does not reserve either its agent or its
-    // shared workspace, including another binding through a filesystem alias.
-    const [,,chatEvents]=await Promise.all([completed(directory,'r_schedule_queued'),completed(otherDirectory,'r_other_shared'),completed(directory,'tg_42')])
-    const chat=JSON.parse(chatEvents.filter(e=>e.stream==='stdout').map(e=>e.text).join(''))
-    assert.match(chat.args.at(-1),/^Chat while scheduled work runs/)
-    assert.match(chat.args.at(-1),/ezenciel-agents-message/)
+    // Another agent remains independent; this agent's queued schedule and chat
+    // wait behind its active owner schedule in the same mind.
+    await completed(otherDirectory,'r_other_shared')
+    assert.ok(await readFile(path.join(directory,'r_schedule_queued.request.json')))
+    assert.ok(await readFile(path.join(directory,'tg_42.request.json')))
     assert.doesNotMatch(await readFile(path.join(directory,'r_hold.events'),'utf8'),/"stream":"exit"/)
     await readFile(path.join(directory,'r_hold.running.json'))
     await writeFile(path.join(directory,'r_hold.cancel'),'')
     let heldOutput=''
     for(let n=0;n<200;n++){heldOutput=await readFile(path.join(directory,'r_hold.events'),'utf8');if(heldOutput.includes('"stream":"exit"'))break;await new Promise(r=>setTimeout(r,20))}
     assert.match(heldOutput, /"stream":"exit","code":1/)
+    const [scheduleEvents,chatEvents]=await Promise.all([completed(directory,'r_schedule_queued'),completed(directory,'tg_42')])
+    const scheduled=JSON.parse(scheduleEvents.filter(e=>e.stream==='stdout').map(e=>e.text).join(''))
+    const chat=JSON.parse(chatEvents.filter(e=>e.stream==='stdout').map(e=>e.text).join(''))
+    assert.equal(scheduled.cwd,await realpath(agents[0].workspace))
+    assert.match(chat.args.at(-1),/^Chat while scheduled work runs/)
+    assert.match(chat.args.at(-1),/ezenciel-agents-message/)
   } finally {
     abort.abort();await server
     EXECUTOR_REGISTRY.grok.command=old

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-host.test.ts

@@ -11,11 +11,12 @@ import { RunStore } from '../src/runs.js'
 
 const until=async(check:()=>Promise<boolean>)=>{for(let n=0;n<250;n++){if(await check())return;await new Promise(r=>setTimeout(r,20))}throw new Error('Host probe timed out')}
 const stdout=(events:string) => events.trim().split('\n').filter(Boolean).map(line=>JSON.parse(line)).filter(event=>event.stream==='stdout').map(event=>event.text).join('')
-test('host transport reserves separate task and main lanes, pins directories, and cancels only its target',async()=>{
+test('host transport serializes owner schedules and chat in the bound mind',async()=>{
  const root=await mkdtemp(join(tmpdir(),'ez-scheduler-host-')),workspace=join(root,'agent'),controlDir=join(root,'control')
  await mkdir(workspace);await mkdir(controlDir)
+ await writeFile(join(workspace,'AGENTS.md'),'bound-owner-instructions')
  const script=join(root,'fixture.mjs')
- await writeFile(script,`console.log(JSON.stringify({cwd:process.cwd(),token:process.env.TELEGRAM_BOT_TOKEN,run:process.env.EZ_RUN_ID}));if(process.env.EZ_RUN_ID.startsWith('r_schedule_'))setInterval(()=>{},1000);`)
+ await writeFile(script,`import {readFileSync} from 'node:fs';console.log(JSON.stringify({cwd:process.cwd(),agents:readFileSync('AGENTS.md','utf8'),token:process.env.TELEGRAM_BOT_TOKEN,run:process.env.EZ_RUN_ID}));if(process.env.EZ_RUN_ID.startsWith('r_schedule_'))setInterval(()=>{},1000);`)
  const old={...EXECUTOR_REGISTRY.grok},token=process.env.TELEGRAM_BOT_TOKEN
  EXECUTOR_REGISTRY.grok.command=process.execPath;EXECUTOR_REGISTRY.grok.buildArgs=()=>[script]
  process.env.TELEGRAM_BOT_TOKEN='never-in-child'
@@ -31,21 +32,29 @@ test('host transport reserves separate task and main lanes, pins directories, an
   await submit(id)
   await until(async()=>Boolean(await exists(id+'.process.json')))
   await submit('tg_1')
-  await until(async()=>(await exists('tg_1.events')).includes('"stream":"exit","code":0'))
+  await new Promise(resolve=>setTimeout(resolve,300))
+  assert.ok(await exists('tg_1.request.json'))
+  assert.equal(await exists('tg_1.events'),'')
   assert.ok(!(await exists(id+'.events')).includes('"stream":"exit"'))
   const scheduled=JSON.parse(stdout(await exists(id+'.events')))
-  const main=JSON.parse(stdout(await exists('tg_1.events')))
-  assert.equal(scheduled.cwd,await realpath(join(controlDir,'work/tasks',id)));assert.equal(main.cwd,await realpath(workspace))
-  assert.equal(scheduled.token,undefined);assert.equal(main.token,undefined)
+  assert.equal(scheduled.cwd,await realpath(workspace))
+  assert.equal(scheduled.agents,'bound-owner-instructions')
+  assert.equal(scheduled.token,undefined)
   // An unknown scheduled run must not unwind the shared host service.
   await submit('r_schedule_corrupt')
   await until(async()=>(await exists('r_schedule_corrupt.events')).includes('"stream":"exit","code":1'))
   assert.ok(!(await exists(id+'.events')).includes('"stream":"exit"'))
   await ownerRun(controlDir,'tg_2')
   await submit('tg_2')
-  await until(async()=>(await exists('tg_2.events')).includes('"stream":"exit","code":0'))
+  assert.ok(await exists('tg_2.request.json'))
   await writeFile(join(dir,id+'.cancel'),'')
   await until(async()=>(await exists(id+'.events')).includes('"stream":"exit"'))
+  await until(async()=>(await exists('tg_1.events')).includes('"stream":"exit","code":0'))
+  await until(async()=>(await exists('tg_2.events')).includes('"stream":"exit","code":0'))
+  const main=JSON.parse(stdout(await exists('tg_1.events')))
+  assert.equal(main.cwd,await realpath(workspace))
+  assert.equal(main.agents,'bound-owner-instructions')
+  assert.equal(main.token,undefined)
  }finally{
   abort.abort();await server
   Object.assign(EXECUTOR_REGISTRY.grok,old)

package/test/scheduler-relay.test.ts

@@ -44,7 +44,7 @@ test('a wrapper-shaped run id has no maintenance treatment and a stale notice is
  }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()=>{
+test('owner chat queues behind a scheduled CLI in the same workspace; 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)
  const replies:string[]=[], workspaces:string[]=[]
@@ -68,27 +68,20 @@ test('chat replies through the real ingress/outbox while scheduled CLI remains a
   assert.equal(background.status,'running')
   const update:Update={update_id:123,message:{message_id:123,date:0,text:'What is 17 × 19?',from:{id:101,is_bot:false,first_name:'Fixture'},chat:{id:101,type:'private',first_name:'Fixture'}}}
   await relay.bot.handleUpdate(update);await relay.drainInbox(true);await relay.drainOutbox()
-  assert.ok(replies.includes('323'))
+  assert.ok(!replies.includes('323'))
   assert.equal((await runs.get(background.id))?.status,'running')
   assert.equal(children[0].exitCode,null)
-  assert.equal(new Set(workspaces).size,2)
+  assert.deepEqual(workspaces,[dir])
   // Pausing future dispatch doesn't kill active work; cancelling this run does.
   await scheduler.enable('slow',false);await relay.drainSources()
   assert.equal(children[0].exitCode,null)
   await scheduler.cancel(background.id);await relay.drainSources()
   await until(async()=> (await runs.get(background.id))?.status==='cancelled')
+  await until(async()=>children.length===2)
+  await relay.drainOutbox()
+  assert.ok(replies.includes('323'))
+  assert.deepEqual(workspaces,[dir,dir])
   assert.equal((await runs.list()).filter(r=>r.scheduled).length,1)
-  for(let n=0;n<5;n++)await scheduler.save({id:'pool_'+n,name:'Pool',text:'Long work',trigger:{at:new Date(Date.now()+2000).toISOString()},enabled:true,owner,execution})
-  await scheduler.tick(owner,runs,Date.now()+3000);await relay.drainSources()
-  const queued=(await runs.list()).find(r=>r.scheduled && r.status==='queued')!
-  assert.ok(queued)
-  assert.equal((await runs.list()).filter(r=>r.scheduled && r.status==='running').length,4)
-  await scheduler.enable(queued.scheduled!.id,false);await relay.drainSources()
-  assert.equal((await runs.get(queued.id))?.status,'queued')
-  await scheduler.enable(queued.scheduled!.id,true);await scheduler.cancel(queued.id);await relay.drainSources()
-  assert.equal((await runs.get(queued.id))?.status,'cancelled')
-  await relay.bot.handleUpdate({...update,update_id:124,message:{...update.message!,message_id:124,text:'/stop'}} as Update)
-  await until(async()=>!(await runs.list()).some(r=>r.scheduled && r.status==='running'))
  }finally{
   await relay.stop()
   for(const child of children)if(child.exitCode===null && child.signalCode===null)await once(child,'close')

package/test/scheduler.test.ts

@@ -1,13 +1,12 @@
 import test from 'node:test'
 import assert from 'node:assert/strict'
-import { mkdtemp, rm, writeFile, readFile, stat, symlink, mkdir } from 'node:fs/promises'
+import { mkdtemp, rm, writeFile, readFile, stat } from 'node:fs/promises'
 import { join } from 'node:path'
 import { tmpdir } from 'node:os'
 import { randomUUID } from 'node:crypto'
 import { Scheduler, scheduledRunId } from '../src/scheduler.js'
 import { RunStore } from '../src/runs.js'
 import { nextOccurrence, validateTrigger, type Trigger } from '../src/schedule-time.js'
-import { taskWorkspace } from '../src/task-workspace.js'
 
 const next=(t:Trigger,after:string)=>{
  const at=nextOccurrence(validateTrigger(t),Date.parse(after));return at===null ? null : new Date(at).toISOString()
@@ -56,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)
@@ -76,19 +116,6 @@ test('pause, edit, removal, owner revocation, corrupt records and traversal fail
  await assert.rejects(f.scheduler.cancel('../bad'))
  await f.scheduler.cancel(run.id);assert.equal(await f.scheduler.cancelled(run.id),true)
 })
-test('task workspaces are distinct and cannot escape through symlinks',async t=>{
- const f=await fixture(t)
- await writeFile(join(f.dir,'private.md'),'Owner context')
- const first=await taskWorkspace(f.dir,'r_one'),second=await taskWorkspace(f.dir,'r_two')
- assert.notEqual(first,second)
- await assert.rejects(readFile(join(first,'private.md'),'utf8'),{code:'ENOENT'})
- await assert.rejects(readFile(join(first,'AGENTS.md'),'utf8'),{code:'ENOENT'})
- await assert.rejects(taskWorkspace(f.dir,'../escape'))
- const other=join(f.dir,'other');await mkdir(other)
- await symlink(other,join(f.dir,'work/tasks/r_link'))
- await assert.rejects(taskWorkspace(f.dir,'r_link'))
-})
-
 test('startup quarantines an interrupted spawn before PID persistence; explicit edit releases its schedule',async t=>{
  const f=await fixture(t),s=await f.scheduler.save({...f.input,trigger:{everySeconds:60,start:new Date(f.now).toISOString()}})
  await f.scheduler.tick(f.owner,f.runs,f.now)

package/src/task-workspace.ts

@@ -1,14 +0,0 @@
-import { mkdir, lstat } from 'node:fs/promises'
-import { join } from 'node:path'
-import { assertId } from './identity.js'
-
-// Fixed, agent-bound path under the control directory, never the workspace
-// mind folder and never a caller-provided cwd. No shared mutable task files.
-export async function taskWorkspace(baseDir: string, id: string): Promise<string> {
-  const dirs=[join(baseDir,'work'),join(baseDir,'work','tasks'),join(baseDir,'work','tasks',assertId(id))]
-  for(const dir of dirs){
-    await mkdir(dir,{recursive:true,mode:0o700})
-    if(!(await lstat(dir)).isDirectory())throw new Error('Task workspace must not be a symlink')
-  }
-  return dirs[2]
-}