@springbrand/agent-runtime 0.3.0-alpha.4 → 0.3.0-alpha.5

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@springbrand/agent-runtime",
-  "version": "0.3.0-alpha.4",
+  "version": "0.3.0-alpha.5",
   "type": "module",
   "files": [
     "src",

package/src/adapter/cloudflare/agent.ts

@@ -33,8 +33,10 @@ import {
   type SubmissionReceipt,
   type SubmissionExecutionMode,
   type SubmissionHandle,
+  type RuntimeUnattendedExecutionGrant,
 } from "../../submission";
 import type { ExecutionLevel } from "../../lib/execution-level";
+import { pinnedUnattendedExecutionGrant } from "../../submission/unattended";
 import {
   HarnessRuntimeConfig,
   activateRuntimeCandidate,
@@ -98,6 +100,10 @@ import { RuntimeDatabase } from "./database";
 // #region Runtime 内部数据与基础工具
 
 const SCHEDULED_STABLE_TIMEOUT_MS = 30_000;
+/** 定时 Run 未结束时拒绝普通输入的统一原因,服务端与客户端状态共用同一事实。 */
+const SCHEDULED_INPUT_LOCKED_MESSAGE =
+  "This scheduled run is still in progress. Wait for it to finish before sending a message.";
+
 interface ActiveTurn {
   submissionId: string;
   requestId: string;
@@ -390,7 +396,7 @@ export abstract class AgentRuntimeKernel<
     }
     await this.broadcastApprovals();
     const running = this.db.submissions.findRunning() as StoredSubmission | null;
-    if (running) {
+    if (running && !running.unattendedFailure) {
       if (
         this.db.approvals.listPendingForSubmission(running.submissionId).length > 0 ||
         this.db.interactions.listPendingForSubmission(running.submissionId).length > 0
@@ -785,6 +791,8 @@ export abstract class AgentRuntimeKernel<
         submissionId,
         requestId: submission.requestId,
         executionLevel: activeRuntime.snapshot.profile.executionLevel,
+        origin: submission.origin,
+        unattendedExecutionGrant: submission.unattendedExecutionGrant,
       },
       candidates: harnessInput.candidates,
       telemetry: this.telemetry,
@@ -812,6 +820,12 @@ export abstract class AgentRuntimeKernel<
         }
       },
       gateTool: harnessInput.platform.gateTool,
+      authorizeUnattendedExecution:
+        harnessInput.platform.authorizeUnattendedExecution,
+      onUnattendedFailure: (reason) => {
+        this.db.submissions.recordUnattendedFailure(submissionId, reason);
+      },
+      unattendedFailure: () => this.db.submissions.find(submissionId)?.unattendedFailure,
     });
     runtime = await openSessionHarness({
       session: openCloudflareSession(this.ctx.storage),
@@ -824,6 +838,7 @@ export abstract class AgentRuntimeKernel<
         workspace: harnessInput.workspace,
         authorize: gate.authorize.bind(gate),
         resolveReplay: gate.resolveReplay.bind(gate),
+        resolveConfirmation: gate.resolveConfirmation.bind(gate),
       }),
       modelToolResultExemptions: harnessInput.candidates
         .filter(({ outputBudget }) => outputBudget?.kind === "structure")
