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

package/plugins/scheduler/node_modules/zod/v4/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/plugins/scheduler/node_modules/zod/v4-mini/index.cjs

@@ -0,0 +1,32 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.z = void 0;
+const z = __importStar(require("../v4/mini/external.cjs"));
+exports.z = z;
+__exportStar(require("../v4/mini/external.cjs"), exports);

package/plugins/scheduler/node_modules/zod/v4-mini/index.d.cts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.cjs";
+export * from "../v4/mini/external.cjs";
+export { z };

package/plugins/scheduler/node_modules/zod/v4-mini/index.d.ts

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };

package/plugins/scheduler/node_modules/zod/v4-mini/index.js

@@ -0,0 +1,3 @@
+import * as z from "../v4/mini/external.js";
+export * from "../v4/mini/external.js";
+export { z };

package/plugins/scheduler/node_modules/zod/v4-mini/package.json

@@ -0,0 +1,7 @@
+{ 
+  "type": "module",
+  "main": "./index.cjs",
+  "module": "./index.js",
+  "types": "./index.d.cts",
+  "sideEffects": false
+}

package/plugins/scheduler/package-lock.json

@@ -0,0 +1,77 @@
+{
+  "name": "@dimcode/scheduler",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "@dimcode/scheduler",
+      "version": "0.1.0",
+      "dependencies": {
+        "@arcships/rutis": "0.19.3",
+        "cron-parser": "5.10.2",
+        "zod": "4.4.3"
+      },
+      "devDependencies": {
+        "@types/node": "24.10.0"
+      }
+    },
+    "node_modules/@arcships/rutis": {
+      "version": "0.19.3",
+      "resolved": "https://registry.npmjs.org/@arcships/rutis/-/rutis-0.19.3.tgz",
+      "integrity": "sha512-mpeVQ2tIZFyiKibgmRtyEhFu0NW3xam/OMUWSkddXIj8a/QqyW3AiE37GKlb4ihpHtuRx1dIz9HyCYHgvnecJw==",
+      "license": "MIT",
+      "engines": {
+        "bun": ">=1.4",
+        "node": ">=22"
+      }
+    },
+    "node_modules/@types/node": {
+      "version": "24.10.0",
+      "resolved": "https://registry.npmjs.org/@types/node/-/node-24.10.0.tgz",
+      "integrity": "sha512-qzQZRBqkFsYyaSWXuEHc2WR9c0a0CXwiE5FWUvn7ZM+vdy1uZLfCunD38UzhuB7YN/J11ndbDBcTmOdxJo9Q7A==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "undici-types": "~7.16.0"
+      }
+    },
+    "node_modules/cron-parser": {
+      "version": "5.10.2",
+      "resolved": "https://registry.npmjs.org/cron-parser/-/cron-parser-5.10.2.tgz",
+      "integrity": "sha512-JfAYMY0LZaWQTuict8PhtF/ksSnq8xefSDmQUnnoqvkPYkU/y3UP0DTWzJKFBz0P1IXsDG8q0vY3zHkoFZOhvw==",
+      "license": "MIT",
+      "dependencies": {
+        "luxon": "^3.7.2"
+      },
+      "engines": {
+        "node": ">=18"
+      }
+    },
+    "node_modules/luxon": {
+      "version": "3.7.2",
+      "resolved": "https://registry.npmjs.org/luxon/-/luxon-3.7.2.tgz",
+      "integrity": "sha512-vtEhXh/gNjI9Yg1u4jX/0YVPMvxzHuGgCm6tC5kZyb08yjGWGnqAjGJvcXbqQR2P3MyMEFnRbpcdFS6PBcLqew==",
+      "license": "MIT",
+      "engines": {
+        "node": ">=12"
+      }
+    },
+    "node_modules/undici-types": {
+      "version": "7.16.0",
+      "resolved": "https://registry.npmjs.org/undici-types/-/undici-types-7.16.0.tgz",
+      "integrity": "sha512-Zz+aZWSj8LE6zoxD+xrjh4VfkIG8Ya6LvYkZqtUQGJPZjYl53ypCaUwWqo7eI0x66KBGeRo+mlBEkMSeSZ38Nw==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/zod": {
+      "version": "4.4.3",
+      "resolved": "https://registry.npmjs.org/zod/-/zod-4.4.3.tgz",
+      "integrity": "sha512-ytENFjIJFl2UwYglde2jchW2Hwm4GJFLDiSXWdTrJQBIN9Fcyp7n4DhxJEiWNAJMV1/BqWfW/kkg71UDcHJyTQ==",
+      "license": "MIT",
+      "funding": {
+        "url": "https://github.com/sponsors/colinhacks"
+      }
+    }
+  }
+}

