opencode-overclock 0.3.0 → 0.5.0

package/src/features/recovery.ts

@@ -0,0 +1,153 @@
+import type { FeatureModule } from "../types.ts"
+import { inject, toast } from "../lib/inject.ts"
+
+export interface RecoveryOptions {
+  maxAttempts?: number
+  cooldownMs?: number
+  autoResume?: boolean
+}
+
+export interface ErrorClassification {
+  recoverable: boolean
+  reason?:
+    | "tool_result_missing"
+    | "thinking_order"
+    | "thinking_disabled"
+    | "context_limit"
+    | "rate_limit"
+    | "transient"
+  message?: string
+}
+
+const ERROR_PATTERNS: Array<{ regex: RegExp; reason: ErrorClassification["reason"] }> = [
+  {
+    regex: /tool_use.*(?:without|missing).*tool_result|tool_result.*missing/i,
+    reason: "tool_result_missing",
+  },
+  { regex: /thinking.*(?:must precede|preceded by|order)/i, reason: "thinking_order" },
+  { regex: /thinking.*(?:not allowed|disabled|unsupported)/i, reason: "thinking_disabled" },
+  {
+    regex: /prompt is too long|context.*(?:limit|window).*exceeded|maximum context length/i,
+    reason: "context_limit",
+  },
+  { regex: /rate[ _-]?limit|too many requests|overloaded/i, reason: "rate_limit" },
+  { regex: /socket hang up|ECONNRESET|ETIMEDOUT|network error/i, reason: "transient" },
+]
+
+/** Classify error into known recoverable provider failure modes. */
+export function classifyError(error: unknown): ErrorClassification {
+  if (!error) return { recoverable: false }
+
+  const errorString =
+    typeof error === "string"
+      ? error
+      : error instanceof Error
+        ? `${error.name}: ${error.message}`
+        : JSON.stringify(error)
+
+  for (const { regex, reason } of ERROR_PATTERNS) {
+    if (regex.test(errorString)) {
+      return { recoverable: true, reason, message: errorString }
+    }
+  }
+
+  return { recoverable: false, message: errorString }
+}
+
+export interface RecoveryTracker {
+  canAttempt(sessionID: string): boolean
+  recordAttempt(sessionID: string): void
+  reset(sessionID: string): void
+}
+
+/** Rate-limits recovery attempts per session. */
+export function createRecoveryTracker(maxAttempts = 3, cooldownMs = 60_000): RecoveryTracker {
+  const attempts = new Map<string, number[]>()
+
+  return {
+    canAttempt(sessionID: string): boolean {
+      const now = Date.now()
+      const list = (attempts.get(sessionID) ?? []).filter((t) => now - t < cooldownMs)
+      if (list.length === 0) {
+        attempts.delete(sessionID)
+      } else {
+        attempts.set(sessionID, list)
+      }
+      return list.length < maxAttempts
+    },
+    recordAttempt(sessionID: string): void {
+      const now = Date.now()
+      const list = (attempts.get(sessionID) ?? []).filter((t) => now - t < cooldownMs)
+      list.push(now)
+      attempts.set(sessionID, list)
+    },
+    reset(sessionID: string): void {
+      attempts.delete(sessionID)
+    },
+  }
+}
+
+/**
+ * Recovery module: automatically detects and recovers from transient provider errors,
+ * protocol sequencing glitches, and context window issues during autonomous sessions.
+ */
+export const recovery: FeatureModule = {
+  name: "recovery",
+  tools: [],
+  defaultEnabled: true,
+  requires: ["session.promptAsync", "session.messages"],
+  async init(ctx, options) {
+    const maxAttempts = typeof options.maxAttempts === "number" ? options.maxAttempts : 3
+    const cooldownMs = typeof options.cooldownMs === "number" ? options.cooldownMs : 60_000
+    const autoResume = options.autoResume !== false
+    const tracker = createRecoveryTracker(maxAttempts, cooldownMs)
+
+    return {
+      event: async ({ event }) => {
+        if (event.type === "session.deleted") {
+          const props = event.properties as { sessionID?: string; info?: { id?: string } } | undefined
+          const id = props?.sessionID ?? props?.info?.id
+          if (id) tracker.reset(id)
+          return
+        }
+
+        if (event.type !== "session.error") return
+
+        const props = event.properties as { sessionID?: string; error?: unknown } | undefined
+        const sessionID = props?.sessionID
+        if (!sessionID || !props?.error) return
+
+        const classified = classifyError(props.error)
+        if (!classified.recoverable) return
+
+        if (!tracker.canAttempt(sessionID)) {
+          console.warn(
+            `[overclock] recovery: exceeded max attempts (${maxAttempts}) for session ${sessionID}`,
+          )
+          await toast(ctx.client, `recovery failed: too many consecutive errors in session`, "error")
+          return
+        }
+
+        tracker.recordAttempt(sessionID)
+        console.warn(
+          `[overclock] recovery: session ${sessionID} error (${classified.reason}), attempting auto-resume`,
+        )
+        await toast(ctx.client, `recovering session from ${classified.reason}...`, "warning")
+
+        if (autoResume) {
+          if (classified.reason === "rate_limit") {
+            // Apply a brief backoff delay before retrying a throttled endpoint
+            await new Promise((r) => setTimeout(r, 2000))
+          }
+
+          const resumeText =
+            classified.reason === "context_limit"
+              ? "[session recovered: context limit reached; summarize recent progress and continue with minimal output]"
+              : `[session recovered from ${classified.reason} - please continue with your previous task]`
+
+          await inject(ctx.client, sessionID, resumeText)
+        }
+      },
+    }
+  },
+}