@@ -838,12 +853,13 @@ export abstract class AgentRuntimeKernel<
     try {
       runtime.harness.hooks.on("before_tool", gate.beforeTool);
       runtime.harness.hooks.on("before_drive", async (event, context) => {
-        if (this.db.submissions.find(submissionId)?.abortReason) {
+        const current = this.db.submissions.find(submissionId);
+        if (current?.abortReason || current?.unattendedFailure) {
           await runtime.requestAbort(event.runId, context);
         }
       });
 
-      if (submission.abortReason && runtime.openOperation) {
+      if ((submission.abortReason || submission.unattendedFailure) && runtime.openOperation) {
         await runtime.requestAbort(
           runtime.openOperation.operationId,
           BACKGROUND_CONTEXT,
@@ -860,11 +876,15 @@ export abstract class AgentRuntimeKernel<
       );
       if (preparation.kind === "settled") {
         const record = preparation.outcome;
+        const unattendedFailure = this.db.submissions.find(submissionId)
+          ?.unattendedFailure;
         const terminal = await this.submissions.finish(
           submission,
-          record.status === "completed" || record.status === "declined"
+          unattendedFailure
+            ? "failed"
+            : record.status === "completed" || record.status === "declined"
             ? "succeeded" : record.status === "aborted" ? "aborted" : "failed",
-          record.error?.message,
+          unattendedFailure ?? record.error?.message,
         );
         this.broadcast(json({
           type: MessageType.CF_AGENT_CHAT_MESSAGES,
@@ -989,7 +1009,11 @@ export abstract class AgentRuntimeKernel<
         return this.db.submissions.find(submissionId)!;
       }
       const record = outcome.outcome;
-      const status = record.status === "completed" || record.status === "declined"
+      const unattendedFailure = this.db.submissions.find(submissionId)
+        ?.unattendedFailure;
+      const status = unattendedFailure
+        ? "failed"
+        : record.status === "completed" || record.status === "declined"
         ? "succeeded"
         : record.status === "aborted"
           ? "aborted"
@@ -998,7 +1022,7 @@ export abstract class AgentRuntimeKernel<
       const terminal = await this.submissions.finish(
         submission,
         status,
-        record.error?.message,
+        unattendedFailure ?? record.error?.message,
       );
       const projectedOutcome = projectSubmissionOutcome(record, terminal);
       await stream.flushTerminal(projectedOutcome);
@@ -1323,11 +1347,41 @@ export abstract class AgentRuntimeKernel<
     this.transcript.importSnapshot(snapshot);
   }
 
+  /**
+   * 本 Session 是否有一条未结束的定时 Submission。
+   *
+   * 定时 Run 未结束时独占输入:普通消息在准入前被拒绝,不排队等它结束。
+   * 定时注入本身走 `submitScheduledPrompt`,不经过这道闸。
+   */
+  private get scheduledInputLocked(): boolean {
+    return this.db.submissions.hasUnfinishedScheduled();
+  }
+
+  private rejectedOrdinaryInputReceipt(): SubmissionReceipt {
+    return {
+      submissionId: crypto.randomUUID(),
+      status: "skipped",
+      accepted: false,
+      error: SCHEDULED_INPUT_LOCKED_MESSAGE,
+      retryable: false,
+      createdAt: Date.now(),
+    };
+  }
+
+  private rejectInputLocked(): MessageDispatchReceipt {
+    return {
+      kind: "rejected",
+      code: "input_locked",
+      message: SCHEDULED_INPUT_LOCKED_MESSAGE,
+    };
+  }
+
   /** Admit text and return immediately; completion continues in the Durable Object. */
   async submitPrompt(
     text: string,
     options?: { idempotencyKey?: string },
   ): Promise<SubmissionReceipt> {
+    if (this.scheduledInputLocked) return this.rejectedOrdinaryInputReceipt();
     const submitted = await this.submitMessage({
       role: "user",
       content: [{ type: "text", text }],
@@ -1357,17 +1411,22 @@ export abstract class AgentRuntimeKernel<
   }
 
   async dispatchMessage(message: UIMessage, delivery: MessageDelivery): Promise<MessageDispatchReceipt> {
+    if (this.scheduledInputLocked) return this.rejectInputLocked();
     return this.delivery.dispatch(message, delivery);
   }
 
   async steerQueuedSubmission(submissionId: string): Promise<MessageDispatchReceipt> {
+    if (this.scheduledInputLocked) return this.rejectInputLocked();
     return this.delivery.steerQueued(submissionId);
   }
 
   /** Admit scheduled work after a bounded stable wait, otherwise return skipped. */
   async submitScheduledPrompt(
     prompt: string,
-    options?: { idempotencyKey?: string },
+    options?: {
+      idempotencyKey?: string;
+      unattendedExecutionGrant?: RuntimeUnattendedExecutionGrant;
+    },
   ): Promise<SubmissionReceipt> {
     const requestId = crypto.randomUUID();
     const submitted = await this.submitMessageWhenStable(
@@ -1379,6 +1438,10 @@ export abstract class AgentRuntimeKernel<
       {
         requestId,
         idempotencyKey: options?.idempotencyKey,
+        origin: "scheduled",
+        unattendedExecutionGrant: options?.unattendedExecutionGrant
+          ? pinnedUnattendedExecutionGrant(options.unattendedExecutionGrant)
+          : undefined,
       },
       SCHEDULED_STABLE_TIMEOUT_MS,
     );
@@ -1463,7 +1526,7 @@ export abstract class AgentRuntimeKernel<
       summary: approval.summary,
       executionLevel: approval.executionLevel,
       requiredExecutionLevel: approval.requiredExecutionLevel,
-      inputJson: approval.inputJson,
+      inputJson: approval.confirmationJson ?? approval.inputJson,
       requestId: approval.requestId,
     };
   }
@@ -1573,6 +1636,7 @@ export abstract class AgentRuntimeKernel<
         hasPendingInteraction: (id) => this.humanDecisions.isWaitingForInteraction(id),
         hasPendingSteer: (id) => this.db.steers.listForSubmission(id).length > 0,
         hasRunningAgentTools: this.db.agentTools.hasRunning(),
+        hasUnfinishedScheduled: this.db.submissions.hasUnfinishedScheduled(),
         previousState: this.state,
       });
       if (changed) this.setState(state);

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

@@ -262,7 +262,10 @@ export interface RuntimeAgentControls {
    */
   submitScheduledPrompt(
     prompt: string,
-    opts?: { idempotencyKey?: string },
+    opts?: {
+      idempotencyKey?: string;
+      unattendedExecutionGrant?: import("../../submission").RuntimeUnattendedExecutionGrant;
+    },
   ): Promise<SubmissionReceipt>;
   /**
    * 按提交编号查询当前处理状态。

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,15 @@ 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("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 +165,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

package/src/config/assembler.ts

@@ -1,3 +1,4 @@
+import { schedulePiToolCandidates } from "../tools/schedule";
 import type { SkillSource } from "agents/skills";
 import type {
   RuntimeGatewayPort,
@@ -264,6 +265,16 @@ async function createToolSurface(
           if (!EXECUTION_LEVELS.includes(candidate.requiredExecutionLevel)) {
             throw new Error(`SpringBrand Tool ${name} execution level is invalid`);
           }
+          if (candidate.unattendedExecution) {
+            requiredName(
+              candidate.unattendedExecution.capability,
+              `SpringBrand Tool ${name} unattended capability`,
+            );
+            requiredName(
+              candidate.unattendedExecution.operation,
+              `SpringBrand Tool ${name} unattended operation`,
+            );
+          }
           if (tools.has(name)) {
             throw new Error(`Duplicate Runtime SpringBrand Tool: ${name}`);
           }
@@ -632,6 +643,7 @@ class RuntimeBuilder {
         : {}),
       hostTools: [
         ...this.hostTools,
+        ...(this.schedule ? schedulePiToolCandidates(this.schedule) : []),
         ...subagentPiToolCandidates(
           this.subagents,
           [...this.enabledSubagents],

package/src/config/pinning.ts

@@ -249,9 +249,20 @@ function describeTools(candidates: readonly PiToolCandidate[]) {
       description: candidate.tool.description ?? candidate.tool.label,
       parameters: candidate.tool.parameters,
       requiredExecutionLevel: candidate.requiredExecutionLevel,
+      ...(candidate.confirmation ? { confirmation: true } : {}),
       ...(candidate.alwaysRequiresApproval
         ? { alwaysRequiresApproval: true }
         : {}),
+      ...(candidate.unattendedExecution
+        ? {
+            unattendedExecution: {
+              capability: candidate.unattendedExecution.capability,
+              operation: candidate.unattendedExecution.operation,
+              objectConstrained:
+                candidate.unattendedExecution.objectForInput !== undefined,
+            },
+          }
+        : {}),
       ...(candidate.deferLoading ? { deferLoading: true } : {}),
       ...(candidate.source ? { source: candidate.source } : {}),
       retry: piToolRetryPolicy(candidate),