package/plugins/scheduler/package.json

@@ -0,0 +1,13 @@
+{
+  "name": "@dimcode/scheduler",
+  "private": true,
+  "version": "0.1.0",
+  "type": "module",
+  "exports": "./index.ts",
+  "dependencies": {
+    "@arcships/rutis": "0.19.3",
+    "cron-parser": "5.10.2",
+    "zod": "4.4.3"
+  },
+  "devDependencies": { "@types/node": "24.10.0" }
+}

package/plugins/scheduler/requests.ts

@@ -0,0 +1,37 @@
+import { z } from 'zod'
+import type { JsonObject } from '../../../npm/plugin.js'
+import { id, managementJob, patchSchema, type Caller } from './data.ts'
+
+export const unloadingBeforeCall = 'tool provider generation is unloading; this call was not made. The tool is offered again once its provider is active; a later request uses the current provider.'
+export const unloadingAfterCall = "tool provider generation is unloading; this call may already have taken effect. Check the operation's state before repeating it with the current provider."
+
+export function bounded(text: string, limit: number): string {
+  const bytes = Buffer.from(text)
+  if (bytes.length <= limit) return text
+  let end = limit
+  while ((bytes[end] & 0xc0) === 0x80) end--
+  return bytes.subarray(0, end).toString('utf8')
+}
+
+const history = { job_id: id, limit: z.number().int().min(1).max(50).default(20) }
+export const toolRequest = z.discriminatedUnion('action', [
+  z.strictObject({ action: z.literal('list') }),
+  z.strictObject({ action: z.literal('get'), job_id: id }),
+  z.strictObject({ action: z.literal('create'), job: patchSchema }),
+  z.strictObject({ action: z.literal('update'), job_id: id, job: patchSchema }),
+  z.strictObject({ action: z.literal('delete'), job_id: id }),
+  z.strictObject({ action: z.literal('set_enabled'), job_id: id, enabled: z.boolean() }),
+  z.strictObject({ action: z.literal('run_now'), job_id: id }),
+  z.strictObject({ action: z.literal('history'), ...history }),
+])
+export const management = {
+  list: z.strictObject({}),
+  save: z.strictObject({ job: managementJob, revision: z.number().int().min(0).optional() }),
+  delete: z.strictObject({ job_id: id }),
+  set_enabled: z.strictObject({ job_id: id, enabled: z.boolean() }),
+  run_now: z.strictObject({ job_id: id }),
+  history: z.strictObject(history),
+}
+export type JobRequest = z.infer<typeof toolRequest> & { caller: Caller }
+export type JobReply = { content: string; records: JsonObject } | { code: string; message: string }
+export interface ScheduleJobs { call(request: JobRequest): Promise<JobReply> }

package/plugins/scheduler/session.ts