package/src/features/safety.ts

@@ -0,0 +1,147 @@
+import type { FeatureModule } from "../types.ts"
+import { toast } from "../lib/inject.ts"
+import { shellQuote } from "../lib/exec.ts"
+
+export interface DangerousPattern {
+  name: string
+  pattern: RegExp
+  reason: string
+}
+
+const GIT_PREFIX =
+  "\\bgit(?:\\s+(?:-[a-zA-Z0-9_.-]+|--[a-zA-Z0-9_.-]+(?:=\\S+)?|-[a-zA-Z]\\s+(?:\"[^\"]*\"|'[^']*'|\\S+)|--(?:git-dir|work-tree|namespace)\\s+(?:\"[^\"]*\"|'[^']*'|\\S+)))*\\s+"
+
+export const DANGEROUS_GIT_PATTERNS: DangerousPattern[] = [
+  {
+    name: "force-push",
+    pattern: new RegExp(
+      `${GIT_PREFIX}push\\b[^;&|\\n]*(?:\\s(?:--force(?:-with-lease)?\\b|-f\\b)|\\s\\+[^\\s:]+(?::\\S+)?)`,
+    ),
+    reason: "Force-pushing can overwrite remote history.",
+  },
+  {
+    name: "hard-reset",
+    pattern: new RegExp(`${GIT_PREFIX}reset\\b[^;&|\\n]*(?:\\s|^)--hard\\b`),
+    reason: "Hard-reset discards uncommitted changes permanently.",
+  },
+  {
+    name: "force-clean",
+    pattern: new RegExp(`${GIT_PREFIX}clean\\b[^;&|\\n]*(?:\\s-[a-zA-Z]*f[a-zA-Z]*|\\s--force\\b)`),
+    reason: "Force clean deletes untracked files irreversibly.",
+  },
+  {
+    name: "branch-force-delete",
+    pattern: new RegExp(
+      `${GIT_PREFIX}branch\\b[^;&|\\n]*(?:\\s-[a-zA-Z]*D[a-zA-Z]*|\\s--delete\\s+--force\\b|\\s--force\\s+--delete\\b|\\s-[a-zA-Z]*d[a-zA-Z]*\\s+-[a-zA-Z]*f[a-zA-Z]*|\\s-[a-zA-Z]*f[a-zA-Z]*\\s+-[a-zA-Z]*d[a-zA-Z]*)`,
+    ),
+    reason: "Force deleting a branch bypasses unmerged commit checks.",
+  },
+  {
+    name: "remote-branch-delete",
+    pattern: new RegExp(`${GIT_PREFIX}push\\b[^;&|\\n]*(?:\\s--delete\\b|\\s-d\\b|\\s:[\\w/.-]+)`),
+    reason: "Deleting a remote branch can impact other collaborators.",
+  },
+  {
+    name: "discard-all-worktree",
+    pattern: new RegExp(
+      `${GIT_PREFIX}(?:restore|checkout)\\b[^;&|\\n]*?(?:\\s(?:--\\s+)?(?:\\.|\\*|:\\/))(?=\\s|$|[;&|])`,
+    ),
+    reason: "Discarding entire worktree changes loses all in-progress edits.",
+  },
+  {
+    name: "stash-destroy",
+    pattern: new RegExp(`${GIT_PREFIX}stash\\s+(?:drop|clear)\\b`),
+    reason: "Dropping or clearing stashes deletes saved work.",
+  },
+  {
+    name: "rebase-skip",
+    pattern: new RegExp(`${GIT_PREFIX}rebase\\s+--skip\\b`),
+    reason: "Rebase skip drops the conflicting commit completely.",
+  },
+]
+
+export interface SafetyOptions {
+  blockDestructiveGit?: boolean
+  allowForcePush?: boolean
+  allowStashDrop?: boolean
+  customPatterns?: { name: string; pattern: string; reason: string }[]
+  [key: string]: unknown
+}
+
+export function resolvePatterns(options: SafetyOptions = {}): DangerousPattern[] {
+  let list = [...DANGEROUS_GIT_PATTERNS]
+
+  if (options.allowForcePush === true) {
+    list = list.filter((p) => p.name !== "force-push")
+  }
+
+  if (options.allowStashDrop === true) {
+    list = list.filter((p) => p.name !== "stash-destroy")
+  }
+
+  if (Array.isArray(options.customPatterns)) {
+    for (const c of options.customPatterns) {
+      if (typeof c.name === "string" && typeof c.pattern === "string") {
+        try {
+          list.push({
+            name: c.name,
+            pattern: new RegExp(c.pattern),
+            reason: typeof c.reason === "string" ? c.reason : "Blocked by custom safety policy.",
+          })
+        } catch (e) {
+          console.warn(`[overclock] safety: invalid custom pattern "${c.name}": ${e}`)
+        }
+      }
+    }
+  }
+
+  return list
+}
+
+export function checkDangerousCommand(
+  command: string,
+  patterns: DangerousPattern[],
+): DangerousPattern | null {
+  for (const p of patterns) {
+    if (p.pattern.test(command)) {
+      return p
+    }
+  }
+  return null
+}
+
+export const safety: FeatureModule = {
+  name: "safety",
+  tools: [],
+  defaultEnabled: true,
+  async init(ctx, options, shared) {
+    const opts = (options ?? {}) as SafetyOptions
+    if (opts.blockDestructiveGit === false) {
+      return {}
+    }
+
+    const patterns = resolvePatterns(opts)
+    const bashToolName = shared?.toolName ? shared.toolName("bash").toLowerCase() : "bash"
+
+    return {
+      "tool.execute.before": async (input, output) => {
+        const toolLower = input.tool.toLowerCase()
+        if (toolLower !== "bash" && toolLower !== bashToolName) return
+
+        const args = output.args as Record<string, unknown> | undefined
+        if (!args || typeof args.command !== "string") return
+
+        const matched = checkDangerousCommand(args.command, patterns)
+        if (!matched) return
+
+        const blockedMessage = `[overclock safety] Blocked destructive git command (${matched.name}): ${matched.reason}\nCommand requested: ${args.command}\nAction: To prevent accidental code loss, destructive git actions are blocked by overclock safety policy. Use safe alternatives like 'git stash push', 'git revert', or selective file restore.`
+
+        // Rewrite command to exit with error rather than crashing the execution fiber
+        // Use shellQuote to ensure no shell expansion/substitution occurs on the blocked command
+        output.args.command = `printf '%s\\n' ${shellQuote(blockedMessage)} >&2 && exit 1`
+
+        void toast(ctx.client, `safety: blocked ${matched.name}`, "warning")
+      },
+    }
+  },
+}

