dimcode-darwin-x64 0.1.0-alpha.16 → 0.1.0-alpha.18

package/plugins/scheduler/engine.ts

@@ -1,436 +0,0 @@
-import { randomUUID } from 'node:crypto'
-import type { Sessions } from '../../../npm/plugin.js'
-import { effective, ScheduleError, within, type Job } from './data.ts'
-import { RunHistory } from './history.ts'
-import { SettingsReadError, type Jobs } from './jobs.ts'
-import { unloadingBeforeCall } from './requests.ts'
-import { terminal, type Run, type RunStore } from './store.ts'
-import { latestWindow, windowAfter } from './windows.ts'
-
-const pause = (milliseconds: number) => new Promise<void>(resolve => setTimeout(resolve, milliseconds))
-const escaped = (text: string) => text.replace(/[&<>"']/g, character => ({ '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&apos;' })[character]!)
-
-export class Scheduler {
-  readonly jobs: Jobs
-  readonly sessions: Sessions
-  readonly store: RunStore
-  closing = false
-  fault: unknown
-  readonly work = new Map<string, Promise<unknown>>()
-  private pruning = false
-  private retryPruneAt: number | undefined
-  private nextWindowAt: number | undefined
-  private rewake = false
-  /// The report's guidance line: the factory configuration's text or
-  /// the built-in one.
-  private readonly reportGuidance: string
-
-  constructor(jobs: Jobs, sessions: Sessions, store: RunStore, reportGuidance = 'Inspect schedule.history for this job.') {
-    this.jobs = jobs; this.sessions = sessions; this.store = store; this.reportGuidance = reportGuidance
-  }
-
-  async track<T>(operation: () => Promise<T>, key: string = randomUUID()): Promise<T> {
-    if (this.closing) throw new ScheduleError('service_reloading', unloadingBeforeCall)
-    if (this.fault) throw this.fault
-    const work = operation()
-    this.work.set(key, work)
-    try { return await work }
-    finally { this.work.delete(key) }
-  }
-
-  async restore() {
-    const runs = await this.store.read()
-    for (const run of runs.filter(run => !terminal(run))) {
-      this.background(run.run_id, () => this.resume(run))
-    }
-    this.requestPrune()
-  }
-
-  startTimer() {
-    this.background('timer', async () => {
-      let minute: number | undefined
-      while (!this.closing && !this.fault) {
-        const now = Date.now(), currentMinute = Math.floor(now / 60_000)
-        if (minute !== currentMinute || this.nextWindowAt !== undefined && now >= this.nextWindowAt) {
-          minute = currentMinute
-          this.nextWindowAt = undefined
-          this.changed()
-        }
-        if (this.retryPruneAt !== undefined && Date.now() >= this.retryPruneAt) this.requestPrune()
-        await pause(1000)
-      }
-    })
-  }
-
-  changed() {
-    if (this.closing || this.fault) return
-    if (this.work.has('wake')) this.rewake = true
-    else this.background('wake', async () => { this.nextWindowAt = await this.tick() })
-  }
-
-  private background(key: string, operation: () => Promise<unknown>) {
-    void this.track(operation, key).catch(error => {
-      if (key !== 'wake' && !(error instanceof SettingsReadError)) this.fault = error
-      console.error('Scheduler', error instanceof Error ? error.message : String(error))
-    }).finally(() => {
-      if (key === 'wake' && this.rewake) {
-        this.rewake = false
-        this.changed()
-      }
-      if (!['timer', 'retention', 'wake'].includes(key) && !this.closing && !this.fault) {
-        this.requestPrune()
-        this.changed()
-      }
-    })
-  }
-
-  private requestPrune() {
-    if (this.pruning) this.retryPruneAt ??= Date.now()
-    else this.background('retention', () => this.prune())
-  }
-
-  async close() {
-    this.closing = true
-    while (this.work.size) await Promise.allSettled([...this.work.values()])
-    await this.store.scope.close()
-  }
-
-  async tick() {
-    const { document } = await this.jobs.read()
-    const runs = await this.store.read()
-    let nextWindow: number | undefined
-    for (const job of document.jobs.filter(job => job.enabled)) {
-      if (this.closing || this.fault) break
-      try {
-        const schedule = job.schedule
-        if ('at' in schedule && runs.some(run => run.job_id === job.id && run.window === new Date(schedule.at).toISOString()
-          && (terminal(run) || run.input_event_id))) {
-          await this.jobs.settleWindow(job)
-          continue
-        }
-        const windows = runs.filter(run => run.job_id === job.id && run.window !== 'manual').map(run => run.window)
-        const previous = windows.length ? Date.parse(windows.sort().at(-1)!)
-          : 'at' in schedule ? Number.NEGATIVE_INFINITY : Date.parse(job.enabled_at!) - 1
-        const next = windowAfter(job, previous)
-        if (next === undefined) continue
-        if (next > Date.now()) {
-          if (next < (Math.floor(Date.now() / 60_000) + 1) * 60_000) {
-            nextWindow = Math.min(nextWindow ?? next, next)
-          }
-          continue
-        }
-        const window = Date.now() - next >= 60_000 ? latestWindow(job, Date.now()) : next
-        await this.accept(job.id, new Date(window).toISOString(), Date.now() - window >= 60_000)
-      } catch (error) {
-        console.error('Scheduler job', job.id, error instanceof Error ? error.message : String(error))
-      }
-    }
-    return nextWindow
-  }
-
-  async accept(jobId: string, window = 'manual', missed = false): Promise<Run> {
-    const { document } = await this.jobs.read()
-    const snapshot = document.jobs.find(job => job.id === jobId)
-    if (!snapshot) throw new ScheduleError('schedule_not_found')
-    const accepted = await this.store.update(runs => {
-      const existing = window === 'manual' ? undefined : runs.find(run => run.job_id === jobId && run.window === window)
-      if (existing) return { run: existing, fresh: false }
-      const now = new Date(Date.now()).toISOString()
-      const reason = missed ? 'missed' : !snapshot.enabled ? 'disabled'
-        : runs.some(run => run.job_id === jobId && !terminal(run)) ? 'overlap'
-        : runs.filter(run => !terminal(run)).length >= document.max_concurrent_runs ? 'capacity' : undefined
-      const deadline = new Date(Date.now() + snapshot.max_run_minutes * 60_000)
-      if (!reason && (!Number.isFinite(deadline.getTime()) || deadline.getUTCFullYear() > 9999)) {
-        throw new ScheduleError('schedule_invalid', 'Run deadline exceeds the persisted timestamp range')
-      }
-      const runId = randomUUID()
-      const run: Run = { run_id: runId, job_id: jobId, window, state: reason ? missed ? 'missed' : 'skipped' : 'launching',
-        created_at: now, submission_id: `scheduler:${runId}`, detail: reason ?? '',
-        ...(reason ? { ended_at: now } : {
-          deadline_at: deadline.toISOString(),
-          ...(snapshot.created_by === 'user' ? {} : { report_to: snapshot.created_by.tool }),
-        }),
-      }
-      runs.push(run)
-      return { run, fresh: true }
-    })
-    if (accepted.fresh && !terminal(accepted.run)) this.background(accepted.run.run_id, () => this.execute(snapshot, accepted.run))
-    else if (accepted.fresh) {
-      if (window !== 'manual' && 'at' in snapshot.schedule) await this.jobs.settleWindow(snapshot)
-      this.requestPrune()
-    }
-    return accepted.run
-  }
-
-  private async check(snapshot: Job, runId: string, revision = snapshot.revision,
-    binding = snapshot.session_id): Promise<Run | undefined> {
-    let current: Job | undefined
-    try { current = (await this.jobs.read()).document.jobs.find(job => job.id === snapshot.id) }
-    catch (error) {
-      if (!(error instanceof SettingsReadError)) throw error
-      await this.finish(runId, 'skipped', 'settings_read_failed')
-      return undefined
-    }
-    const run = (await this.store.read()).find(run => run.run_id === runId)!
-    if (terminal(run) || this.closing || this.fault) return undefined
-    if (Date.now() >= Date.parse(run.deadline_at!)) {
-      await this.finish(runId, 'timed_out', 'deadline_before_input')
-      return undefined
-    }
-    if (!current || current.revision !== revision || !current.enabled
-      || current.mode !== snapshot.mode || current.session_id !== binding) {
-      await this.finish(runId, 'skipped', current && !current.enabled ? 'disabled' : 'changed')
-      return undefined
-    }
-    return run
-  }
-
-  private async execute(snapshot: Job, accepted: Run) {
-    const submitted = await this.submit(snapshot, accepted)
-    if (submitted) await this.follow({ ...accepted, session_id: submitted.sessionId, input_event_id: submitted.receipt.inputId }, submitted.receipt.sequence)
-  }
-
-  private async bind(snapshot: Job, runId: string, sessionId: string): Promise<number | 'unbound' | undefined> {
-    for (let attempt = 0; attempt < 2; attempt++) {
-      const run = (await this.store.read()).find(run => run.run_id === runId)!
-      if (terminal(run) || this.closing || this.fault) return
-      let result
-      try {
-        result = await this.jobs.bind(snapshot, sessionId)
-      } catch (error) {
-        if (error instanceof SettingsReadError) await this.finish(runId, 'skipped', 'settings_read_failed')
-        else if (error instanceof ScheduleError && error.code === 'schedule_conflict') {
-          if (attempt === 0) continue
-          await this.store.update(runs => { runs.find(run => run.run_id === runId)!.detail = 'binding_conflict' })
-          return 'unbound'
-        } else if (error instanceof ScheduleError && ['user_only_field', 'invalid_document'].includes(error.code)) {
-          await this.finish(runId, 'failed', `binding_rejected: ${error.code}`)
-        } else await this.finish(runId, 'skipped', 'binding_unconfirmed')
-        return
-      }
-      if (typeof result === 'number') return result
-      await this.finish(runId, 'skipped', result)
-      return
-    }
-  }
-
-  private async submit(snapshot: Job, accepted: Run) {
-    if (!await this.check(snapshot, accepted.run_id)) return
-    let requested
-    try { requested = effective(snapshot) }
-    catch (error) {
-      if (!(error instanceof ScheduleError)) throw error
-      await this.finish(accepted.run_id, 'failed', error.code)
-      return
-    }
-    let sessionId: string
-    if (snapshot.mode === 'create' || !snapshot.session_id) {
-      let reply
-      try {
-        reply = await this.sessions.launch({ cwd: snapshot.cwd, policy: requested,
-          ...(snapshot.agent_id ? { agent: snapshot.agent_id } : {}), ...(snapshot.model ? { model: snapshot.model } : {}),
-          ...(snapshot.created_by === 'user' ? {} : { starter: {
-            sessionId: snapshot.created_by.tool.session_id, branchId: snapshot.created_by.tool.branch_id,
-          } }),
-        })
-      } catch {
-        await this.finish(accepted.run_id, 'lost', 'launch_reply_unknown')
-        return
-      }
-      if (!reply.ok) {
-        await this.finish(accepted.run_id, 'failed', reply.error.code)
-        return
-      }
-      sessionId = reply.value.sessionId
-      await this.store.update(runs => Object.assign(runs.find(run => run.run_id === accepted.run_id)!, {
-        session_id: sessionId, session_origin: 'launch', policy: reply.value.policy,
-      }))
-    } else {
-      let live, actual
-      try {
-        live = snapshot.created_by === 'user' ? await this.jobs.permissions.permissionDefaults({})
-          : (await this.jobs.permissions.permission({ sessionId: snapshot.created_by.tool.session_id, branchId: snapshot.created_by.tool.branch_id })).policy
-      } catch {
-        if (await this.check(snapshot, accepted.run_id)) await this.finish(accepted.run_id, 'skipped', 'policy_read_failed')
-        return
-      }
-      try {
-        actual = (await this.jobs.permissions.permission({ sessionId: snapshot.session_id, branchId: 'main' })).policy
-      } catch (error) {
-        const missing = error !== null && typeof error === 'object' && 'code' in error
-          && (error.code === 'session_closed' || error.code === 'branch_missing') ? error.code : undefined
-        if (await this.check(snapshot, accepted.run_id)) await this.finish(accepted.run_id,
-          missing ? 'failed' : 'skipped', missing ?? 'policy_read_failed')
-        return
-      }
-      if (!within(actual, requested) || !within(actual, live)) {
-        if (await this.check(snapshot, accepted.run_id)) await this.finish(accepted.run_id, 'skipped', 'policy')
-        return
-      }
-      sessionId = snapshot.session_id
-      await this.store.update(runs => Object.assign(runs.find(run => run.run_id === accepted.run_id)!, {
-        session_id: sessionId, session_origin: 'reuse', policy: actual,
-      }))
-    }
-    let revision = snapshot.revision, binding = snapshot.session_id
-    if (snapshot.mode === 'reuse' && !snapshot.session_id) {
-      const bound = await this.bind(snapshot, accepted.run_id, sessionId)
-      if (bound === undefined) return
-      if (bound !== 'unbound') { revision = bound; binding = sessionId }
-    }
-    if (!await this.check(snapshot, accepted.run_id, revision, binding)) return
-    let receipt, inputReply
-    try {
-      inputReply = await this.sessions.input({ sessionId, branchId: 'main', mode: 'queue', submissionId: accepted.submission_id,
-        rawBlocks: [{ text: `<dim-scheduler kind="scheduled-run" job="${escaped(snapshot.id)}" run="${escaped(accepted.run_id)}">${escaped(snapshot.name)}</dim-scheduler>` }],
-        content: [{ type: 'text', text: snapshot.prompt }],
-      })
- } catch { }
-    if (inputReply?.ok) receipt = inputReply.value
-    else if (inputReply && !['reloading', 'publication_unknown', 'ambiguous'].includes(inputReply.error.code)) {
-      await this.finish(accepted.run_id, 'failed', inputReply.error.code)
-      return
-    }
-    if (!receipt) {
-      const current = (await this.store.read()).find(run => run.run_id === accepted.run_id)!
-      receipt = await this.lookup(current)
-      if (!receipt) return
-    }
-    await this.store.update(runs => Object.assign(runs.find(run => run.run_id === accepted.run_id)!, {
-      state: 'submitted', input_event_id: receipt.inputId,
-    }))
-    return { sessionId, receipt }
-  }
-
-  private async lookup(run: Run) {
-    while (!this.closing) {
-      let reply
-      try { reply = await this.sessions.lookup({ sessionId: run.session_id!, branchId: 'main', submissionId: run.submission_id }) }
-      catch { await pause(1000); continue }
-      if (reply.ok) {
-        if (reply.value.status === 'accepted') return reply.value
-        await this.finish(run.run_id, 'lost', 'input_unknown')
-        return
-      }
-      if (reply.error.code !== 'reloading') { await this.finish(run.run_id, 'lost', reply.error.code); return }
-      await pause(1000)
-    }
-  }
-
-  private async resume(run: Run) {
-    if (!run.session_id) { await this.finish(run.run_id, 'lost', 'launch_identity_unknown'); return }
-    if (!run.input_event_id) {
-      const found = await this.lookup(run)
-      if (!found) return
-      await this.store.update(runs => Object.assign(runs.find(value => value.run_id === run.run_id)!, { state: 'submitted', input_event_id: found.inputId }))
-      await this.follow({ ...run, input_event_id: found.inputId }, found.sequence)
-    } else await this.follow(run)
-  }
-
-  private async follow(run: Run, after = 0) {
-    const history = new RunHistory(this.sessions, run.session_id!, run.input_event_id!, after)
-    let stopIssued = false
-    while (!this.closing && !this.fault) {
-      if (!await history.read()) { await pause(1000); continue }
-      if (history.outcome) {
-        await this.finish(run.run_id, stopIssued && history.outcome.state === 'cancelled' ? 'timed_out' : history.outcome.state, history.outcome.detail)
-        return
-      }
-      if (Date.now() >= Date.parse(run.deadline_at!)) {
-        if (history.applied && history.interrupted && !history.consumed) {
-          await this.finish(run.run_id, 'timed_out', 'interrupted_before_consumption')
-          return
-        }
-        if (!history.applied && !history.consumed) {
-          let withdrawn
-          try { withdrawn = await this.sessions.withdraw({ sessionId: run.session_id!, branchId: 'main', inputId: run.input_event_id!, reason: 'scheduled run timed out' }) }
- catch { }
-          if (withdrawn?.ok && withdrawn.value.status === 'deleted') { await this.finish(run.run_id, 'timed_out', 'withdrawn_at_deadline'); return }
-          await history.read()
-        } else if (history.consumed && !stopIssued) {
-          stopIssued = true
-          try {
-            const stopped = await this.sessions.stop({ sessionId: run.session_id!, branchId: 'main', reason: 'scheduled run timed out' })
-            if (!stopped.ok && stopped.error.code === 'reloading') stopIssued = false
-          }
- catch { }
-        }
-      } else if (history.consumed && run.state !== 'running') {
-        await this.store.update(runs => { runs.find(value => value.run_id === run.run_id)!.state = 'running' })
-        run.state = 'running'
-      }
-      const remaining = Date.parse(run.deadline_at!) - Date.now()
-      await pause(remaining > 0 ? Math.min(1000, remaining) : 1000)
-    }
-  }
-
-  private async finish(runId: string, state: Run['state'], detail: string) {
-    const run = await this.store.update(runs => {
-      const run = runs.find(run => run.run_id === runId)!
-      if (terminal(run)) return undefined
-      run.state = state
-      run.detail = run.detail === 'binding_conflict' ? `binding_conflict${detail ? `; ${detail}` : ''}` : detail
-      run.ended_at = new Date(Date.now()).toISOString()
-      return run
-    })
-    if (!run?.report_to || !['completed', 'failed', 'cancelled', 'timed_out', 'lost'].includes(run.state)) return
-    let failure: string | undefined
-    try {
-      const body = `Scheduled job ${run.job_id}, run ${run.run_id}: ${run.state} (${run.detail}).${run.session_id ? ` Session ${run.session_id}.` : ''}\n${this.reportGuidance}`
-      const reply = await this.sessions.input({ sessionId: run.report_to.session_id, branchId: run.report_to.branch_id,
-        mode: 'steer', submissionId: `scheduler-report:${run.run_id}`, rawBlocks: [{ text:
-          `<dim-scheduler kind="report" job="${escaped(run.job_id)}" run="${escaped(run.run_id)}">${escaped(body)}</dim-scheduler>`,
-        }], content: [],
-      })
-      if (!reply.ok) failure = reply.error.code
-    } catch { failure = 'bridge_error' }
-    if (failure) await this.store.update(runs => {
-      runs.find(value => value.run_id === runId)!.detail += `; report_failed: ${failure}`
-    })
-  }
-
-  async prune() {
-    if (this.pruning) {
-      this.retryPruneAt ??= Date.now()
-      return
-    }
-    this.pruning = true
-    this.retryPruneAt = undefined
-    try {
-      const runs = await this.store.read()
-      const { document } = await this.jobs.read()
-      const keep = new Set(runs.filter(run => !terminal(run) || this.work.has(run.run_id)).map(run => run.run_id))
-      for (const job of document.jobs) {
-        const newest = runs.filter(run => run.job_id === job.id && terminal(run))
-          .sort((a, b) => b.ended_at!.localeCompare(a.ended_at!) || b.run_id.localeCompare(a.run_id)).slice(0, 100)
-        for (const run of newest) keep.add(run.run_id)
-      }
-      const references = new Set([...document.jobs.filter(job => job.mode === 'reuse').map(job => job.session_id),
-        ...runs.filter(run => keep.has(run.run_id)).map(run => run.session_id)].filter((id): id is string => id !== undefined))
-      for (const sessionId of references) {
-        const ownership = runs.filter(run => run.session_id === sessionId && run.session_origin === 'launch')
-          .sort((a, b) => b.created_at.localeCompare(a.created_at) || b.run_id.localeCompare(a.run_id))[0]
-        if (ownership) keep.add(ownership.run_id)
-      }
-      const expired = runs.filter(run => !keep.has(run.run_id))
-      const deletions = new Set(expired.filter(run => run.session_origin === 'launch' && !references.has(run.session_id!)).map(run => run.session_id!))
-      for (const sessionId of deletions) {
-        try {
-          const reply = await this.sessions.delete({ sessionId })
-          if (!reply.ok) throw new ScheduleError(reply.error.code)
-        } catch (error) {
-          this.retryPruneAt = Date.now() + 60_000
-          for (const run of expired.filter(run => run.session_id === sessionId && run.session_origin === 'launch')) keep.add(run.run_id)
-          console.error('Scheduler cleanup', error instanceof Error ? error.message : String(error))
-        }
-      }
-      const remove = new Set(expired.filter(run => !keep.has(run.run_id)).map(run => run.run_id))
-      if (remove.size) await this.store.update(current => {
-        for (let index = current.length - 1; index >= 0; index--) if (remove.has(current[index].run_id) && !this.work.has(current[index].run_id)) current.splice(index, 1)
-      })
-    } catch (error) {
-      this.retryPruneAt = Date.now() + 60_000
-      console.error('Scheduler retention', error instanceof Error ? error.message : String(error))
-    } finally { this.pruning = false }
-  }
-}

package/plugins/scheduler/history.ts

@@ -1,60 +0,0 @@
-import type { Sessions } from '../../../npm/plugin.js'
-import type { Run } from './store.ts'
-
-/** The published prefix following this run's own input; no idle wait or cross-Session subscription. */
-export class RunHistory {
-  readonly sessions: Sessions
-  readonly sessionId: string
-  readonly inputId: string
-  after: number
-  through: number | undefined
-  applied = false
-  consumed = false
-  deleted = false
-  interrupted = false
-  outcome: Pick<Run, 'state' | 'detail'> | undefined
-
-  constructor(sessions: Sessions, sessionId: string, inputId: string, after = 0) {
-    this.sessions = sessions; this.sessionId = sessionId; this.inputId = inputId; this.after = after
-  }
-
-  async read(): Promise<boolean> {
-    for (;;) {
-      let page
-      try {
-        page = await this.sessions.history({ sessionId: this.sessionId, branchId: 'main', after: this.after,
-          ...(this.through === undefined ? {} : { through: this.through }), limit: 256,
-        })
-      } catch (error) {
-        console.error('Scheduler history', this.sessionId, error instanceof Error ? error.message : String(error))
-        return false
-      }
-      if (!page.ok) {
-        if (page.error.code === 'reloading') return false
-        this.outcome ??= { state: 'failed', detail: page.error.code }
-        return true
-      }
-      this.through = page.value.through
-      for (const event of page.value.events) {
-        this.after = event.sequence
-        if (event.type === 'input' && event.data.input_id === this.inputId) {
-          if (event.name === 'applied') this.applied = true
-          if (event.name === 'consumed') this.consumed = true
-          if (event.name === 'deleted') this.deleted = true
-        }
-        if (this.applied && !this.consumed && event.type === 'stop' && event.name === 'interrupt') this.interrupted = true
-        if (this.consumed && !this.outcome && event.type === 'turn' && event.name === 'end') {
-          this.outcome = event.data.status === 'completed' ? { state: 'completed', detail: 'completed' }
-            : event.data.status === 'failed' ? { state: 'failed', detail: 'turn_failed' }
-            : { state: 'cancelled', detail: 'interrupted' }
-        }
-      }
-      if (!page.value.events.length || this.after >= this.through) {
-        this.after = this.through
-        this.through = undefined
-        if (this.deleted && !this.consumed) this.outcome = { state: 'cancelled', detail: 'withdrawn' }
-        return true
-      }
-    }
-  }
-}

package/plugins/scheduler/index.ts

@@ -1,164 +0,0 @@
-import { definePlugin } from '@arcships/rutis'
-import { z } from 'zod'
-import type { JsonObject, ManagementMethods, PartRegistry, PluginFiles, SessionPermissions, Sessions, Settings } from '../../../npm/plugin.js'
-import { ScheduleError, type Job } from './data.ts'
-import { Scheduler } from './engine.ts'
-import { Jobs } from './jobs.ts'
-import { bounded, management, unloadingBeforeCall, type ScheduleJobs } from './requests.ts'
-import session from './session.ts'
-import { settings } from './settings.ts'
-import { RunStore, type Run } from './store.ts'
-import { windowAfter } from './windows.ts'
-
-/// The plugin's factory configuration: the tool description and the
-/// report's guidance line, each one whole text. `report_guidance` is one
-/// line: the entry names the report's last line as guidance, not part of
-/// the scheduler's account, so a value with a line break is refused.
-const guidance = z.string().min(1).refine(value => !/[\r\n]/.test(value), {
-  message: 'report_guidance must be one line: the entry names the report\'s last line as guidance',
-})
-const options = z.strictObject({ description: z.string().min(1).optional(), report_guidance: guidance.optional() })
-
-function jobPreview(job: Job) {
-  return { ...job, name: bounded(job.name, 256), prompt: bounded(job.prompt, 4 * 1024),
-    prompt_truncated: Buffer.byteLength(job.prompt) > 4 * 1024 }
-}
-
-function runPreview(run: Run) { return { ...run, detail: bounded(run.detail, 512) } }
-
-export default definePlugin({
-  name: 'Scheduler',
-  // A plain JSON Schema: zod's result also carries `~standard`, which
-  // rutis refuses as a Standard Schema.
-  config: JSON.parse(JSON.stringify(z.toJSONSchema(options))),
-  inject: ['sessions', 'sessionPermissions', 'settings', 'pluginFiles', 'managementMethods', 'partRegistry'],
-  provides: { scheduleJobs: { call: 'async' } },
-  async apply(ctx, config: z.infer<typeof options>) {
-    config = options.parse(config)
-    await ctx.use<Settings>('settings').register(settings)
-    const jobs = new Jobs(ctx.use<Settings>('settings'), ctx.use<SessionPermissions>('sessionPermissions'))
-    const scope = await ctx.use<PluginFiles>('pluginFiles').open()
-    const scheduler = new Scheduler(jobs, ctx.use<Sessions>('sessions'), new RunStore(scope), config.report_guidance)
-    ctx.effect(() => scheduler.close())
-
-    async function list() {
-      const { document } = await jobs.read()
-      const runs = await scheduler.store.read()
-      return { jobs: document.jobs.map(job => {
-        const ownRuns = runs.filter(run => run.job_id === job.id).sort((a, b) => b.created_at.localeCompare(a.created_at) || b.run_id.localeCompare(a.run_id))
-        const windows = ownRuns.filter(run => run.window !== 'manual').map(run => run.window).sort()
-        const after = windows.length ? Date.parse(windows.at(-1)!)
-          : 'at' in job.schedule ? Number.NEGATIVE_INFINITY : Date.parse(job.enabled_at!) - 1
-        let next_window: string | null = null, issue: string | undefined
-        try {
-          const next = job.enabled ? windowAfter(job, after) : undefined
-          if (next !== undefined) next_window = new Date(next).toISOString()
-        }
-        catch (error) { issue = error instanceof Error ? error.message : String(error) }
-        return { ...job, next_window,
-          ...(issue ? { schedule_error: issue } : {}), last_run: ownRuns[0] ?? null }
-      }) }
-    }
-    const history = async (jobId: string, limit: number) => ({ runs: (await scheduler.store.read()).filter(run => run.job_id === jobId)
-      .sort((a, b) => b.created_at.localeCompare(a.created_at) || b.run_id.localeCompare(a.run_id)).slice(0, limit) })
-    async function remove(jobId: string) {
-      const result = await jobs.delete(jobId)
-      await scheduler.prune()
-      return result
-    }
-
-    const owner: ScheduleJobs = {
-      async call(request) {
-        try {
-          return await scheduler.track(async () => {
-            let records: JsonObject, visible: JsonObject
-            if (request.action === 'list') {
-              const listed = await list()
-              records = listed
-              visible = { jobs: listed.jobs.map(({ prompt, ...job }) => ({ ...job,
-                name: bounded(job.name, 256), last_run: job.last_run ? runPreview(job.last_run) : null,
-                ...(job.schedule_error ? { schedule_error: bounded(job.schedule_error, 512) } : {}),
-              })) }
-            } else if (request.action === 'get') {
-              const job = await jobs.get(request.job_id)
-              records = { job }; visible = { job: jobPreview(job) }
-            }
-            else if (request.action === 'create' || request.action === 'update') {
-              const saved = await jobs.save({ ...request.job, ...(request.action === 'update' ? { id: request.job_id } : {}) }, request.caller)
-              records = saved; visible = { ...saved, job: jobPreview(saved.job) }
-            } else if (request.action === 'set_enabled') {
-              const job = await jobs.setEnabled(request.job_id, request.enabled)
-              records = { job }; visible = { job: jobPreview(job) }
-            } else if (request.action === 'delete') visible = records = await remove(request.job_id)
-            else if (request.action === 'run_now') {
-              const run = await scheduler.accept(request.job_id)
-              records = run; visible = runPreview(run)
-            } else {
-              const result = await history(request.job_id, request.limit)
-              records = result; visible = { runs: result.runs.map(runPreview) }
-            }
-            return { content: JSON.stringify(visible), records }
-          })
-        } catch (error) {
-          if (error instanceof ScheduleError && error.code === 'service_reloading') {
-            return { code: 'service_unavailable', message: unloadingBeforeCall }
-          }
-          if (error instanceof ScheduleError) return { code: error.code, message: bounded(error.message, 4 * 1024) }
-          throw error
-        }
-      },
-    }
-    try { await scheduler.restore() }
-    catch (error) { scheduler.fault = error }
-
-    await ctx.use<ManagementMethods>('managementMethods').register(
-      'schedule',
-      ['list', 'save', 'delete', 'set_enabled', 'run_now', 'history'].map(name => ({
-        name: `schedule.${name}`, mutating: name !== 'list' && name !== 'history',
-        interruption: name === 'list' || name === 'history' ? 'report' : 'drain', progress: false,
-      })),
-      async (call, cancellation) => {
-        let cancelled = false
-        void cancellation.then(() => { cancelled = true }, () => { cancelled = true })
-        await Promise.resolve()
-        if (cancelled) return { code: 'service_reloading', message: 'Scheduler call cancelled before admission' }
-        try {
-          return await scheduler.track(async () => {
-            let value: JsonObject
-            switch (call.method) {
-              case 'schedule.list': management.list.parse(call.params); value = await list(); break
-              case 'schedule.save': {
-                const input = management.save.parse(call.params)
-                value = await jobs.save(input.job, undefined, input.revision)
-                break
-              }
-              case 'schedule.delete': value = await remove(management.delete.parse(call.params).job_id); break
-              case 'schedule.set_enabled': {
-                const input = management.set_enabled.parse(call.params)
-                value = { job: await jobs.setEnabled(input.job_id, input.enabled) }
-                break
-              }
-              case 'schedule.run_now': value = await scheduler.accept(management.run_now.parse(call.params).job_id); break
-              case 'schedule.history': {
-                const input = management.history.parse(call.params)
-                value = await history(input.job_id, input.limit)
-                break
-              }
-              default: return { code: 'unknown_method', message: 'Unknown Scheduler method' }
-            }
-            return { kind: 'value' as const, value }
-          })
-        } catch (error) {
-          if (error instanceof z.ZodError) return { code: 'schedule_invalid', message: error.message }
-          if (error instanceof ScheduleError) return { code: error.code, message: error.message }
-          throw error
-        }
-      },
-    )
-    if (scheduler.fault) throw scheduler.fault
-    ctx.provide('scheduleJobs', owner)
-    await ctx.use<PartRegistry>('partRegistry').registerDefinition('session', 'SchedulerSession', session(config.description))
-    ctx.on('settings/schedule', () => scheduler.changed())
-    scheduler.startTimer()
-  },
-})