@@ -0,0 +1,59 @@
+import { definePlugin } from '@arcships/rutis'
+import { z } from 'zod'
+import type { GuideEntries, JsonSchema, ToolRegistry } from '../../../npm/plugin.js'
+import { patchSchema } from './data.ts'
+import { bounded, toolRequest, unloadingBeforeCall, unloadingAfterCall, type JobReply, type ScheduleJobs } from './requests.ts'
+
+const jobSchema = z.toJSONSchema(patchSchema) as JsonSchema
+jobSchema.properties!.schedule.type = 'object'
+
+// The dim-scheduler entry (Scheduler §5.2): both kinds it writes, verbatim.
+const ENTRY = '<dim-scheduler kind="scheduled-run" job="nightly-build" run="run-7f2">: a scheduled job\'s saved prompt, delivered when the job runs, and <dim-scheduler kind="report" job="nightly-build" run="run-7f2">: how that run ended. job names the job, run names the run, in both. In the scheduled-run tag the body is the job\'s name, and the message after the tag is the prompt saved for the job: the request this run carries out, in the operator\'s channel. In the report tag the body states the run\'s outcome and, when known, the session it ran in: the scheduler\'s account of how the run ended, information, not a request. The report\'s last line is not part of that account: it is guidance on what to do next.'
+
+/// The `schedule` declaration's description in force when the factory
+/// configuration sets none.
+const DESCRIPTION = 'Manage scheduled jobs across this host, including other workspaces. Every create/update, even a rename, replaces the saving branch and authority cap; future reports go to this branch. An omitted policy keeps its stored value, whose default can change with the saving origin. Inspect the old-to-new authority transition in the result.'
+
+export default (description: string = DESCRIPTION) => definePlugin({
+  name: 'SchedulerSession', inject: ['scheduleJobs', 'toolRegistry', 'guideEntries'],
+  provides: {},
+  async apply(ctx) {
+    const owner = ctx.use<ScheduleJobs>('scheduleJobs')
+    let closing = false
+    ctx.effect(() => { closing = true })
+    await ctx.use<GuideEntries>('guideEntries').register('session', { markers: ['dim-scheduler'], order: 110, text: ENTRY })
+    await ctx.use<ToolRegistry>('toolRegistry').register(
+      { name: 'schedule', source: 'extension', risk: 'persistent_configuration',
+        description,
+        inputSchema: { type: 'object', required: ['action'], additionalProperties: false, properties: {
+          action: { type: 'string', enum: ['list', 'get', 'create', 'update', 'delete', 'set_enabled', 'run_now', 'history'] },
+          job_id: { type: 'string' }, enabled: { type: 'boolean' }, limit: { type: 'integer', minimum: 1, maximum: 50 },
+          job: jobSchema,
+        } },
+      },
+      async (call, cancellation) => {
+        if (closing) return { content: unloadingBeforeCall, isError: true }
+        if (call.config.interactive === false || call.config.collaborationRole === 'member') {
+          return { content: 'schedule is available only in interactive leader Sessions.', isError: true }
+        }
+        const request = toolRequest.safeParse(call.arguments)
+        if (!request.success) return { content: `schedule: schedule_invalid\n${bounded(request.error.message, 4 * 1024)}`, isError: true }
+        let cancelled = false
+        void cancellation.then(() => { cancelled = true }, () => { cancelled = true })
+        await Promise.resolve()
+        if (closing) return { content: unloadingBeforeCall, isError: true }
+        if (cancelled) return { content: 'schedule: cancelled before handover', isError: true }
+        let reply: JobReply
+        try {
+          reply = await owner.call({ ...request.data, caller: { sessionId: call.sessionId, branchId: call.branchId, cwd: call.config.cwd } })
+        } catch (error) {
+          if (closing) return { content: unloadingAfterCall, isError: true }
+          throw error
+        }
+        if (closing) return { content: unloadingAfterCall, isError: true }
+        return 'code' in reply ? { content: `schedule: ${reply.code}\n${reply.message}`, isError: true }
+          : { content: reply.content, structuredContent: reply.records }
+      },
+    )
+  },
+})

package/plugins/scheduler/settings.ts