package/src/features/sched.ts

@@ -1,7 +1,9 @@
 import { tool } from "@opencode-ai/plugin"
 import { Cron } from "croner"
-import type { FeatureModule } from "../types.ts"
+import type { FeatureModule, SchedOptions } from "../types.ts"
+import type { BusyTracker } from "../core/types.ts"
 import { ensureStateDir, readJson, writeJson } from "../lib/state.ts"
+import { scheduleStore, type ScheduleEntry } from "../lib/mirror.ts"
 import { inject, toast } from "../lib/inject.ts"
 
 const z = tool.schema
@@ -9,103 +11,202 @@ const z = tool.schema
 export type Spec = { kind: "interval"; ms: number } | { kind: "cron"; expr: string }
 
 const UNITS: Record<string, number> = { s: 1000, m: 60_000, h: 3_600_000, d: 86_400_000 }
+export const MIN_INTERVAL_MS = 5000
+export const MAX_SCHEDULES = 50
+export const MAX_CONSECUTIVE_FAILURES = 5
 
-/** "30s" | "5m" | "2h" | "1d" -> interval; else cron expr (validated). Throws on garbage. */
+/** "30s" | "5m" | "2h" | "1d" -> interval; else cron expr (validated). Throws on garbage or frequency < 5s. */
 export function parseSpec(spec: string): Spec {
   const m = spec.trim().match(/^(\d+)([smhd])$/)
-  if (m) return { kind: "interval", ms: Number(m[1]) * UNITS[m[2]!]! }
-  new Cron(spec) // throws if invalid
+  if (m) {
+    const ms = Number(m[1]) * UNITS[m[2]!]!
+    if (ms < MIN_INTERVAL_MS) {
+      throw new Error(`Schedule interval must be at least 5s (got ${spec})`)
+    }
+    return { kind: "interval", ms }
+  }
+  const cron = new Cron(spec) // throws if invalid
+  const runs = cron.nextRuns(2)
+  if (runs.length >= 2 && runs[1]!.getTime() - runs[0]!.getTime() < MIN_INTERVAL_MS) {
+    throw new Error(`Schedule frequency must be at least 5s (got ${spec})`)
+  }
   return { kind: "cron", expr: spec }
 }
 
