@springbrand/agent-runtime 0.3.0-alpha.2 → 0.3.0-alpha.20

package/src/adapter/cloudflare/define-agent.ts

@@ -17,7 +17,7 @@ import type { RuntimeState } from "../../conversation";
 import type {
   TemporaryAgentApprovalDecision,
   TemporaryAgentApprovalRequest,
-  TemporaryAgentLaunch,
+  TemporaryAgentLaunchSelection,
 } from "../../tools";
 import { TEMPORARY_AGENT_LAUNCH_KEY } from "../../tools";
 import {
@@ -83,7 +83,7 @@ export interface LoadedRuntime<Config> {
 export interface RuntimeConfigUpdate<Change> {
   readonly changed: boolean;
   readonly change: Change;
-  /** Restore any committed config state when the replacement Runtime cannot load. */
+  /** Restore committed state if an immediate replacement fails. */
   readonly rollback?: () => Promise<void>;
 }
 
@@ -96,11 +96,16 @@ interface RuntimeAgentDefinitionBase<
   /** 必须等于 Worker 导出名（Wrangler `class_name`）。 */
   readonly name: string;
 
-  /** Refresh Host-owned inputs before a new Submission is pinned. Never runs on continuation/recovery. */
+  /** Refresh Host-owned inputs before a new Submission records its Runtime key. */
   readonly beforeSubmission?: (
     context: RuntimeAgentPlanningContext<Env, Command, Change>,
   ) => Promise<boolean>;
 
+  /** Prepare per-Submission Host state after admission and before its first assembly pin. */
+  readonly afterSubmission?: (
+    context: RuntimeAgentPlanningContext<Env, Command, Change>,
+  ) => Promise<void>;
+
   readonly load: (
     context: RuntimeAgentPlanningContext<Env, Command, Change>,
     requestedRuntimeKey?: string,
@@ -114,7 +119,7 @@ interface RuntimeAgentDefinitionBase<
   /** Prepare the optional telemetry consumer for this concrete Agent facet. */
   readonly telemetry?: (
     context: RuntimeAgentPlanningContext<Env, Command, Change>,
-  ) => AgentTelemetryBinding | undefined;
+  ) => AgentTelemetryBinding | undefined | Promise<AgentTelemetryBinding | undefined>;
 }
 
 export interface ReadonlyRuntimeAgentDefinition<
@@ -262,7 +267,12 @@ export interface RuntimeAgentControls {
    */
   submitScheduledPrompt(
     prompt: string,
-    opts?: { idempotencyKey?: string },
+    opts?: {
+      idempotencyKey?: string;
+      scheduledMaxExecutionLevel?: import("../../lib/execution-level").ExecutionLevel;
+      /** @deprecated Retained for rolling upgrades; ignored by Runtime. */
+      unattendedExecutionGrant?: import("../../submission").RuntimeUnattendedExecutionGrant;
+    },
   ): Promise<SubmissionReceipt>;
   /**
    * 按提交编号查询当前处理状态。
@@ -355,9 +365,7 @@ const TERMINAL_AGENT_TOOL_STATUSES = [
 ] as const;
 const AGENT_TOOL_RETENTION_MS = 24 * 60 * 60 * 1_000;
 
-function parseTemporaryAgentLaunch<Config>(
-  input: unknown,
-): TemporaryAgentLaunch<Config> {
+function parseTemporaryAgentLaunch(input: unknown): TemporaryAgentLaunchSelection {
   const record = input != null && typeof input === "object"
     ? input as Record<string, unknown>
     : {};
@@ -375,17 +383,15 @@ function parseTemporaryAgentLaunch<Config>(
   ) {
     throw new Error("invalid temporary agent executionLevel");
   }
-  if (!("config" in record)) {
-    throw new Error("invalid temporary agent config");
-  }
-  return {
+  const selection: TemporaryAgentLaunchSelection = {
     subagentName: read("subagentName", 128),
     instructions: read("instructions", 65_536),
     task: read("task", 65_536),
     runtimeKey: read("runtimeKey", 512),
-    config: record.config as Config,
     executionLevel: executionLevel as ExecutionLevel,
   };
+  if ("config" in record) throw new Error("unexpected temporary agent config");
+  return selection;
 }
 
 /**
@@ -406,14 +412,14 @@ export function defineRuntimeAgent<
     | MutableRuntimeAgentDefinition<Env, Config, Command, Change>
     | ReadonlyRuntimeAgentDefinition<Env, Config>,
 ): RuntimeAgentClass<Env, Command, Change> {
-  const resolveDefinitionTelemetry = (
+  const resolveDefinitionTelemetry = async (
     context: RuntimeAgentPlanningContext<Env, Command, Change>,
-  ): AgentTelemetryBinding | undefined => {
+  ): Promise<AgentTelemetryBinding | undefined> => {
     const telemetry = definition.telemetry;
     if (!telemetry) return undefined;
-    return (telemetry as (
+    return await (telemetry as (
       context: RuntimeAgentPlanningContext<Env, Command, Change>,
-    ) => AgentTelemetryBinding | undefined)(context);
+    ) => AgentTelemetryBinding | undefined | Promise<AgentTelemetryBinding | undefined>)(context);
   };
 
   const GeneratedRuntimeAgent = {
@@ -423,7 +429,7 @@ export function defineRuntimeAgent<
       private loading?: Promise<void>;
       private telemetryResolved = false;
       private resolvedTelemetry?: AgentTelemetryBinding;
-      private temporaryLaunch?: TemporaryAgentLaunch<Config>;
+      private temporaryLaunch?: TemporaryAgentLaunchSelection;
       private temporaryDispose?: () => Promise<void>;
       private temporaryCleanup?: Promise<void>;
 
@@ -444,10 +450,10 @@ export function defineRuntimeAgent<
         return this.ensureConfig(runtimeKey);
       }
 
-      protected async prepareRuntimeForSubmission(submissionId: string): Promise<void> {
+      protected async prepareRuntimeForAdmission(): Promise<void> {
         const beforeSubmission = definition.beforeSubmission as RuntimeAgentDefinitionBase<Env, Config, Command, Change>["beforeSubmission"];
         try {
-          const changed = await beforeSubmission?.(this.createDefinitionContext(undefined, submissionId));
+          const changed = await beforeSubmission?.(this.createDefinitionContext());
           await this.ensureConfig(undefined, changed === true);
         } catch (error) {
           this.hasLoadedRuntime = false;
@@ -455,6 +461,17 @@ export function defineRuntimeAgent<
         }
       }
 
+      protected async prepareRuntimeForSubmission(submissionId: string): Promise<void> {
+        const afterSubmission = definition.afterSubmission as RuntimeAgentDefinitionBase<Env, Config, Command, Change>["afterSubmission"];
+        try {
+          await this.ensureRuntimeReady();
+          await afterSubmission?.(this.createDefinitionContext(undefined, submissionId));
+        } catch (error) {
+          this.hasLoadedRuntime = false;
+          throw error;
+        }
+      }
+
       // 作用：加载默认 Runtime，或切换到调用方指定的 key。
       // 调用：RPC 控制面在业务配置需要刷新时调用。
       // 原因：复用 `ensureConfig`，让手动重载遵守和首次启动相同的原子规则。
@@ -546,7 +563,7 @@ export function defineRuntimeAgent<
         if (this.role !== "temporary") {
           throw new Error("Agent Tool runs require a temporary child facet");
         }
-        const launch = parseTemporaryAgentLaunch<Config>(input);
+        const launch = parseTemporaryAgentLaunch(input);
         this.temporaryLaunch = launch;
         await this.ctx.storage.put(TEMPORARY_AGENT_LAUNCH_KEY, launch);
         await this.reloadRuntime(launch.runtimeKey, { force: true });
@@ -619,6 +636,11 @@ export function defineRuntimeAgent<
             if (!resolvedRuntimeKey) {
               throw new Error("Resolved Runtime key must not be empty");
             }
+            if (requestedRuntimeKey && resolvedRuntimeKey !== requestedRuntimeKey) {
+              throw new Error(
+                `Requested Runtime key ${requestedRuntimeKey} resolved to ${resolvedRuntimeKey}`,
+              );
+            }
             const context = this.createDefinitionContext({
               value: loaded.config,
             });
@@ -635,7 +657,7 @@ export function defineRuntimeAgent<
             let resources = loaded.resources;
             let commitGuard = loaded.commitGuard;
             if (!this.telemetryResolved) {
-              this.resolvedTelemetry = resolveDefinitionTelemetry(context);
+              this.resolvedTelemetry = await resolveDefinitionTelemetry(context);
               this.telemetryResolved = true;
             }
             const telemetry = this.resolvedTelemetry;
@@ -718,7 +740,7 @@ export function defineRuntimeAgent<
         resources: ResolvedResources,
       ): Promise<ResolvedResources> {
         const launch = this.temporaryLaunch ??
-          await this.ctx.storage.get<TemporaryAgentLaunch<Config>>(
+          await this.ctx.storage.get<TemporaryAgentLaunchSelection>(
             TEMPORARY_AGENT_LAUNCH_KEY,
           );
         if (!launch) throw new Error("Temporary Agent is not initialized");
@@ -749,7 +771,7 @@ export function defineRuntimeAgent<
       }
 
       private async requestParentTemporaryApproval(
-        launch: TemporaryAgentLaunch<Config>,
+        launch: TemporaryAgentLaunchSelection,
         request: {
           toolCallId: string;
           toolName: string;
@@ -815,7 +837,7 @@ export function defineRuntimeAgent<
         this.temporaryCleanup = (async () => {
           if (!this.temporaryDispose) {
             const launch = this.temporaryLaunch ??
-              await this.ctx.storage.get<TemporaryAgentLaunch<Config>>(
+              await this.ctx.storage.get<TemporaryAgentLaunchSelection>(
                 TEMPORARY_AGENT_LAUNCH_KEY,
               );
             if (launch) await this.ensureConfig(launch.runtimeKey);
@@ -885,7 +907,6 @@ export function defineRuntimeAgent<
                     input: {
                       ...normalized,
                       runtimeKey: agent.loadedRuntimeKey,
-                      config: runtimeConfig.value,
                       executionLevel: agent.executionLevel(),
                     },
                     runId: `temporary-agent:${runContext.toolCallId}`,

package/src/adapter/cloudflare/index.ts

@@ -23,8 +23,26 @@ export {
 export {
   isValidTimeZone,
   nextCronOccurrence,
+  wallTimeInstants,
   zoneOffsetMs,
 } from "./scheduling/zoned-cron";
+export {
+  DEFAULT_LATENESS_WINDOW_MS,
+  isWithinLatenessWindow,
+  nextScheduledOccurrence,
+  resolveScheduleOccurrences,
+  toScheduleRuleSpec,
+  validateScheduleRuleSpec,
+  type LocalScheduleTrigger,
+  type ScheduledOccurrence,
+  type ScheduleOccurrence,
+  type ScheduleOccurrenceResolution,
+  type ScheduleRuleError,
+  type ScheduleRuleErrorCode,
+  type ScheduleRuleSpec,
+  type ScheduleSkipReason,
+  type SkippedOccurrence,
+} from "./scheduling/schedule-rule";
 
 export {
   CloudflareSandboxAdapter,

package/src/adapter/cloudflare/scheduling/schedule-rule.ts

@@ -0,0 +1,322 @@
+import type {
+  LocalScheduleRule,
+  ScheduleSpec,
+} from "../../../submission/contracts";
+import { isValidTimeZone, wallTimeInstants, zoneOffsetMs } from "./zoned-cron";
+
+const DAY_MS = 86_400_000;
+const HOUR_MS = 3_600_000;
+const MINUTE_MS = 60_000;
+/** 扫描上限:每日/每周规则一定在 7 天内出现,这里只兜底防止坏输入空转。 */
+const MAX_SCAN_DAYS = 366 * 5;
+
+/**
+ * 宿主允许在计划时点之后多久仍可启动该轮次。宿主可覆盖,
+ * 通用模块只把它当作可参数化的迟到窗口,不承载套餐或任务策略。
+ */
+export const DEFAULT_LATENESS_WINDOW_MS = 5 * MINUTE_MS;
+
+export type ScheduleSkipReason = "dst_missing_local_time";
+
+/** 一个真实可执行的本地时间轮次。 */
+export interface ScheduledOccurrence {
+  kind: "scheduled";
+  /** 跨重算、重启都稳定的轮次身份,供宿主做幂等键。 */
+  occurrenceId: string;
+  /** 计划执行的 UTC 瞬时。 */
+  scheduledAt: number;
+  /** 任务时区下的本地日期 `YYYY-MM-DD`。 */
+  localDate: string;
+  /** 任务时区下的本地钟点 `HH:mm`。 */
+  localTime: string;
+  /** 含边界的最迟可启动瞬时 = `scheduledAt + latenessWindowMs`。 */
+  latestStartAt: number;
+}
+
+/** 因夏令时缺失钟点而被跳过的轮次;没有可执行瞬时,只留身份与原因。 */
+export interface SkippedOccurrence {
+  kind: "skipped";
+  occurrenceId: string;
+  localDate: string;
+  localTime: string;
+  reason: ScheduleSkipReason;
+}
+
+export type ScheduleOccurrence = ScheduledOccurrence | SkippedOccurrence;
+
+/** 一条按任务时区解释的当地时间规则及其生效窗口。 */
+export interface ScheduleRuleSpec {
+  rule: LocalScheduleRule;
+  /** IANA 时区名,如 `Asia/Shanghai`;绝不退化成固定 UTC offset。 */
+  timeZone: string;
+  /** 含当天的最早生效本地日期 `YYYY-MM-DD`。 */
+  startDate?: string;
+  /** 含当天的最后生效本地日期 `YYYY-MM-DD`。 */
+  endDate?: string;
+  /** 覆盖默认迟到窗口。 */
+  latenessWindowMs?: number;
+}
+
+/** `ScheduleSpec.trigger` 里 `local` 变体的形状。 */
+export type LocalScheduleTrigger = Extract<
+  ScheduleSpec["trigger"],
+  { kind: "local" }
+>;
+
+/**
+ * 把合同的 `local` 触发条件投影成时间规则计算规格。
+ *
+ * 宿主与路由共用同一映射,避免各自拼一份 `startDate`/`endDate`,改合同字段时漏改。
+ */
+export function toScheduleRuleSpec(
+  trigger: LocalScheduleTrigger,
+  timeZone: string,
+): ScheduleRuleSpec {
+  return {
+    rule: trigger.rule,
+    timeZone,
+    ...(trigger.startDate ? { startDate: trigger.startDate } : {}),
+    ...(trigger.endDate ? { endDate: trigger.endDate } : {}),
+  };
+}
+
+export type ScheduleRuleErrorCode =
+  | "invalid_rule"
+  | "invalid_time_zone"
+  | "invalid_date"
+  | "invalid_time"
+  | "empty_weekdays"
+  | "invalid_weekday"
+  | "invalid_window"
+  | "invalid_limit"
+  | "no_future_occurrence";
+
+export interface ScheduleRuleError {
+  code: ScheduleRuleErrorCode;
+  message: string;
+}
+
+export type ScheduleOccurrenceResolution =
+  | { ok: true; occurrences: ScheduleOccurrence[] }
+  | { ok: false; error: ScheduleRuleError };
+
+interface LocalClock {
+  hour: number;
+  minute: number;
+}
+
+/** 校验规则形状与时区,不判断是否存在未来时点。 */
+export function validateScheduleRuleSpec(
+  spec: ScheduleRuleSpec,
+): ScheduleRuleError | null {
+  if (typeof spec.timeZone !== "string" || !isValidTimeZone(spec.timeZone)) {
+    return { code: "invalid_time_zone", message: `未知时区:${spec.timeZone}` };
+  }
+  const rule = spec.rule as unknown;
+  if (!isRecord(rule) ||
+    (rule.kind !== "once" && rule.kind !== "daily" && rule.kind !== "weekly")) {
+    return { code: "invalid_rule", message: "不支持的当地时间规则" };
+  }
+  const time = typeof rule.time === "string" ? parseTime(rule.time) : null;
+  if (!time) {
+    return { code: "invalid_time", message: `非法钟点:${String(rule.time ?? "")}` };
+  }
+  if (rule.kind === "once" &&
+    (typeof rule.date !== "string" || parseDate(rule.date) === null)) {
+    return { code: "invalid_date", message: `非法日期:${String(rule.date ?? "")}` };
+  }
+  if (rule.kind === "weekly") {
+    if (!Array.isArray(rule.weekdays) || rule.weekdays.length === 0) {
+      if (Array.isArray(rule.weekdays)) {
+        return { code: "empty_weekdays", message: "每周规则至少需要一个星期" };
+      }
+      return { code: "invalid_weekday", message: "星期必须是数字数组" };
+    }
+    if (
+      rule.weekdays.some(
+        (weekday) => !Number.isInteger(weekday) || weekday < 0 || weekday > 6,
+      )
+    ) {
+      return {
+        code: "invalid_weekday",
+        message: `非法星期:${rule.weekdays.join(",")}`,
+      };
+    }
+  }
+  const start = optionalDate(spec.startDate);
+  if (spec.startDate !== undefined && start === null) {
+    return { code: "invalid_date", message: `非法开始日期:${spec.startDate}` };
+  }
+  const end = optionalDate(spec.endDate);
+  if (spec.endDate !== undefined && end === null) {
+    return { code: "invalid_date", message: `非法结束日期:${spec.endDate}` };
+  }
+  if (start !== null && end !== null && end < start) {
+    return { code: "invalid_window", message: "结束日期不能早于开始日期" };
+  }
+  return null;
+}
+
+/**
+ * 从 `after`(UTC 瞬时,不含)起枚举轮次,含被跳过的缺失钟点。
+ *
+ * 预览、下一轮计算和恢复枚举都走这里,保证三者语义一致;输出为空时返回可识别的
+ * `no_future_occurrence`,而不是伪造一个执行时间。
+ */
+export function resolveScheduleOccurrences(
+  spec: ScheduleRuleSpec,
+  options: { after: number; limit: number },
+): ScheduleOccurrenceResolution {
+  const error = validateScheduleRuleSpec(spec);
+  if (error) return { ok: false, error };
+  if (!Number.isSafeInteger(options.limit) || options.limit <= 0) {
+    return {
+      ok: false,
+      error: { code: "invalid_limit", message: "轮次数量必须是正整数" },
+    };
+  }
+  const occurrences = enumerate(spec, options.after, options.limit);
+  if (occurrences.length === 0) {
+    return {
+      ok: false,
+      error: {
+        code: "no_future_occurrence",
+        message: "该规则在给定时间之后没有有效执行时点",
+      },
+    };
+  }
+  return { ok: true, occurrences };
+}
+
+/** 下一个可执行瞬时;缺失钟点被跳过,不伪造、不顺延补跑。 */
+export function nextScheduledOccurrence(
+  spec: ScheduleRuleSpec,
+  after: number,
+): ScheduledOccurrence | null {
+  if (validateScheduleRuleSpec(spec) !== null) return null;
+  for (let limit = 1; limit <= 512; limit *= 2) {
+    const occurrences = enumerate(spec, after, limit);
+    const scheduled = occurrences.find(
+      (occurrence): occurrence is ScheduledOccurrence =>
+        occurrence.kind === "scheduled",
+    );
+    if (scheduled) return scheduled;
+    if (occurrences.length < limit) return null;
+  }
+  return null;
+}
+
+/** 含边界判断某个已计划轮次是否仍在迟到窗口内。 */
+export function isWithinLatenessWindow(
+  occurrence: ScheduledOccurrence,
+  now: number,
+): boolean {
+  return now >= occurrence.scheduledAt && now <= occurrence.latestStartAt;
+}
+
+function enumerate(
+  spec: ScheduleRuleSpec,
+  after: number,
+  limit: number,
+): ScheduleOccurrence[] {
+  const time = parseTime(spec.rule.time);
+  if (!time) return [];
+  const windowMs = spec.latenessWindowMs ?? DEFAULT_LATENESS_WINDOW_MS;
+  const wallAfter = after + zoneOffsetMs(after, spec.timeZone);
+  const dayOfAfter = Math.floor(wallAfter / DAY_MS) * DAY_MS;
+  const startDay = optionalDate(spec.startDate) ?? dayOfAfter;
+  const endDay = optionalDate(spec.endDate);
+  const occurrences: ScheduleOccurrence[] = [];
+
+  const onceDay = spec.rule.kind === "once" ? parseDate(spec.rule.date) : null;
+  // 一次性规则直接跳到目标日期，不能让重复规则的扫描保险上限拒绝远期任务。
+  let day = Math.max(startDay, dayOfAfter, onceDay ?? Number.NEGATIVE_INFINITY);
+  const maxScanDays = onceDay === null ? MAX_SCAN_DAYS : 0;
+  for (let scanned = 0; scanned <= maxScanDays; scanned += 1, day += DAY_MS) {
+    if (endDay !== null && day > endDay) break;
+    if (!matchesRule(spec.rule, day)) continue;
+
+    const wall = day + time.hour * HOUR_MS + time.minute * MINUTE_MS;
+    const localDate = formatDate(day);
+    const localTime = formatTime(time);
+    const occurrenceId = `${localDate}T${localTime}`;
+    const instants = wallTimeInstants(wall, spec.timeZone);
+    if (instants.length === 0) {
+      // 拨快抹掉的钟点:没有可执行瞬时,只在游标之后才作为跳过轮次报告。
+      if (wall <= wallAfter) continue;
+      occurrences.push({
+        kind: "skipped",
+        occurrenceId,
+        localDate,
+        localTime,
+        reason: "dst_missing_local_time",
+      });
+    } else {
+      const scheduledAt = instants[0];
+      if (scheduledAt <= after) continue;
+      occurrences.push({
+        kind: "scheduled",
+        occurrenceId,
+        scheduledAt,
+        localDate,
+        localTime,
+        latestStartAt: scheduledAt + windowMs,
+      });
+    }
+    if (occurrences.length >= limit) break;
+  }
+  return occurrences;
+}
+
+function matchesRule(rule: LocalScheduleRule, day: number): boolean {
+  switch (rule.kind) {
+    case "once":
+      return day === parseDate(rule.date);
+    case "daily":
+      return true;
+    case "weekly":
+      return rule.weekdays.includes(new Date(day).getUTCDay());
+  }
+}
+
+function parseTime(value: string): LocalClock | null {
+  const match = /^([01]\d|2[0-3]):([0-5]\d)$/.exec(value);
+  if (!match) return null;
+  return { hour: Number(match[1]), minute: Number(match[2]) };
+}
+
+function formatTime({ hour, minute }: LocalClock): string {
+  return `${String(hour).padStart(2, "0")}:${String(minute).padStart(2, "0")}`;
+}
+
+/** `YYYY-MM-DD` → UTC 零点毫秒;非法日历日期返回 null。 */
+function parseDate(value: string): number | null {
+  const match = /^(\d{4})-(\d{2})-(\d{2})$/.exec(value);
+  if (!match) return null;
+  const year = Number(match[1]);
+  const month = Number(match[2]);
+  const day = Number(match[3]);
+  const ms = Date.UTC(year, month - 1, day);
+  const date = new Date(ms);
+  if (
+    date.getUTCFullYear() !== year ||
+    date.getUTCMonth() !== month - 1 ||
+    date.getUTCDate() !== day
+  ) {
+    return null;
+  }
+  return ms;
+}
+
+function optionalDate(value: string | undefined): number | null {
+  if (value === undefined) return null;
+  return parseDate(value);
+}
+
+function formatDate(day: number): string {
+  return new Date(day).toISOString().slice(0, 10);
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}

package/src/adapter/cloudflare/scheduling/zoned-cron.ts

@@ -55,7 +55,8 @@ export function nextCronOccurrence(
         for (const second of parsed.seconds) {
           const wall = day + hour * 3_600_000 + minute * 60_000 + second * 1_000;
           if (wall <= wallAfter) continue;
-          const resolved = wallTimeCandidates(wall, timeZone, after)[0];
+          const resolved = wallTimeInstants(wall, timeZone)
+            .find((instant) => instant > after);
           if (resolved !== undefined) return resolved;
         }
       }
@@ -73,18 +74,22 @@ export function isValidTimeZone(timeZone: string): boolean {
   }
 }
 
-function wallTimeCandidates(wallUtc: number, timeZone: string, after: number): number[] {
+/**
+ * 所有本地墙上时间恰好等于 `wallUtc` 的 UTC 瞬时,升序。
+ *
+ * `wallUtc` 是"把本地钟点当作 UTC"的伪瞬时(见 {@link zoneOffsetMs})。
+ * 返回空数组 = 该钟点在当地被夏令时拨快抹掉;返回两个 = 拨慢导致同一钟点出现两次。
+ * 这是 `nextCronOccurrence` 与本地规则计算共用的唯一钟点解析边界。
+ */
+export function wallTimeInstants(wallUtc: number, timeZone: string): number[] {
   const offsets = new Set([
-    zoneOffsetMs(after, timeZone),
     zoneOffsetMs(wallUtc - 2 * 86_400_000, timeZone),
     zoneOffsetMs(wallUtc, timeZone),
     zoneOffsetMs(wallUtc + 2 * 86_400_000, timeZone),
   ]);
   return [...offsets]
     .map((offset) => wallUtc - offset)
-    .filter((instant) =>
-      instant > after && instant + zoneOffsetMs(instant, timeZone) === wallUtc
-    )
+    .filter((instant) => instant + zoneOffsetMs(instant, timeZone) === wallUtc)
     .sort((left, right) => left - right);
 }
 

package/src/adapter/cloudflare/schema.ts

@@ -51,6 +51,18 @@ export function initializeSchema(sql: SqlTaggedTemplate): void {
   if (!submissionColumns.has("regenerate_message_id")) {
     sql`ALTER TABLE pi_submissions ADD COLUMN regenerate_message_id TEXT`;
   }
+  if (!submissionColumns.has("origin")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN origin TEXT NOT NULL DEFAULT 'user'`;
+  }
+  if (!submissionColumns.has("scheduled_max_execution_level")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN scheduled_max_execution_level TEXT`;
+  }
+  if (!submissionColumns.has("unattended_execution_grant_json")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN unattended_execution_grant_json TEXT`;
+  }
+  if (!submissionColumns.has("unattended_failure")) {
+    sql`ALTER TABLE pi_submissions ADD COLUMN unattended_failure TEXT`;
+  }
   sql`CREATE UNIQUE INDEX IF NOT EXISTS pi_submissions_one_running
       ON pi_submissions(status)
       WHERE status = 'running'`;
@@ -156,6 +168,9 @@ export function initializeSchema(sql: SqlTaggedTemplate): void {
         .map((column) => column.name),
     );
   let columns = approvalColumns();
+  if (!columns.has("confirmation_json")) {
+    sql`ALTER TABLE pi_approvals ADD COLUMN confirmation_json TEXT`;
+  }
   if (!columns.has("execution_level")) {
     // 旧 Session 没有持久化当时的授权档位，safe 失败关闭；只影响旧 pending 回执展示，不会静默放行。
     sql`ALTER TABLE pi_approvals