@@ -0,0 +1,275 @@
+import type { SourceDeclaration } from '../../../npm/plugin.js'
+
+export const settings: SourceDeclaration = {
+  "source": "schedule",
+  "userFile": "schedule.json",
+  "userOnly": [
+    "/max_concurrent_runs"
+  ],
+  "schema": {
+    "$schema": "https://json-schema.org/draft/2020-12/schema",
+    "type": "object",
+    "properties": {
+      "jobs": {
+        "default": [],
+        "type": "array",
+        "items": {
+          "type": "object",
+          "properties": {
+            "name": {
+              "type": "string",
+              "minLength": 1
+            },
+            "schedule": {
+              "anyOf": [
+                {
+                  "type": "object",
+                  "properties": {
+                    "every_minutes": {
+                      "type": "integer",
+                      "minimum": 1,
+                      "maximum": 9007199254740991
+                    }
+                  },
+                  "required": [
+                    "every_minutes"
+                  ],
+                  "additionalProperties": false
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "at": {
+                      "type": "string",
+                      "format": "date-time",
+                      "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d(?::[0-5]\\d(?:\\.\\d+)?)?(?:Z|([+-](?:[01]\\d|2[0-3]):[0-5]\\d)))$"
+                    }
+                  },
+                  "required": [
+                    "at"
+                  ],
+                  "additionalProperties": false
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "cron": {
+                      "type": "string",
+                      "pattern": "^[0-9*/,-]+ +[0-9*/,-]+ +[0-9*/,-]+ +[0-9*/,-]+ +[0-9*/,-]+$"
+                    },
+                    "tz": {
+                      "type": "string",
+                      "minLength": 1
+                    }
+                  },
+                  "required": [
+                    "cron"
+                  ],
+                  "additionalProperties": false
+                }
+              ]
+            },
+            "prompt": {
+              "type": "string",
+              "maxLength": 32768
+            },
+            "cwd": {
+              "type": "string",
+              "minLength": 1
+            },
+            "model": {
+              "type": "object",
+              "properties": {
+                "providerId": {
+                  "type": "string",
+                  "minLength": 1
+                },
+                "modelId": {
+                  "type": "string",
+                  "minLength": 1
+                }
+              },
+              "required": [
+                "providerId",
+                "modelId"
+              ],
+              "additionalProperties": false
+            },
+            "mode": {
+              "type": "string",
+              "enum": [
+                "create",
+                "reuse"
+              ]
+            },
+            "policy": {
+              "type": "string",
+              "enum": [
+                "read-only",
+                "workspace-write",
+                "full-access"
+              ]
+            },
+            "max_run_minutes": {
+              "default": 60,
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 9007199254740991
+            },
+            "id": {
+              "type": "string",
+              "minLength": 1
+            },
+            "agent_id": {
+              "type": "string",
+              "minLength": 1
+            },
+            "session_id": {
+              "type": "string",
+              "minLength": 1
+            },
+            "policy_cap": {
+              "type": "object",
+              "properties": {
+                "preset": {
+                  "type": "string",
+                  "enum": [
+                    "read-only",
+                    "workspace-write",
+                    "full-access"
+                  ]
+                },
+                "fileAccess": {
+                  "type": "string",
+                  "enum": ["read-only", "workspace-read-write", "unrestricted"]
+                },
+                "toolApproval": {
+                  "type": "string",
+                  "enum": ["ask", "bypass"]
+                },
+                "allowedTools": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                },
+                "disallowedTools": {
+                  "type": "array",
+                  "items": {
+                    "type": "string"
+                  }
+                }
+              },
+              "required": [
+                "preset",
+                "allowedTools",
+                "disallowedTools"
+              ],
+              "additionalProperties": false
+            },
+            "created_by": {
+              "anyOf": [
+                {
+                  "type": "string",
+                  "const": "user"
+                },
+                {
+                  "type": "object",
+                  "properties": {
+                    "tool": {
+                      "type": "object",
+                      "properties": {
+                        "session_id": {
+                          "type": "string",
+                          "minLength": 1
+                        },
+                        "branch_id": {
+                          "type": "string",
+                          "minLength": 1
+                        }
+                      },
+                      "required": [
+                        "session_id",
+                        "branch_id"
+                      ],
+                      "additionalProperties": false
+                    }
+                  },
+                  "required": [
+                    "tool"
+                  ],
+                  "additionalProperties": false
+                }
+              ]
+            },
+            "enabled": {
+              "type": "boolean"
+            },
+            "enabled_at": {
+              "type": "string",
+              "maxLength": 24,
+              "format": "date-time",
+              "pattern": "^(?:(?:\\d\\d[2468][048]|\\d\\d[13579][26]|\\d\\d0[48]|[02468][048]00|[13579][26]00)-02-29|\\d{4}-(?:(?:0[13578]|1[02])-(?:0[1-9]|[12]\\d|3[01])|(?:0[469]|11)-(?:0[1-9]|[12]\\d|30)|(?:02)-(?:0[1-9]|1\\d|2[0-8])))T(?:(?:[01]\\d|2[0-3]):[0-5]\\d:[0-5]\\d\\.\\d{3}(?:Z))$"
+            },
+            "revision": {
+              "type": "integer",
+              "minimum": 1,
+              "maximum": 9007199254740991
+            }
+          },
+          "required": [
+            "name",
+            "schedule",
+            "prompt",
+            "cwd",
+            "mode",
+            "max_run_minutes",
+            "id",
+            "policy_cap",
+            "created_by",
+            "enabled",
+            "revision"
+          ],
+          "additionalProperties": false,
+          "allOf": [
+            {
+              "if": {
+                "properties": {
+                  "enabled": {
+                    "const": true
+                  }
+                },
+                "required": [
+                  "enabled"
+                ]
+              },
+              "then": {
+                "required": [
+                  "enabled_at"
+                ]
+              },
+              "else": {
+                "not": {
+                  "required": [
+                    "enabled_at"
+                  ]
+                }
+              }
+            }
+          ]
+        }
+      },
+      "max_concurrent_runs": {
+        "default": 4,
+        "type": "integer",
+        "minimum": 1,
+        "maximum": 9007199254740991
+      }
+    },
+    "required": [
+      "jobs",
+      "max_concurrent_runs"
+    ],
+    "additionalProperties": false
+  }
+}