-interface Schedule {
-  id: string
-  spec: string
-  prompt: string
-  target: "current" | "new-session"
-  sessionID: string // creator; inject target when target=current
-  createdAt: string
+export type Schedule = ScheduleEntry
+
+export interface ScheduleManager {
+  readonly schedules: Map<string, ScheduleEntry>
+  create(input: {
+    spec: string
+    prompt: string
+    target: "current" | "new-session"
+    sessionID: string
+  }): Promise<{ schedule: ScheduleEntry; next: string }>
+  list(): Array<{ schedule: ScheduleEntry; next: string }>
+  delete(id: string): Promise<boolean>
+  arm(s: ScheduleEntry): void
+  disarm(id: string): void
+  fire(s: ScheduleEntry): Promise<void>
+  nextRun(s: ScheduleEntry): string
+  dispose(): void
+}
+
+export interface ScheduleManagerDeps {
+  storePath: string
+  client: any
+  busy?: BusyTracker
+  skipIfBusy?: boolean
 }
 
 /**
- * Scheduled runs: cron exprs or plain intervals ("5m"). interval + current session = /loop.
- * Persisted, rearmed on startup.
+ * Encapsulated schedule manager handling timer registration, persistence,
+ * and dispatching prompt injections.
  */
-export const sched: FeatureModule = {
-  name: "sched",
-  tools: ["schedule_create", "schedule_list", "schedule_delete"],
-  options: { skipIfBusy: "boolean" },
-  defaultEnabled: true,
-  requires: ["session.promptAsync", "session.messages", "session.create"],
-  async init(ctx, options, shared) {
-    const dir = await ensureStateDir(ctx.directory)
-    const storePath = `${dir}/schedules.json`
-    const schedules = new Map<string, Schedule>()
-    const timers = new Map<string, Cron | ReturnType<typeof setInterval>>()
-    const skipIfBusy = options.skipIfBusy !== false
-
-    const persist = () => writeJson(storePath, [...schedules.values()])
-
-    async function fire(s: Schedule) {
-      try {
-        if (s.target === "current") {
-          // target still chewing on previous turn -> skip this fire, no pileup
-          if (skipIfBusy && shared.busy.isBusy(s.sessionID)) {
-            await toast(ctx.client, `schedule ${s.id} skipped (session busy)`, "info")
+export async function createScheduleManager(deps: ScheduleManagerDeps): Promise<ScheduleManager> {
+  const schedules = new Map<string, ScheduleEntry>()
+  const timers = new Map<string, { stop(): void }>()
+  const consecutiveFailures = new Map<string, number>()
+  const skipIfBusy = deps.skipIfBusy !== false
+
+  const persist = async () => writeJson(deps.storePath, [...schedules.values()])
+
+  async function remove(id: string): Promise<boolean> {
+    if (!schedules.delete(id)) return false
+    disarm(id)
+    consecutiveFailures.delete(id)
+    await persist()
+    return true
+  }
+
+  async function fire(s: ScheduleEntry) {
+    try {
+      if (s.target === "current") {
+        if (skipIfBusy && deps.busy?.isBusy(s.sessionID)) {
+          await toast(deps.client, `schedule ${s.id} skipped (session busy)`, "info")
+          return
+        }
+        const ok = await inject(deps.client, s.sessionID, `[schedule ${s.id} fired]\n${s.prompt}`)
+        if (!ok) {
+          const fails = (consecutiveFailures.get(s.id) ?? 0) + 1
+          consecutiveFailures.set(s.id, fails)
+          if (fails >= MAX_CONSECUTIVE_FAILURES) {
+            console.warn(
+              `[overclock] schedule ${s.id}: target session ${s.sessionID} unreachable ${fails} times, auto-removing`,
+            )
+            await toast(deps.client, `schedule ${s.id}: session unreachable, auto-removed`, "warning")
+            await remove(s.id)
             return
           }
-          const ok = await inject(ctx.client, s.sessionID, `[schedule ${s.id} fired]\n${s.prompt}`)
-          if (!ok) await toast(ctx.client, `schedule ${s.id}: target session gone`, "warning")
+          await toast(deps.client, `schedule ${s.id}: target session gone`, "warning")
         } else {
-          const res = await ctx.client.session.create({ body: { title: `sched:${s.id}` } })
-          const id = res.data?.id
-          if (!id) throw new Error("session.create returned no id")
-          await inject(ctx.client, id, s.prompt)
-          await toast(ctx.client, `schedule ${s.id} fired -> new session`, "info")
+          consecutiveFailures.delete(s.id)
         }
-      } catch (e) {
-        console.warn(`[overclock] schedule ${s.id} fire failed: ${e}`)
-        await toast(ctx.client, `schedule ${s.id} failed: ${e}`, "error")
+      } else {
+        const res = await deps.client.session.create({ body: { title: `sched:${s.id}` } })
+        const id = res.data?.id
+        if (!id) throw new Error("session.create returned no id")
+        await inject(deps.client, id, s.prompt)
+        await toast(deps.client, `schedule ${s.id} fired -> new session`, "info")
       }
+    } catch (e) {
+      console.warn(`[overclock] schedule ${s.id} fire failed: ${e}`)
+      await toast(deps.client, `schedule ${s.id} failed: ${e}`, "error")
     }
+  }
 
-    function arm(s: Schedule) {
-      const spec = parseSpec(s.spec)
-      timers.set(
-        s.id,
-        spec.kind === "interval"
-          ? setInterval(() => fire(s), spec.ms)
-          : new Cron(spec.expr, () => fire(s)),
-      )
-    }
+  function arm(s: ScheduleEntry) {
+    const spec = parseSpec(s.spec)
+    const timer =
+      spec.kind === "interval"
+        ? {
+            stop: clearInterval.bind(
+              null,
+              setInterval(() => fire(s), spec.ms),
+            ),
+          }
+        : new Cron(spec.expr, () => fire(s))
+    timers.set(s.id, timer)
+  }
 
-    function disarm(id: string) {
-      const t = timers.get(id)
-      if (!t) return
-      t instanceof Cron ? t.stop() : clearInterval(t)
-      timers.delete(id)
-    }
+  function disarm(id: string) {
+    timers.get(id)?.stop()
+    timers.delete(id)
+  }
 
-    const nextRun = (s: Schedule): string => {
-      const spec = parseSpec(s.spec)
-      if (spec.kind === "cron") return new Cron(spec.expr).nextRun()?.toISOString() ?? "never"
-      return `every ${s.spec}`
+  function nextRun(s: ScheduleEntry): string {
+    const spec = parseSpec(s.spec)
+    if (spec.kind === "cron") return new Cron(spec.expr).nextRun()?.toISOString() ?? "never"
+    return `every ${s.spec}`
+  }
+
+  const stored = await readJson<ScheduleEntry[]>(deps.storePath, [])
+  for (const s of stored) {
+    schedules.set(s.id, s)
+    try {
+      arm(s)
+    } catch (e) {
+      console.warn(`[overclock] rearm ${s.id} failed: ${e}`)
     }
+  }
 
-    // rearm persisted schedules (restart-safe)
-    for (const s of await readJson<Schedule[]>(storePath, [])) {
-      schedules.set(s.id, s)
-      try {
-        arm(s)
-      } catch (e) {
-        console.warn(`[overclock] rearm ${s.id} failed: ${e}`)
+  return {
+    schedules,
+    arm,
+    disarm,
+    fire,
+    nextRun,
+    async create(input) {
+      if (schedules.size >= MAX_SCHEDULES) {
+        throw new Error(`Maximum schedules limit reached (${MAX_SCHEDULES})`)
       }
-    }
+      parseSpec(input.spec)
+      const s: ScheduleEntry = {
+        id: `s-${crypto.randomUUID().slice(0, 6)}`,
+        spec: input.spec,
+        prompt: input.prompt,
+        target: input.target,
+        sessionID: input.sessionID,
+        createdAt: new Date().toISOString(),
+      }
+      schedules.set(s.id, s)
+      arm(s)
+      await persist()
+      return { schedule: s, next: nextRun(s) }
+    },
+    list() {
+      return [...schedules.values()].map((s) => ({ schedule: s, next: nextRun(s) }))
+    },
+    delete: remove,
+    dispose() {
+      for (const id of [...timers.keys()]) disarm(id)
+    },
+  }
+}
+
+/**
+ * Scheduled runs: cron exprs or plain intervals ("5m"). interval + current session = /loop.
+ * Persisted, rearmed on startup.
+ */
+export const sched: FeatureModule = {
+  name: "sched",
+  tools: ["schedule_create", "schedule_list", "schedule_delete"],
+  defaultEnabled: true,
+  requires: ["session.promptAsync", "session.messages", "session.create"],
+  async init(ctx, rawOptions, shared) {
+    const options = (rawOptions ?? {}) as SchedOptions
+    await ensureStateDir(ctx.directory)
+    const storePath = scheduleStore.path(ctx.directory)
+
+    const manager = await createScheduleManager({
+      storePath,
+      client: ctx.client,
+      busy: shared.busy,
+      skipIfBusy: options.skipIfBusy !== false,
+    })
 
     return {
-      dispose: async () => {
-        for (const id of [...timers.keys()]) disarm(id)
-      },
+      dispose: async () => manager.dispose(),
       tool: {
         schedule_create: tool({
           description:
@@ -116,31 +217,25 @@ export const sched: FeatureModule = {
             target: z.enum(["current", "new-session"]).default("current"),
           },
           async execute(args, tctx) {
-            parseSpec(args.spec) // validate before storing
-            const s: Schedule = {
-              id: `s-${crypto.randomUUID().slice(0, 6)}`,
+            const { schedule, next } = await manager.create({
               spec: args.spec,
               prompt: args.prompt,
               target: args.target,
               sessionID: tctx.sessionID,
-              createdAt: new Date().toISOString(),
-            }
-            schedules.set(s.id, s)
-            arm(s)
-            await persist()
-            return `created ${s.id}: ${args.spec} -> ${args.target} (next: ${nextRun(s)})`
+            })
+            return `created ${schedule.id}: ${args.spec} -> ${args.target} (next: ${next})`
           },
         }),
         schedule_list: tool({
           description: "List schedules.",
           args: {},
           async execute() {
-            const all = [...schedules.values()]
+            const all = manager.list()
             if (!all.length) return "no schedules"
             return all
               .map(
-                (s) =>
-                  `${s.id} [${s.spec}] -> ${s.target} (next: ${nextRun(s)}) :: ${s.prompt.slice(0, 60)}`,
+                ({ schedule: s, next }) =>
+                  `${s.id} [${s.spec}] -> ${s.target} (next: ${next}) :: ${s.prompt.slice(0, 60)}`,
               )
               .join("\n")
           },
@@ -149,9 +244,8 @@ export const sched: FeatureModule = {
           description: "Delete a schedule by id.",
           args: { id: z.string() },
           async execute(args) {
-            if (!schedules.delete(args.id)) return `no schedule ${args.id}`
-            disarm(args.id)
-            await persist()
+            const ok = await manager.delete(args.id)
+            if (!ok) return `no schedule ${args.id}`
             return `deleted ${args.id}`
           },
         }),