package/plugins/scheduler/store.ts

@@ -0,0 +1,67 @@
+import { z } from 'zod'
+import type { FileScope } from '../../../npm/plugin.js'
+import { address, id, policy, ScheduleError, timestamp } from './data.ts'
+
+const runSchema = z.strictObject({
+  run_id: id, job_id: id, window: z.union([z.literal('manual'), timestamp]),
+  state: z.enum(['skipped', 'missed', 'launching', 'submitted', 'running', 'completed', 'failed', 'cancelled', 'timed_out', 'lost']),
+  deadline_at: timestamp.optional(), session_id: id.optional(), session_origin: z.enum(['launch', 'reuse']).optional(),
+  policy: policy.optional(), input_event_id: id.optional(), submission_id: id, report_to: address.optional(),
+  created_at: timestamp, ended_at: timestamp.optional(), detail: z.string(),
+}).superRefine((run, context) => {
+  const sessionFields = [run.session_id, run.session_origin, run.policy].filter(value => value !== undefined).length
+  const accepted = run.state !== 'skipped' && run.state !== 'missed'
+  if (terminal(run) !== (run.ended_at !== undefined)
+    || (accepted && !run.deadline_at)
+    || (run.state === 'missed' && run.deadline_at !== undefined)
+    || (sessionFields !== 0 && sessionFields !== 3)
+    || (['submitted', 'running', 'completed', 'cancelled'].includes(run.state) && (!run.input_event_id || sessionFields !== 3))
+    || (run.state === 'launching' && run.input_event_id !== undefined)
+    || (run.state === 'missed' && (sessionFields !== 0 || run.input_event_id !== undefined || run.report_to !== undefined))
+    || (run.state === 'skipped' && (run.input_event_id !== undefined || (!run.deadline_at && (sessionFields !== 0 || run.report_to !== undefined))))
+    || (run.input_event_id !== undefined && sessionFields !== 3)
+    || run.submission_id !== `scheduler:${run.run_id}`) {
+    context.addIssue({ code: 'custom', message: 'Inconsistent Scheduler run record' })
+  }
+})
+const storedSchema = z.strictObject({ version: z.literal(1), runs: z.array(runSchema) }).superRefine((stored, context) => {
+  if (new Set(stored.runs.map(run => run.run_id)).size !== stored.runs.length) {
+    context.addIssue({ code: 'custom', message: 'Duplicate Scheduler run identity' })
+  }
+})
+export type Run = z.infer<typeof runSchema>
+export function terminal(run: { state: string }): boolean { return !['launching', 'submitted', 'running'].includes(run.state) }
+
+/** One decoder for the committed inner-v1 file; native transactions own serialization. */
+export class RunStore {
+  readonly scope: FileScope
+  constructor(scope: FileScope) { this.scope = scope }
+  async read(): Promise<Run[]> { return this.access(runs => runs, false) }
+  async update<T>(change: (runs: Run[]) => T): Promise<T> { return this.access(change, true) }
+
+  private async access<T>(change: (runs: Run[]) => T, write: boolean): Promise<T> {
+    let value!: T
+    let problem: unknown
+    const outcome = await this.scope.withLock('scheduler/runs.json', async file => {
+      try {
+        const text = await file.read()
+        if (!text.ok) throw new ScheduleError(text.error)
+        let runs: Run[]
+        if (text.value === null) runs = []
+        else {
+          try { runs = storedSchema.parse(JSON.parse(text.value)).runs }
+          catch { throw new ScheduleError('invalid_data') }
+        }
+        value = change(runs)
+        if (write) {
+          const replaced = await file.replace(JSON.stringify({ version: 1, runs }))
+          if (!replaced.ok) throw new ScheduleError(replaced.error)
+        }
+      } catch (error) { problem = error }
+      return null
+    })
+    if (!outcome.ok) throw new ScheduleError(outcome.error)
+    if (problem !== undefined) throw problem
+    return value
+  }
+}

package/plugins/scheduler/windows.ts

@@ -0,0 +1,36 @@
+import { CronExpressionParser } from 'cron-parser'
+import type { Job } from './data.ts'
+
+/** Derive windows from the enabled anchor and durable run history, never a timer counter. */
+export function windowAfter(job: Job, after: number): number | undefined {
+  const schedule = job.schedule
+  if ('at' in schedule) {
+    const instant = Date.parse(schedule.at)
+    return instant > after ? instant : undefined
+  }
+  const anchor = Date.parse(job.enabled_at!)
+  if ('every_minutes' in schedule) {
+    const period = schedule.every_minutes * 60_000
+    return anchor + Math.max(0, Math.floor((after - anchor) / period) + 1) * period
+  }
+  const iterator = CronExpressionParser.parse(schedule.cron, { currentDate: Math.max(after, anchor - 1), tz: schedule.tz })
+  for (;;) {
+    const next = iterator.next()
+    if (iterator.includesDate(next)) return next.getTime()
+  }
+}
+
+export function latestWindow(job: Job, now: number): number {
+  const schedule = job.schedule
+  if ('at' in schedule) return Date.parse(schedule.at)
+  if ('every_minutes' in schedule) {
+    const anchor = Date.parse(job.enabled_at!)
+    const period = schedule.every_minutes * 60_000
+    return anchor + Math.floor((now - anchor) / period) * period
+  }
+  const iterator = CronExpressionParser.parse(schedule.cron, { currentDate: now + 1, tz: schedule.tz })
+  for (;;) {
+    const previous = iterator.prev()
+    if (iterator.includesDate(previous)) return previous.getTime()
+  }
+}