@springbrand/agent-runtime 0.2.0-alpha.71 → 0.3.0-alpha.1

package/src/runtime.ts

@@ -1,4760 +0,0 @@
-import { summarizeModelUsage } from "./model-usage";
-import type {
-  AgentToolLifecycleResult,
-  AgentToolRunInfo,
-  Connection,
-} from "agents";
-import {
-  ChatStreamStalledError,
-  MessageType,
-  clearChatTerminal,
-  parseProtocolMessage,
-  recordChatTerminal,
-  sendIfOpen,
-  type ChatRecoveryConfig,
-} from "agents/chat";
-import { RecoverableChatAgent } from "./kernel/recoverable-chat-agent";
-import {
-  ApprovalLifecycle,
-  type ApprovalContinuationData,
-} from "./kernel/approval-lifecycle";
-import { InteractionLifecycle } from "./kernel/interaction-lifecycle";
-import {
-  SubmissionLifecycle,
-  MAX_PENDING_SUBMISSIONS,
-  SubmissionQueueFullError,
-  type SubmissionExecutionMode,
-  type SubmissionInput,
-  type SubmissionStore,
-  type SubmissionHandle,
-} from "./kernel/submission-lifecycle";
-import {
-  USER_STOP_REASON,
-  type ApprovalDecision,
-  type ApprovalReceipt,
-  type MessageDelivery,
-  type MessageDispatchReceipt,
-  type SubmissionReceipt,
-} from "./kernel/receipts";
-import type { ExecutionLevel } from "./lib/execution-level";
-import type {
-  RuntimeGatewaySession,
-  RuntimeSubmissionAdmissionHook,
-  RuntimeTurnEventsPort,
-} from "./kernel/bindings";
-import type { RuntimeAssemblyView } from "./kernel/runtime-assembly-view";
-import { projectRuntimeAssembly } from "./kernel/runtime-assembly";
-import type {
-  RuntimeExtensionPermissions,
-} from "./kernel/extensions";
-import type {
-  RuntimeActivity,
-  RuntimeState,
-  RuntimeTurnState,
-} from "./kernel/state";
-import {
-  RuntimeLoadTracker,
-  withRuntimeLoadTimeout,
-} from "./kernel/runtime-load";
-import {
-  prepareRuntimeCandidate,
-  type RuntimeAssemblyInput,
-  type RuntimeCandidate,
-  type RuntimeSnapshot,
-} from "./runtime-assembler";
-import {
-  RuntimeTelemetryCoordinator,
-} from "./telemetry";
-import { connectConfiguredMcpServers } from "./lib/mcp";
-import {
-  ContextOverflowError,
-  PiRuntimeAdapter,
-  MODEL_STREAM_STALL_TIMEOUT_MS,
-  readModelStreamStallDetails,
-  RetryableModelError,
-  RetryableModelSessionError,
-  type PiCanonicalUserInput,
-  type PiCanonicalTranscriptSnapshot,
-  type PiChatRecoveryData,
-  type UIChatRequestBody,
-  type RequestedCapability,
-  type PiDurableMutation,
-  type PiRecoveryCommand,
-  type PiRecoveryDecision,
-  type PiRuntimeTranscript,
-  type PiToolInputRecord,
-  type PiStoredToolSettlement,
-  type PiToolSettlement,
-  type PreparedPiRuntime,
-  type PreparedPiTurnAdapter,
-} from "./pi/runtime-adapter";
-import type { UIMessage, UIMessageChunk } from "ai";
-import type {
-  AssistantMessage,
-  ToolResultMessage,
-} from "@earendil-works/pi-ai";
-import { serializeOutput } from "./lib/artifacts";
-import type {
-  RuntimeModelUsageEvent,
-  RuntimeToolSettlementEvent,
-  RuntimeLifecycleFact,
-  RuntimeSubagentUsageEvent,
-} from "./kernel/bindings";
-import { RuntimeSubagentLifecycleRecorder } from "./kernel/durable-lifecycle";
-import {
-  decodeSubagentCompletion,
-  isZeroSubagentUsage,
-  runtimeSubagentRunMetadata,
-  subagentTerminalStatus,
-  type RuntimeSubagentRunMetadata,
-} from "./kernel/subagent-runtime";
-import {
-  isTerminalSubmissionStatus,
-  RuntimeDatabase,
-  type StoredSubmissionAdmission,
-  type SubmissionRecoveryReason,
-  type SubmissionStatus,
-} from "./db/index";
-import {
-  TemporaryAgentCoordinator,
-  type TemporaryAgentApprovalDecision,
-  type TemporaryAgentApprovalRequest,
-  type TemporaryAgentExecutor,
-  type TemporaryAgentRequest,
-  type TemporaryAgentRunContext,
-} from "./layers/orchestration/temporary-agent/core";
-
-/**
- * 本文件负责把 Cloudflare Agent 的通信与持久化能力接到 Pi Turn。
- *
- * @remarks
- * 核心术语见包入口 `index.ts`。
- */
-
-// #region Runtime 内部数据与基础工具
-
-const SCHEDULED_STABLE_TIMEOUT_MS = 30_000;
-const TURN_EVENT_RETRY_SECONDS = 10;
-const RUNTIME_EVENT_MAX_ATTEMPTS = 5;
-const MODEL_SESSION_ID_STORAGE_KEY = "universal-agent:model-session-id";
-
-// 计划续跑丢失多久后由看门狗接手。必须显著长于一个正常执行片的时长，
-// 否则会在健康的长执行片上误判并派发出重复的一片。
-const CONTINUATION_WATCHDOG_SECONDS = 300;
-// 一次 Host admission 调用最多被视为「在途」多久。停在 pending 的准入行永久保留
-// —— 它固定了同一 identity 重投时必须复用的 runId,不能靠删行来让容量回收 ——
-// 但一次远端失败或崩溃留下的行超过这个窗口后就不再占用 pending 容量,否则
-// Host 侧的一次抖动会把 Session 永久卡在「队列已满」。
-const ADMISSION_ATTEMPT_WINDOW_MS = 60_000;
-export const CHAT_RECOVERY_MAX_ATTEMPTS = 5;
-const SERVER_TOOL_TIMEOUT_MAX_ATTEMPTS = 2;
-// stall 单独收窄。理由不是「stall 更不值得救」,而是它的重试**期望值和别的错不一样**:
-// 瞬时错(5xx / 断流)重跑一次往往就好了;stall 的重跑是拿同一份 transcript 让模型
-// 重新想同样久,如果它本来就超预算,再跑几次也一样超。把看门狗放宽到 240s 之后,
-// 真该救的那一类已经在第一次就跑完了,剩下还在 stall 的基本是连接真死——
-// 那种情况下 5 次 × 240s ≈ 20 分钟的空转纯属折磨用户。3 次约 12 分钟封顶。
-export const CHAT_STALL_MAX_ATTEMPTS = 3;
-const CHAT_RECOVERY_TERMINAL_MESSAGE =
-  "Recovery failed after multiple attempts. This generation has stopped and your progress has been saved. Send a new message to continue.";
-const CONTEXT_OVERFLOW_TERMINAL_MESSAGE =
-  "The model context is still too large after forced compaction. Start a new conversation or reduce the attached context.";
-
-type RuntimeEventOutboxPayload =
-  | { readonly type: "model-usage"; readonly event: RuntimeModelUsageEvent }
-  | {
-      readonly type: "tool-settlement";
-      readonly event: RuntimeToolSettlementEvent;
-    }
-  | { readonly type: "subagent-usage"; readonly event: RuntimeSubagentUsageEvent }
-  | { readonly type: "lifecycle"; readonly event: RuntimeLifecycleFact };
-interface StoredSubmission extends SubmissionReceipt {
-  status: SubmissionStatus;
-  requestId: string;
-  idempotencyKey?: string;
-  assemblyRevision: string;
-  assemblyDescriptor: string;
-  assistantMessageId: string;
-  abortReason?: string;
-  queuedInputJson?: string | null;
-  queuedUiMessageJson?: string | null;
-  userMessageId?: string | null;
-  regenerateMessageId?: string | null;
-  recoveryErrorCount: number;
-  recoveryReason?: SubmissionRecoveryReason;
-  runId: string | null;
-  /** 跨执行片累计的模型回合数，全局回合预算据此判断。 */
-  modelTurns: number;
-  /** 当前让步执行片的标识；没有未完成让步时为 null。 */
-  continuationId: string | null;
-}
-
-interface SubmitMessageOptions {
-  requestId: string;
-  idempotencyKey?: string;
-  userMessageId?: string;
-  userMessage?: UIMessage & { role: "user" };
-  regenerate?: boolean;
-}
-
-interface ActiveTurn {
-  submissionId: string;
-  requestId: string;
-  messageId: string;
-  startedAt: number;
-  continuation: boolean;
-  /** Execution adapter — use abort()/steer() instead of touching Pi directly. */
-  agent: PreparedPiTurnAdapter;
-}
-
-interface ActiveRuntime {
-  readonly snapshot: RuntimeSnapshot;
-  readonly revision: string;
-  readonly pi: PreparedPiRuntime;
-  readonly gatewaySession?: RuntimeGatewaySession;
-  readonly admission?: RuntimeSubmissionAdmissionHook;
-}
-
-interface PlannedContinuationData {
-  readonly submissionId: string;
-  readonly requestId: string;
-  /** Identifies the yielded execution slice so retries dedupe without swallowing the next slice. */
-  readonly continuationId: string;
-}
-
-/**
- * 说明一次恢复准备的结局。
- *
- * @remarks
- * `prepareRecoveredTurn` 返回它，`executeNonTerminalSubmission` 据此决定重起 Turn、
- * 保持停靠还是落终态。
- *
- * `parked` 与 `unresumable` 必须分开：前者有人（审批、客户端交互）或有已排的调度会来解开它，
- * 后者没有任何东西会再唤醒 —— 把两者混成一个「不继续」，非终态记录就会永久停在 running。
- */
-type RecoveredTurnPreparation =
-  /** Transcript 完好，可以重起 Pi Turn。 */
-  | { readonly kind: "resume" }
-  /** 正在等人或等已排的续跑；保持非终态是正确的。 */
-  | { readonly kind: "parked" }
-  /** 准备过程自己已经写好了终态。 */
-  | { readonly kind: "settled" }
-  /** 续不下去，调用方必须落一条用户看得见的失败终态。 */
-  | { readonly kind: "unresumable"; readonly reason: string };
-
-// 作用：为一个没人会来解开的 `wait` 生成用户能看懂的终态原因。
-// 调用：`prepareRecoveredTurn` 判定 wait 不是 approval/interaction 时调用。
-// 原因：终态文本会直接呈现给用户，必须说明发生了什么以及能不能重试。
-function unresumableWaitMessage(reason: string | undefined): string {
-  return reason === "uncertain-tool"
-    ? "SpringBrand stopped this turn: a non-idempotent Tool was interrupted and its result cannot be confirmed, so it was not retried. Check whether the external action already happened before sending another request."
-    : "SpringBrand could not resume this turn after an interruption.";
-}
-
-// 作用：把任意异常整理成可以持久化或发给客户端的文字。
-// 调用：Turn 执行、恢复和业务投影捕获 `unknown` 异常时调用。
-// 原因：错误边界不能假定抛出值一定是 `Error`。
-function errorText(error: unknown): string {
-  return error instanceof Error ? error.message : String(error);
-}
-
-// 作用：用同一种 JSON 序列化方式生成持久化或传输文本。
-// 调用：本文件写里程碑、WebSocket 帧和比较投影时调用。
-// 原因：收口序列化入口，避免同一数据在不同路径产生不同文本。
-function json(value: unknown): string {
-  return JSON.stringify(value);
-}
-
-function validateAdmissionResult(
-  result: import("./kernel/bindings").RuntimeSubmissionAdmissionResult,
-): import("./kernel/bindings").RuntimeSubmissionAdmissionResult {
-  if (!result || typeof result !== "object" || typeof result.accepted !== "boolean") {
-    throw new Error("Runtime admission result is invalid");
-  }
-  if (!result.accepted) {
-    if (
-      typeof result.code !== "string" || !result.code.trim() ||
-      (result.retryable !== undefined && typeof result.retryable !== "boolean")
-    ) {
-      throw new Error("Runtime admission rejection is invalid");
-    }
-    return result;
-  }
-  return result;
-}
-
-async function closeRuntimeGatewaySession(
-  session: RuntimeGatewaySession | undefined,
-  step: string,
-): Promise<void> {
-  if (!session) return;
-  await withRuntimeLoadTimeout(step, () => session.close()).catch(
-    () => undefined,
-  );
-}
-
-function assistantUsageEvent(
-  eventId: string,
-  submissionId: string,
-  message: AssistantMessage,
-  requestedModel: RuntimeSnapshot["pi"]["model"],
-): RuntimeModelUsageEvent {
-  return {
-    eventId,
-    submissionId,
-    runId: submissionId,
-    kind: "assistant",
-    ...summarizeModelUsage(requestedModel, [message]),
-  };
-}
-
-// 作用：把用户消息内容变成可比较的稳定形状。
-// 调用：重新生成回答时，提交入口用它核对客户端与已存用户消息。
-// 原因：字符串和分段内容必须先归一化，否则语义相同的消息会被误判为不同。
-// 把 park 时存下的 Tool 输入还原成对象，交给该 Tool 自己的 settle 映射。
-// respondToolInteraction 调用；解析失败按 undefined 处理，因为映射函数是否用得到它由 Tool 决定。
-function safeParseJson(text: string): unknown {
-  try {
-    return JSON.parse(text);
-  } catch {
-    return undefined;
-  }
-}
-
-// Tool 没有提供 settle 时的缺省映射：响应原样成为 ToolResult 的 details。
-// text 用 serializeOutput 而不是裸 JSON.stringify，与其他 Tool 结果的文本形态保持一致。
-function defaultInteractionResult(
-  response: unknown,
-): { content: ToolResultMessage["content"]; details: unknown } {
-  return {
-    content: [{ type: "text", text: serializeOutput(response).text }],
-    details: response,
-  };
-}
-
-function userContentKey(message: PiCanonicalUserInput): string {
-  return json(
-    typeof message.content === "string"
-      ? [{ type: "text", text: message.content }]
-      : message.content,
-  );
-}
-
-function requestedCapabilitiesOf(metadata: unknown): RequestedCapability[] {
-  if (metadata === null || typeof metadata !== "object" || Array.isArray(metadata)) {
-    return [];
-  }
-  const record = metadata as Record<string, unknown>;
-  if (!("requestedCapabilities" in record)) return [];
-  if (!Array.isArray(record.requestedCapabilities)) {
-    throw new Error("requestedCapabilities must be an array");
-  }
-
-  const result: RequestedCapability[] = [];
-  const seen = new Set<string>();
-  for (const value of record.requestedCapabilities) {
-    if (value === null || typeof value !== "object" || Array.isArray(value)) {
-      throw new Error("requestedCapabilities contains an invalid capability");
-    }
-    const capability = value as Record<string, unknown>;
-    if (
-      (capability.kind !== "skill" && capability.kind !== "tool" && capability.kind !== "plan") ||
-      typeof capability.name !== "string" ||
-      !capability.name.trim() ||
-      typeof capability.label !== "string" ||
-      !capability.label.trim()
-    ) {
-      throw new Error("requestedCapabilities contains an invalid capability");
-    }
-    const key = `${capability.kind}:${capability.name}`;
-    if (seen.has(key)) continue;
-    seen.add(key);
-    result.push({
-      kind: capability.kind,
-      name: capability.name,
-      label: capability.label,
-    });
-  }
-  return result;
-}
-
-interface PendingTemporaryAgentApproval {
-  receipt: ApprovalReceipt;
-  submissionId?: string;
-  toolCallId: string;
-  resolve(decision: TemporaryAgentApprovalDecision): void;
-}
-
-export interface ToolInteractionResponsePreparation {
-  readonly toolCallId: string;
-  readonly toolName: string;
-  readonly toolInput: unknown;
-  readonly response: unknown;
-}
-
-// #endregion
-
-/**
- * 这是 UniversalAgent 唯一的生产 Runtime Kernel。
- *
- * @remarks
- * Cloudflare Agent 负责 Durable Object 生命周期、SQLite、facet、
- * WebSocket、定时任务和 fiber。
- *
- * Pi 负责模型与 Tool 循环和 canonical transcript。
- *
- * 生产 Agent 由 `defineRuntimeAgent` 生成子类，应用不直接实例化本类。
- */
-export abstract class AgentRuntimeKernel<
-  Env extends Cloudflare.Env = Cloudflare.Env,
-> extends RecoverableChatAgent<Env, RuntimeState, PiChatRecoveryData> {
-  override chatRecovery: ChatRecoveryConfig = {
-    maxAttempts: CHAT_RECOVERY_MAX_ATTEMPTS,
-    terminalMessage: CHAT_RECOVERY_TERMINAL_MESSAGE,
-  };
-
-  initialState: RuntimeState = {
-    runtimeLoad: { status: "idle", available: false },
-  };
-
-  protected abstract ensureRuntimeReady(): Promise<void>;
-  /** Runs only before the first pin of a newly activated Submission. */
-  protected prepareRuntimeForSubmission(_submissionId: string): Promise<void> {
-    return this.ensureRuntimeReady();
-  }
-  protected get submissionContext() {
-    return {
-      id: this.submissions.currentActive()?.submissionId ?? this.db.submissions.findRunning()?.submissionId,
-      unfinishedIds: this.db.submissions.listUnfinishedIds(),
-    };
-  }
-
-  /** Let the Host prepare a validated client response before Tool settlement. */
-  protected prepareToolInteractionResponse(
-    input: ToolInteractionResponsePreparation,
-  ): Promise<unknown | null> {
-    return Promise.resolve(input.response);
-  }
-
-  private activeRuntime?: ActiveRuntime;
-  private telemetryCoordinator?: RuntimeTelemetryCoordinator;
-  private piAdapter?: PiRuntimeAdapter;
-  private readonly transcript: PiRuntimeTranscript;
-  private readonly submissions: SubmissionLifecycle<
-    StoredSubmission,
-    ActiveTurn
-  >;
-  private readonly approvals: ApprovalLifecycle<StoredSubmission>;
-  private readonly interactions: InteractionLifecycle<StoredSubmission>;
-  private runtimeLoadTracker?: RuntimeLoadTracker;
-  private modelSessionId?: string;
-  private readonly modelSessionIdReady?: Promise<void>;
-  private runtimeEventDrainTail?: Promise<void>;
-  private readonly streamBySubmission = new Map<string, string>();
-  private migratedSubmissionIds?: Set<string>;
-  private db!: RuntimeDatabase;
-  private readonly temporaryAgents = new TemporaryAgentCoordinator();
-  private readonly admissionsInFlight = new Map<
-    string,
-    Promise<import("./kernel/bindings").RuntimeSubmissionAdmissionResult>
-  >();
-  private readonly temporaryAgentApprovals =
-    new Map<string, PendingTemporaryAgentApproval>();
-
-  // #region 构造、装配与启动
-
-  // 作用：返回当前 Kernel 唯一的 Pi 适配器。
-  // 调用：构造和后续所有 Pi 装配、Turn 与恢复路径都通过它访问。
-  // 原因：允许构造时注入适配器，同时为未注入场景保留惰性单例。
-  private get pi(): PiRuntimeAdapter {
-    return this.piAdapter ??= new PiRuntimeAdapter();
-  }
-
-  /**
-   * Runtime 装载进度的状态机。
-   *
-   * @remarks
-   * 本类和 `defineRuntimeAgent` 生成的宿主共同驱动它：宿主管一轮尝试的起止，
-   * `initConfig` 管中途的阶段推进，因此它是 protected 而非 private。
-   *
-   * 写成惰性访问器而不是字段：本类有测试用 `Object.create(prototype)` 造替身，
-   * 那条路径既不跑构造函数也不跑字段初始化器。
-   */
-  protected get runtimeLoad(): RuntimeLoadTracker {
-    return this.runtimeLoadTracker ??= new RuntimeLoadTracker({
-      read: () => this.state.runtimeLoad,
-      publish: (runtimeLoad) => this.setState({ ...this.state, runtimeLoad }),
-      isAvailable: () => Boolean(this.activeRuntime),
-    });
-  }
-
-  private get telemetry(): RuntimeTelemetryCoordinator {
-    return this.telemetryCoordinator ??= new RuntimeTelemetryCoordinator({
-      outbox: () => this.db?.telemetry,
-      waitUntil: (promise) => this.ctx.waitUntil(promise),
-      scheduleRetry: async (delaySeconds, idempotent) => {
-        await this.schedule(
-          delaySeconds,
-          "_drainTelemetry",
-          undefined,
-          { idempotent },
-        );
-      },
-      onError: (error) => {
-        console.warn(
-          "[runtime-telemetry:degraded]",
-          json({ error: errorText(error) }),
-        );
-      },
-    });
-  }
-
-  /**
-   * 为一个 Cloudflare Durable Object 实例建立持久化与执行协作器。
-   *
-   * @remarks
-   * Cloudflare Runtime 创建由 `defineRuntimeAgent` 生成的类时，间接调用。
-   *
-   * 数据库 schema、Submission、Transcript 和 Approval 在同一构造路径绑定，
-   * 避免它们引用不同的事务边界或 Pi 适配器。
-   */
-  constructor(
-    ctx: DurableObjectState,
-    env: Env,
-    pi: PiRuntimeAdapter = new PiRuntimeAdapter(),
-  ) {
-    super(ctx, env, {
-      fiberPrefix: "__cf_internal_pi_turn:",
-      snapshotKey: "__cfPiFiberSnapshot",
-      snapshotKind: "pi-turn",
-    });
-    this.modelSessionIdReady = ctx.storage.get<string>(
-      MODEL_SESSION_ID_STORAGE_KEY,
-    ).then((stored) => {
-      this.modelSessionId = stored;
-    });
-    this.piAdapter = pi;
-    this.db = new RuntimeDatabase(
-      this.sql.bind(this),
-      (fn) => this.ctx.storage.transactionSync(fn),
-    );
-    this.db.initializeSchema();
-    const submissionStore: SubmissionStore<StoredSubmission> = {
-      transaction: (run) => this.db.transaction(run),
-      find: (submissionId) => this.readSubmission(submissionId),
-      findByRequestId: (requestId) =>
-        this.findSubmissionByRequest(requestId),
-      findByIdempotencyKey: (key) => this.findSubmissionByKey(key),
-      countUnfinished: () =>
-        this.db.submissions.countUnfinished(),
-      countPending: () => this.db.submissions.countPending(),
-      findRunning: () =>
-        this.db.submissions.findRunning() as StoredSubmission | null,
-      findNextPending: () =>
-        this.db.submissions.findNextPending() as StoredSubmission | null,
-      listPending: () =>
-        this.db.submissions.listPending() as StoredSubmission[],
-      updateAbortReason: (submissionId, reason) =>
-        this.db.submissions.updateAbortReason(submissionId, reason),
-    };
-    this.submissions = new SubmissionLifecycle({
-      store: submissionStore,
-      clearTerminal: () => clearChatTerminal(this.ctx.storage),
-      execute: (submissionId, mode) =>
-        this.executeSubmission(submissionId, mode),
-      appendAbortIntent: (submission, reason) =>
-        this.appendTerminalIntent(submission, "aborted", reason),
-      commitTerminal: (submission, outcome, message) =>
-        this.commitTerminalOutcome(submission, outcome, message),
-      abortActive: (turn) => turn.agent.abort(),
-      interruptActive: (turn) => turn.agent.interrupt(),
-    });
-    this.transcript = this.pi.createTranscript({
-      storage: this.ctx.storage,
-      durability: {
-        transaction: (run) => this.db.transaction(run),
-        upsertUserSidecar: (id, body) =>
-          this.db.messageUi.upsert(id, body),
-        readUserSidecar: (id) => this.db.messageUi.get(id),
-        clearUserSidecars: () => this.db.messageUi.clear(),
-        listMessageSubmissionLinks: () =>
-          this.db.submissions.listMessageSubmissionLinks(),
-        findSubmissionProjection: (submissionId) =>
-          this.readSubmission(submissionId),
-        listApprovalViews: (submissionId) =>
-          this.db.approvals.listApprovalViews(submissionId),
-      },
-      hasActiveTurn: () => this.submissions.isBusy(),
-    });
-    this.approvals = new ApprovalLifecycle({
-      db: this.db,
-      pi: this.pi,
-      findSubmission: (submissionId) =>
-        this.readSubmission(submissionId),
-      isSubmissionActive: (submissionId) => this.submissions.isActive(submissionId),
-      applyRecoveryMutations: (submission, mutations) =>
-        this.applyPiRecoveryMutations(submission, mutations),
-      materializeRecoveredToolResults: (submission) =>
-        this.materializeRecoveredToolResults(submission),
-      scheduleContinuation: async (data) => {
-        await this.schedule(
-          0,
-          "_piApprovalContinuation",
-          data,
-          { idempotent: true },
-        );
-      },
-      onApprovalsChanged: () => this.broadcastApprovals(),
-      onTelemetryRequested: (approval) => {
-        this.telemetry.capture("approvalRequested", {
-          submissionId: approval.submissionId,
-          toolCallId: approval.toolCallId,
-          executionId: approval.executionId,
-          toolName: approval.toolName,
-          summary: approval.summary,
-          input: safeParseJson(approval.inputJson),
-          occurredAt: approval.createdAt,
-        });
-      },
-      onTelemetryDecided: (approval, decision) => {
-        this.telemetry.capture("approvalDecided", {
-          submissionId: approval.submissionId,
-          toolCallId: approval.toolCallId,
-          executionId: approval.executionId,
-          decision,
-          ...(approval.reason ? { reason: approval.reason } : {}),
-          occurredAt: approval.decidedAt ?? Date.now(),
-        });
-      },
-    });
-    this.interactions = new InteractionLifecycle({
-      db: this.db,
-      pi: this.pi,
-      findSubmission: (submissionId) =>
-        this.readSubmission(submissionId),
-      applyRecoveryMutations: (submission, mutations) =>
-        this.applyPiRecoveryMutations(submission, mutations),
-      materializeRecoveredToolResults: (submission) =>
-        this.materializeRecoveredToolResults(submission),
-      // 与审批不同，这里不经 `schedule` 绕一圈：RPC 已经把 DO 叫醒了，
-      // 而 interaction 没有自己的续跑键，续跑就是普通的「已结算 Tool 恢复原 Turn」。
-      resumeSubmission: async (submissionId) => {
-        await this.submissions.recover(submissionId);
-      },
-      onInteractionsChanged: async () => {
-        this.broadcast(json({
-          type: MessageType.CF_AGENT_CHAT_MESSAGES,
-          messages: await this.getMessages(),
-        }));
-        await this.broadcastApprovals();
-      },
-      onTelemetryRequested: (interaction) => {
-        this.telemetry.capture("interactionRequested", {
-          submissionId: interaction.submissionId,
-          toolCallId: interaction.toolCallId,
-          interactionId: interaction.interactionId,
-          toolName: interaction.toolName,
-          input: safeParseJson(interaction.inputJson),
-          occurredAt: interaction.createdAt,
-        });
-      },
-      onTelemetrySettled: (interaction) => {
-        if (interaction.status === "responded") {
-          this.telemetry.capture("interactionResponded", {
-            submissionId: interaction.submissionId,
-            toolCallId: interaction.toolCallId,
-            interactionId: interaction.interactionId,
-            ...(interaction.responseJson
-              ? { response: safeParseJson(interaction.responseJson) }
-              : {}),
-            occurredAt: interaction.respondedAt ?? Date.now(),
-          });
-          return;
-        }
-        if (interaction.status === "cancelled") {
-          this.telemetry.capture("interactionCancelled", {
-            submissionId: interaction.submissionId,
-            toolCallId: interaction.toolCallId,
-            interactionId: interaction.interactionId,
-            occurredAt: interaction.respondedAt ?? Date.now(),
-          });
-        }
-      },
-    });
-  }
-
-  // 作用：把通用聊天恢复协议接到本 Runtime 的 Submission 和 Pi 里程碑。
-  // 调用：`RecoverableChatAgent` 第一次需要分类或重试中断 Turn 时惰性调用。
-  // 原因：传输层不应认识 Pi 数据库，所以用窄端口隔开通用恢复与领域决策。
-  protected createRecoveryPort() {
-    return this.pi.createRecovery({
-      readRecoveryState: (requestId) => {
-        const submission = this.findSubmissionByRequest(requestId);
-        if (!submission) return null;
-        return {
-          submissionId: submission.submissionId,
-          requestId: submission.requestId,
-          terminal: isTerminalSubmissionStatus(submission.status),
-          milestoneBodies: this.recoveryMilestoneBodies(
-            submission.submissionId,
-          ),
-          settledToolCount: this.db.settlements.countForSubmission(
-            submission.submissionId,
-          ),
-        };
-      },
-      retryTurn: async (submissionId) => {
-        try {
-          const receipt = await this.submissions.recover(submissionId);
-          return receipt.status === "completed"
-            ? { status: "completed" as const }
-            : {
-                status: "failed" as const,
-                error:
-                  receipt.error ??
-                  `SpringBrand recovery ended with status ${receipt.status}`,
-              };
-        } catch (error) {
-          if (
-            error instanceof ChatStreamStalledError ||
-            error instanceof RetryableModelError
-          ) {
-            return { status: "scheduled" as const };
-          }
-          throw error;
-        }
-      },
-      failTurn: async (submissionId, message) => {
-        const submission = this.readSubmission(submissionId);
-        if (submission) {
-          await this.submissions.finish(submission, "failed", message);
-        }
-      },
-      hasPendingInteraction: () => this.approvals.countPending() > 0,
-    });
-  }
-
-  // 作用：准备并原子切换一份新的 Runtime 配置。
-  // 调用：生成 Agent 在首次启动或显式重载 Runtime key 时调用。
-  // 原因：先完整 prepare 再替换 Snapshot，且活跃 Turn 期间禁止换 revision，可避免半装配和恢复时能力漂移。
-  protected async initConfig(input: RuntimeAssemblyInput): Promise<void> {
-    const candidate = await prepareRuntimeCandidate(input);
-    await this.initCandidate(candidate);
-  }
-
-  private turnEventsPort(): RuntimeTurnEventsPort | undefined {
-    return this.activeRuntime?.snapshot.bindings.turnEvents;
-  }
-
-  protected async initCandidate(candidate: RuntimeCandidate): Promise<void> {
-    await this.modelSessionIdReady;
-    const previous = this.activeRuntime;
-    const candidateSnapshot = candidate.snapshot;
-    this.runtimeLoad.advance("assembly");
-    this.runtimeLoad.advance("mcp");
-    await connectConfiguredMcpServers(
-      this,
-      candidateSnapshot.profile.mcpServers.filter(server => !server.hostManaged),
-    );
-    const gatewayDegradations = [];
-    let gatewaySession: RuntimeGatewaySession | undefined;
-    if (candidateSnapshot.bindings.gateway) {
-      try {
-        gatewaySession = await withRuntimeLoadTimeout(
-          "gateway.open",
-          () => candidateSnapshot.bindings.gateway!.open(
-            `${this.ctx.id.toString()}:${crypto.randomUUID()}`,
-          ),
-          {
-            onLateResult: (session) =>
-              closeRuntimeGatewaySession(session, "gateway.close.late"),
-          },
-        );
-      } catch {
-        gatewayDegradations.push({
-          capability: "connector" as const,
-          reason: "unavailable" as const,
-          detail: "Connector Gateway MCP",
-        });
-      }
-    }
-
-    this.runtimeLoad.advance("pi");
-    let prepared: PreparedPiRuntime;
-    try {
-      prepared = await this.pi.prepare({
-        snapshot: candidateSnapshot,
-        mcpHost: this,
-        gatewaySession,
-        additionalDegradations: gatewayDegradations,
-        createExtensionHostBinding: (permissions, ownContextLabels) =>
-          this.createExtensionHostBinding(
-            permissions,
-            ownContextLabels,
-          ),
-      });
-    } catch (error) {
-      await closeRuntimeGatewaySession(gatewaySession, "gateway.close.failed");
-      throw error;
-    }
-    const revision = await this.hash(prepared.revisionDescriptor);
-    // 停在人机等待上的 Submission 是「未完成」，但没有任何模型请求在飞、
-    // 没有任何工具在执行 —— 换装配对它是安全的，而且这正是「决定时才装上
-    // 新能力，同一轮接着跑」所依赖的那一步。真正在执行的 Turn 仍然被挡住。
-    const contested = Boolean(previous) &&
-      revision !== previous?.revision &&
-      this.submissions.isBusy() &&
-      this.db.submissions.listUnfinishedIds().some(id => Boolean(this.readSubmission(id)?.assemblyRevision));
-    const parked = contested && this.db.everyUnfinishedSubmissionParked();
-    if (contested && !parked) {
-      await closeRuntimeGatewaySession(gatewaySession, "gateway.close.contested");
-      throw new Error(
-        "Cannot reload Runtime while a revision-pinned SpringBrand Turn is active",
-      );
-    }
-    const repin = parked
-      ? await withRuntimeLoadTimeout(
-          "parked-submission.repin",
-          () => this.prepareParkedSubmissionRepin(prepared, revision),
-        )
-      : undefined;
-    const next = Object.freeze({
-      snapshot: candidateSnapshot,
-      revision,
-      pi: prepared,
-      ...(gatewaySession ? { gatewaySession } : {}),
-      ...(candidate.admission
-        ? { admission: candidate.admission }
-        : {}),
-    }) satisfies ActiveRuntime;
-    let activated = false;
-    const previousGatewaySession = previous?.gatewaySession;
-    try {
-      for (const [index, guard] of candidate.commitGuards.entries()) {
-        await withRuntimeLoadTimeout(`commit-guard:${index}`, guard);
-      }
-      this.pi.activate(candidateSnapshot);
-      activated = true;
-      repin?.commit();
-      this.telemetry.configure(candidate.telemetry);
-      this.activeRuntime = next;
-    } catch (error) {
-      repin?.abort();
-      if (activated && previous) this.pi.activate(previous.snapshot);
-      await closeRuntimeGatewaySession(gatewaySession, "gateway.close.aborted");
-      throw error;
-    }
-    if (repin) {
-      await withRuntimeLoadTimeout(
-        "parked-submission.interrupt",
-        () => repin.interrupt(),
-      ).catch(() => undefined);
-    }
-    await closeRuntimeGatewaySession(
-      previousGatewaySession,
-      "gateway.close.previous",
-    );
-
-    const degradations = prepared.degradations;
-    if (degradations.length > 0) {
-      console.warn(
-        "[runtime-load:degraded]",
-        json({ degradations }),
-      );
-    }
-  }
-
-  async _drainTelemetry(): Promise<void> {
-    await this.ensureRuntimeReady();
-    await this.telemetry.drainScheduled();
-  }
-
-  // 作用：为某个已准入 Submission 建立一次 Pi Turn 执行适配器。
-  // 调用：新 Turn、恢复 Turn 和审批后重试 Tool 都在开始 Pi 执行前调用。
-  // 原因：在这里一次性固定 revision、持久化回调与终态回调，防止各执行路径绕过同一耐久性规则。
-  private createSubmissionExecutionAdapter(
-    submission: StoredSubmission,
-    output: {
-      readonly startedAt?: number;
-      readonly continuation?: boolean;
-      readonly assistantOrdinal?: number;
-      readonly onRecord?: (
-        chunk: UIMessageChunk,
-      ) => void | Promise<void>;
-      readonly onTerminal?: (
-        terminal: {
-          outcome: "succeeded" | "failed" | "aborted";
-          message?: string;
-        },
-      ) => void | Promise<void>;
-    } = {},
-  ): PreparedPiTurnAdapter {
-    const startedAt = output.startedAt ?? Date.now();
-    const snapshot = this.assembly();
-    const runMetadata: RuntimeSubagentRunMetadata = {
-      submissionId: submission.submissionId,
-      parentRunId: submission.runId ?? submission.submissionId,
-    };
-    const lifecycle = this.subagentLifecycle(runMetadata);
-    const toolExecutors = snapshot.bindings.subagents
-      ? this.pi.subagentToolExecutors(
-          snapshot.bindings.subagents,
-          snapshot.profile.enabledSubagents,
-          {
-            ...runMetadata,
-            onRegistered: async (runId) => {
-              await lifecycle.register(runId);
-            },
-            onUsage: async (event) => {
-              await lifecycle.usage(event);
-            },
-            onTerminal: async (terminal) => {
-              await lifecycle.terminal(terminal);
-            },
-          },
-        )
-      : undefined;
-    return this.pi.createTurn({
-      prepared: this.preparedPi(),
-      pinnedDescriptor: submission.assemblyDescriptor,
-      modelSessionId: this.modelSessionId ?? this.name,
-      submission: {
-        id: submission.submissionId,
-        requestId: submission.requestId,
-        messageId: submission.assistantMessageId,
-        startedAt,
-        continuation: output.continuation ?? false,
-        assistantOrdinal: output.assistantOrdinal ?? 0,
-        modelTurnsConsumed: submission.modelTurns,
-      },
-      canonicalMessages: () => this.transcript.canonicalMessages(),
-      durability: {
-        findToolSettlement: (toolCallId) =>
-          this.readToolSettlement(submission.submissionId, toolCallId),
-        requestToolApproval: (approval, signal, onCreated) =>
-          this.approvals.request(
-            submission,
-            approval,
-            signal,
-            async (created) => {
-              await onCreated?.();
-              try {
-                await this.turnEventsPort()?.onApproval?.({
-                  submissionId: submission.submissionId,
-                  approvalExecutionId: created.executionId,
-                });
-              } catch (error) {
-                console.warn(
-                  "[runtime-approval-projection:degraded]",
-                  json({ error: errorText(error) }),
-                );
-              }
-            },
-          ),
-        // spec 在这里用不上：响应侧一律从重新装配出的 candidate 按 toolName 取回同一份，
-        // 好让「DO 一直醒着」和「park 期间睡过一觉」走完全相同的一条代码路径。
-        requestToolInteraction: (interaction, _spec, signal) =>
-          this.interactions.request(submission, interaction, signal),
-        appendToolInput: (input) =>
-          this.appendToolInput(submission, input),
-        settleTool: (call) =>
-          this.settleTool(submission.submissionId, call),
-      },
-      onGeneration: (event) => {
-        if (event.type === "started") {
-          this.telemetry.capture("generationStarted", {
-            submissionId: submission.submissionId,
-            generationId: event.generationId,
-            provider: event.provider,
-            model: event.model,
-            input: event.input,
-            occurredAt: event.timestamp,
-          });
-          return;
-        }
-        this.telemetry.capture("generationFinished", {
-          submissionId: submission.submissionId,
-          generationId: event.generationId,
-          outcome: event.outcome === "success"
-            ? "completed"
-            : event.outcome === "cancelled"
-              ? "cancelled"
-              : "failed",
-          durationMs: event.durationMs,
-          ...(event.usage
-            ? {
-                inputTokens: event.usage.input,
-                outputTokens: event.usage.output,
-                totalTokens: event.usage.totalTokens,
-                cost: event.usage.cost.total,
-              }
-            : {}),
-          ...(event.errorName ? { error: event.errorName } : {}),
-          ...(event.output ? { output: event.output } : {}),
-          occurredAt: event.timestamp,
-        });
-      },
-      onNestedToolStarted: (event) => {
-        this.telemetry.capture("toolStarted", {
-          submissionId: submission.submissionId,
-          ...event,
-        });
-      },
-      onNestedToolFinished: (event) => {
-        this.telemetry.capture("toolFinished", {
-          submissionId: submission.submissionId,
-          parentToolCallId: event.parentToolCallId,
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          outcome: event.outcome,
-          durationMs: event.durationMs,
-          ...(event.output ? {
-            output: event.output,
-            outputBytes: json(event.output).length,
-          } : {}),
-          ...(event.error ? { error: errorText(event.error) } : {}),
-          occurredAt: event.occurredAt,
-        });
-        this.projectNestedToolSettlement(submission.submissionId, event);
-      },
-      onUnknownToolStarted: (event) => {
-        this.telemetry.capture("toolStarted", {
-          submissionId: submission.submissionId,
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          input: event.input,
-          occurredAt: event.occurredAt,
-        });
-      },
-      onUnknownToolFinished: (event) => {
-        this.telemetry.capture("toolFinished", {
-          submissionId: submission.submissionId,
-          toolCallId: event.toolCallId,
-          toolName: event.toolName,
-          outcome: event.outcome,
-          output: event.output,
-          outputBytes: json(event.output).length,
-          occurredAt: event.occurredAt,
-        });
-      },
-      ...(toolExecutors && Object.keys(toolExecutors).length > 0
-        ? { toolExecutors }
-        : {}),
-      transformContext: (messages, signal) =>
-        this.transformPiContext(submission.submissionId, messages, signal),
-      abortReason: () =>
-        this.readSubmission(submission.submissionId)?.abortReason,
-      onRecord: output.onRecord ?? (() => undefined),
-      onCanonicalMessage: async (commit) => {
-        // 换装配把这条执行器中断掉了。它退场路上还会吐出「工具被中止」这样的
-        // 消息 —— 那不是这一轮的事实，写进权威 transcript 会让重建出来的续跑
-        // 看到一份自己从没产生过的工具结果。
-        if (this.migratedSubmissions.has(submission.submissionId)) return;
-        let consumedSteer = false;
-        this.db.transaction(() => {
-          if (commit.kind !== "append-user") {
-            const persisted = this.transcript.commitAdapterMessage(
-              submission.submissionId,
-              commit,
-            );
-            if (persisted.inserted && commit.message.role === "assistant") {
-              const event = assistantUsageEvent(
-                persisted.id,
-                submission.submissionId,
-                commit.message,
-                snapshot.pi.model,
-              );
-              this.db.runtimeEvents.insert({
-                eventId: event.eventId,
-                body: json({ type: "model-usage", event }),
-                createdAt: commit.message.timestamp,
-              });
-            }
-            return;
-          }
-          const pending = this.db.steers.findByMessageId(commit.id);
-          if (!pending) {
-            this.transcript.commitAdapterMessage(
-              submission.submissionId,
-              commit,
-            );
-            return;
-          }
-          if (pending.submissionId !== submission.submissionId) {
-            throw new Error(
-              `Steer ${pending.steerId} belongs to another submission`,
-            );
-          }
-          const uiMessage = pending.uiMessageJson
-            ? JSON.parse(pending.uiMessageJson) as UIMessage & {
-                role: "user";
-              }
-            : undefined;
-          this.transcript.append(commit.id, commit.message, {
-            submissionId: submission.submissionId,
-            ...(uiMessage ? { userMessage: uiMessage } : {}),
-          });
-          this.db.steers.deleteByMessageId(commit.id);
-          consumedSteer = true;
-        });
-        await this.drainRuntimeEvents();
-        if (consumedSteer) await this.broadcastApprovals();
-      },
-      onTerminal: output.onTerminal ?? (() => undefined),
-    });
-  }
-
-  private subagentLifecycle(
-    input: RuntimeSubagentRunMetadata,
-  ): RuntimeSubagentLifecycleRecorder {
-    return new RuntimeSubagentLifecycleRecorder(input, {
-      save: async (event) => {
-        this.db.transaction(() => {
-          this.db.runtimeEvents.insert({
-            eventId: event.eventId,
-            body: json({
-              type: event.kind === "subagent" ? "subagent-usage" : "lifecycle",
-              event,
-            }),
-            createdAt: Date.now(),
-          });
-        });
-        await this.drainRuntimeEvents();
-      },
-      has: (eventId) => this.db.runtimeEvents.has(eventId),
-      hasSubagentUsage: (submissionId, subagentRunId) =>
-        this.db.runtimeEvents.hasSubagentUsage(submissionId, subagentRunId),
-    });
-  }
-
-  /**
-   * 在 Agent 实例启动或从休眠唤醒后恢复 Session 本地后台状态。
-   *
-   * @remarks
-   * Cloudflare Agents SDK 在任何 HTTP、WebSocket 或 RPC 调用前调用它。
-   *
-   * 先恢复审批续跑，再分类未完 Submission，
-   * 可避免把正在等待人的 Turn 当成普通中断直接重试。
-   *
-   * 待确认：Cloudflare 当前文档说 `DurableObjectState.waitUntil`
-   * 不会延长 Durable Object 生命；本文件仍在三处用它启动后台任务。
-   */
-  async onStart(): Promise<void> {
-    this.runtimeLoad.reset();
-    this.telemetry.recover(() => this.ensureRuntimeReady());
-    if (this.db.runtimeEvents.hasPending()) {
-      this.ctx.waitUntil(
-        this.ensureRuntimeReady().then(() => this.drainRuntimeEvents()),
-      );
-    }
-    await this.broadcastApprovals();
-    await this.approvals.dispatchPendingContinuations();
-    const running = this.db.submissions.findRunning() as StoredSubmission | null;
-    if (running) {
-      const effect = this.decidePiRecovery(running).effect;
-      if (effect.kind === "wait" && effect.reason === "approval") {
-        return;
-      }
-    }
-    this.ctx.waitUntil(
-      this.submissions.recoverHead().then(() => undefined),
-    );
-  }
-
-  private drainRuntimeEvents(idempotentRetry = true): Promise<void> {
-    const drain = (this.runtimeEventDrainTail ?? Promise.resolve())
-      .catch(() => undefined)
-      .then(() => this.deliverRuntimeEvents(idempotentRetry));
-    this.runtimeEventDrainTail = drain;
-    return drain.finally(() => {
-      if (this.runtimeEventDrainTail === drain) {
-        this.runtimeEventDrainTail = undefined;
-      }
-    });
-  }
-
-  private async deliverRuntimeEvents(idempotentRetry: boolean): Promise<void> {
-    const turnEvents = this.turnEventsPort();
-    if (!turnEvents) return;
-
-    let failed = false;
-    for (const row of this.db.runtimeEvents.listPending()) {
-      try {
-        const payload = JSON.parse(row.body) as RuntimeEventOutboxPayload;
-        if (payload.type === "model-usage") {
-          await turnEvents.onModelUsage?.(payload.event);
-        } else if (payload.type === "tool-settlement") {
-          await turnEvents.onToolSettled?.(payload.event);
-        } else if (payload.type === "subagent-usage") {
-          if (turnEvents.onSubagentUsage) {
-            const confirmation = await turnEvents.onSubagentUsage(payload.event);
-            if (confirmation?.confirmed !== true) {
-              throw new Error("Runtime event was not confirmed");
-            }
-          }
-        } else {
-          if (turnEvents.onLifecycleFact) {
-            const confirmation = await turnEvents.onLifecycleFact(payload.event);
-            if (confirmation?.confirmed !== true) {
-              throw new Error("Runtime event was not confirmed");
-            }
-          }
-        }
-        this.db.transaction(() =>
-          this.db.runtimeEvents.markDelivered(row.eventId, Date.now())
-        );
-      } catch (error) {
-        const failure = errorText(error);
-        const attemptCount = this.db.transaction(() => {
-          const nextAttemptCount = this.db.runtimeEvents.markFailed(
-            row.eventId,
-            failure,
-          );
-          if (nextAttemptCount >= RUNTIME_EVENT_MAX_ATTEMPTS) {
-            this.db.runtimeEvents.quarantine(row.eventId, Date.now(), failure);
-          }
-          return nextAttemptCount;
-        });
-        if (attemptCount >= RUNTIME_EVENT_MAX_ATTEMPTS) {
-          console.warn(
-            "[runtime-turn-event:quarantined]",
-            json({ eventId: row.eventId, attemptCount, error: failure }),
-          );
-          continue;
-        }
-        failed = true;
-        console.warn(
-          "[runtime-turn-event:degraded]",
-          json({ eventId: row.eventId, attemptCount, error: failure }),
-        );
-        break;
-      }
-    }
-    if (!failed) return;
-
-    try {
-      await this.schedule(
-        TURN_EVENT_RETRY_SECONDS,
-        "_drainRuntimeTurnEvents",
-        undefined,
-        { idempotent: idempotentRetry },
-      );
-    } catch (error) {
-      console.warn(
-        "[runtime-turn-event-retry:degraded]",
-        json({ error: errorText(error) }),
-      );
-    }
-  }
-
-  async _drainRuntimeTurnEvents(): Promise<void> {
-    await this.ensureRuntimeReady();
-    await this.drainRuntimeEvents(false);
-  }
-
-  // 作用：重新读取当前 Snapshot 以刷新动态 Context 依赖。
-  // 调用：生成 Agent 的 `refreshMemoryContext` 在确保配置已加载后调用。
-  // 原因：统一经过 `assembly` 的已初始化检查，不再引入第二份配置状态。
-  async refreshContext(): Promise<void> {
-    this.assembly();
-  }
-
-  // 作用：在当前 Session 内启动一个临时 Agent 执行。
-  // 调用：临时 Agent Tool 通过 `RuntimeAgentConfigContext` 带着本次信号调用。
-  // 原因：协调器统一跟踪运行和取消，不把临时子执行塞进持久 Submission 模型。
-  protected runTemporaryAgent(
-    request: TemporaryAgentRequest,
-    context: TemporaryAgentRunContext,
-    execute: TemporaryAgentExecutor,
-  ): Promise<string> {
-    return this.temporaryAgents.run(
-      request,
-      async (normalized) => {
-        const submission = this.findSubmissionByRequest(context.requestId);
-        const subagentId = `temporary:${context.toolCallId}`;
-        const startedAt = Date.now();
-        if (submission) {
-          this.telemetry.capture("subagentStarted", {
-            submissionId: submission.submissionId,
-            toolCallId: context.toolCallId,
-            subagentId,
-            agentType: normalized.subagentName,
-            prompt: {
-              instructions: normalized.instructions,
-              task: normalized.task,
-            },
-            occurredAt: startedAt,
-          });
-        }
-        try {
-          const output = await execute(normalized);
-          if (submission) {
-            this.telemetry.capture("subagentFinished", {
-              submissionId: submission.submissionId,
-              toolCallId: context.toolCallId,
-              subagentId,
-              outcome: "completed",
-              durationMs: Math.max(0, Date.now() - startedAt),
-              output,
-            });
-          }
-          return output;
-        } catch (error) {
-          if (submission) {
-            this.telemetry.capture("subagentFinished", {
-              submissionId: submission.submissionId,
-              toolCallId: context.toolCallId,
-              subagentId,
-              outcome: context.signal.aborted ? "cancelled" : "failed",
-              durationMs: Math.max(0, Date.now() - startedAt),
-              error: errorText(error),
-            });
-          }
-          throw error;
-        }
-      },
-      context.signal,
-    );
-  }
-
-  /**
-   * 登记一条临时 Agent 的 Tool 审批并等待用户决定。
-   *
-   * @remarks
-   * Temporary Agent Host 在子执行需要人工授权时调用。
-   *
-   * 它与持久 Pi Tool 审批共用同一客户端投影，但只保存本次执行的 Promise，
-   * 因为临时 Agent 本身不参与 Session Turn 恢复。
-   */
-  async requestTemporaryAgentApproval(
-    request: TemporaryAgentApprovalRequest,
-  ): Promise<TemporaryAgentApprovalDecision> {
-    if (this.temporaryAgentApprovals.has(request.executionId)) {
-      throw new Error(
-        `temporary agent approval already pending: ${request.executionId}`,
-      );
-    }
-    const submission = this.findSubmissionByRequest(request.requestId);
-    return new Promise((resolve, reject) => {
-      this.temporaryAgentApprovals.set(request.executionId, {
-        receipt: {
-          executionId: request.executionId,
-          source: "temporary-agent",
-          action: request.toolName,
-          summary: `${request.subagentName} requests ${request.toolName}`,
-          executionLevel: request.executionLevel,
-          requiredExecutionLevel: request.requiredExecutionLevel,
-          inputJson: JSON.stringify(request.input ?? null),
-          requestId: request.requestId,
-        },
-        ...(submission ? { submissionId: submission.submissionId } : {}),
-        toolCallId: request.toolCallId,
-        resolve,
-      });
-      if (submission) {
-        this.telemetry.capture("approvalRequested", {
-          submissionId: submission.submissionId,
-          toolCallId: request.toolCallId,
-          executionId: request.executionId,
-          toolName: request.toolName,
-          summary: `${request.subagentName} requests ${request.toolName}`,
-          input: request.input,
-        });
-      }
-      void this.broadcastApprovals().catch((error) => {
-        this.temporaryAgentApprovals.delete(request.executionId);
-        reject(error);
-      });
-    });
-  }
-
-  /**
-   * 取消一条仍在等待的临时 Agent 审批。
-   *
-   * @remarks
-   * Temporary Agent Host 在子执行停止或超时时调用。
-   *
-   * 先从内存表删除再解决 Promise，避免并发的批准请求再次命中已取消项。
-   */
-  async cancelTemporaryAgentApproval(
-    executionId: string,
-    reason = "temporary agent was cancelled",
-  ): Promise<{ ok: boolean }> {
-    const pending = this.temporaryAgentApprovals.get(executionId);
-    if (!pending) return { ok: false };
-    this.temporaryAgentApprovals.delete(executionId);
-    pending.resolve({ approved: false, reason });
-    if (pending.submissionId) {
-      this.telemetry.capture("approvalDecided", {
-        submissionId: pending.submissionId!,
-        toolCallId: pending.toolCallId,
-        executionId,
-        decision: "cancelled",
-        reason,
-      });
-    }
-    await this.broadcastApprovals();
-    return { ok: true };
-  }
-
-  // 作用：返回已生效的 Runtime Snapshot。
-  // 调用：所有需要模型、工作区、扩展或投影绑定的运行时路径调用。
-  // 原因：未初始化时立即失败，比在深层路径触发空值更容易定位。
-  private assembly(): RuntimeSnapshot {
-    if (!this.activeRuntime) {
-      throw new Error(
-        "Runtime must be assembled before use",
-      );
-    }
-    return this.activeRuntime.snapshot;
-  }
-
-  private async normalizeUIUserInput(
-    message: UIMessage & { role: "user" },
-  ): Promise<PiCanonicalUserInput> {
-    const capabilities = requestedCapabilitiesOf(message.metadata);
-    if (capabilities.length === 0) return this.pi.normalizeUserInput(message);
-
-    await this.ensureRuntimeReady();
-    const installedSkills = new Set(
-      this.assembly().bindings.skills.sources.map(({ name }) => name),
-    );
-    const context: string[] = [];
-    for (const capability of capabilities) {
-      if (capability.kind === "skill") {
-        if (!installedSkills.has(capability.name)) {
-          throw new Error(
-            `Requested Skill is not installed: ${capability.name}`,
-          );
-        }
-        context.push(
-          `requested capability: skill/${capability.name}`,
-          `required action: call activate_skill for "${capability.name}" before handling the task`,
-        );
-        continue;
-      }
-      if (capability.kind === "tool") {
-        if (!this.pi.hasTool(this.preparedPi(), capability.name)) {
-          throw new Error(`Requested Tool is not installed: ${capability.name}`);
-        }
-        context.push(
-          `requested capability: tool/${capability.name}`,
-          `required action: call tool "${capability.name}" when handling the task`,
-        );
-        continue;
-      }
-      if (capability.name !== "plan") {
-        throw new Error(`Unknown plan capability: ${capability.name}`);
-      }
-      context.push(
-        "requested capability: plan/plan",
-        "required action: call update_plan with the complete plan before other work, then wait for user confirmation before execution",
-      );
-    }
-    return this.pi.normalizeUserInput(message, context.join("\n"));
-  }
-
-  // 作用：把当前已安装的 Runtime Snapshot 投影成可序列化的调试视图。
-  // 调用：Session facet 的 `getRuntimeAssembly` RPC。
-  // 原因：UI 需要读取真实装配结果，而不是上层配置声明。
-  protected readRuntimeAssembly(): RuntimeAssemblyView {
-    const runtime = this.activeRuntime;
-    if (!runtime) {
-      throw new Error("Runtime must be assembled before use");
-    }
-    return projectRuntimeAssembly(
-      runtime.snapshot,
-      runtime.revision,
-      runtime.pi,
-    );
-  }
-
-  // 作用：为 Runtime Extension 创建只包含授权能力的 Worker 回环绑定。
-  // 调用：Pi 准备扩展时，按每个扩展的权限和 Context label 调用。
-  // 原因：`ctx.exports` 是 Cloudflare 提供的 Worker 内回环入口，在边界上裁剪权限可避免扩展接触整个 Agent。
-  private createExtensionHostBinding(
-    permissions: RuntimeExtensionPermissions,
-    ownContextLabels: readonly string[],
-  ): Fetcher {
-    const exports = this.ctx.exports as unknown as {
-      HostBridgeLoopback(input: {
-        props: {
-          agentClassName: string;
-          agentId: string;
-          permissions: RuntimeExtensionPermissions;
-          ownContextLabels: string[];
-        };
-      }): Fetcher;
-    };
-    return exports.HostBridgeLoopback({
-      props: {
-        agentClassName: this.constructor.name,
-        agentId: this.ctx.id.toString(),
-        permissions,
-        ownContextLabels: [...ownContextLabels],
-      },
-    });
-  }
-
-  // 作用：计算一段描述文本的 SHA-256 十六进制指纹。
-  // 调用：配置激活、Submission 准入和恢复校验在比较 revision 时调用。
-  // 原因：只持久化稳定短指纹，即可验证完整描述没有在 Turn 中途改变。
-  private async hash(value: string): Promise<string> {
-    const digest = await crypto.subtle.digest(
-      "SHA-256",
-      new TextEncoder().encode(value),
-    );
-    return [...new Uint8Array(digest)]
-      .map((byte) => byte.toString(16).padStart(2, "0"))
-      .join("");
-  }
-
-  // 作用：返回当前已准备好的 Pi Runtime。
-  // 调用：创建 Turn 适配器或准入固定装配时调用。
-  // 原因：明确区分“已有 Snapshot”和“Pi 已完成准备”，防止半初始化状态进入 Turn。
-  /**
-   * 正在被换装配中断、等待持久续跑接手的 Submission。
-   *
-   * 中断和取消在执行路径上长得一模一样（都是 abort），但结局相反：取消要写终态，
-   * 换装配中断必须让 Submission 停在 running，等决策把它交给续跑。这个集合是
-   * 两者唯一的区分依据，只在一次 `repinParkedSubmissions` 的窗口内有成员。
-   *
-   * 写成惰性访问器而不是字段：本类有测试用 `Object.create(prototype)` 造替身，
-   * 那条路径不跑字段初始化器。
-   */
-  private get migratedSubmissions(): Set<string> {
-    return this.migratedSubmissionIds ??= new Set<string>();
-  }
-
-  private preparedPi(): PreparedPiRuntime {
-    if (!this.activeRuntime) {
-      throw new Error(
-        "SpringBrand Runtime must be prepared before starting a Turn",
-      );
-    }
-    return this.activeRuntime.pi;
-  }
-
-  // #endregion
-
-  // #region Submission 准入与配置固定
-
-  // 作用：为新 Submission 生成包含当前 Context 的不可变装配描述。
-  // 调用：Submission 通过去重和忙碌检查后，在真正写入前调用。
-  // 原因：把动态 Context 和执行档位固定在准入时，恢复时才能按原配置继续。
-  private async admissionPin(fresh: boolean, submissionId: string): Promise<{
-    revision: string;
-    descriptor: string;
-  }> {
-    if (fresh) await this.prepareRuntimeForSubmission(submissionId);
-    else await this.ensureRuntimeReady();
-    return this.currentAssemblyPin();
-  }
-
-  // 作用：按当前已装配的 Runtime 生成一份不可变装配描述。
-  // 调用：准入 pin 走 `admissionPin`；`initConfig` 内部的重新 pin 直接调用本方法。
-  // 原因：`initConfig` 已经在装配串行入口里面，再走 `ensureRuntimeReady` 会等自己，
-  // 所以「确保装配就绪」和「按当前装配取 pin」必须是两步。
-  private async currentAssemblyPin(): Promise<{
-    revision: string;
-    descriptor: string;
-  }> {
-    await this.drainRuntimeEvents();
-    const runtime = this.activeRuntime;
-    if (!runtime) {
-      throw new Error("Runtime revision is not initialized");
-    }
-    return this.pinAssembly(runtime.pi, runtime.revision);
-  }
-
-  private async pinAssembly(
-    prepared: PreparedPiRuntime,
-    baseRevision: string,
-  ): Promise<{ revision: string; descriptor: string }> {
-    const pinned = await this.pi.pin({
-      prepared,
-      baseRevision,
-      readExtensionContext: ({ label }) =>
-        this._hostGetContext(label),
-    });
-    if (pinned.degradations.length > 0) {
-      console.warn(
-        "[runtime-context:degraded]",
-        json({ degradations: pinned.degradations }),
-      );
-    }
-    return {
-      revision: await this.hash(pinned.descriptor),
-      descriptor: pinned.descriptor,
-    };
-  }
-
-  private async pinSubmissionAssembly(
-    submission: StoredSubmission,
-    mode: SubmissionExecutionMode,
-  ): Promise<StoredSubmission> {
-    if (submission.assemblyRevision && submission.assemblyDescriptor) {
-      return submission;
-    }
-    if (submission.assemblyRevision || submission.assemblyDescriptor) {
-      throw new Error("Submission assembly pin is incomplete");
-    }
-    const { revision, descriptor } = await this.admissionPin(mode === 'fresh', submission.submissionId);
-    this.db.submissions.pinAssembly(
-      submission.submissionId,
-      revision,
-      descriptor,
-    );
-    const pinned = this.readSubmission(submission.submissionId);
-    if (!pinned?.assemblyRevision || !pinned.assemblyDescriptor) {
-      throw new Error("Submission ended before Runtime assembly was pinned");
-    }
-    return pinned;
-  }
-
-  /** 准备 parked Submission 的续跑切换，持久 pin 只在最终 commit 中修改。 */
-  private async prepareParkedSubmissionRepin(
-    prepared: PreparedPiRuntime,
-    baseRevision: string,
-  ): Promise<{ commit(): void; interrupt(): Promise<void>; abort(): void }> {
-    await this.drainRuntimeEvents();
-    const { revision, descriptor } = await this.pinAssembly(
-      prepared,
-      baseRevision,
-    );
-    const plans: Array<{
-      submission: StoredSubmission;
-      decision: PiRecoveryDecision;
-    }> = [];
-    for (const submissionId of this.db.submissions.listUnfinishedIds()) {
-      const submission = this.readSubmission(submissionId);
-      if (
-        !submission?.assemblyRevision ||
-        !submission.assemblyDescriptor ||
-        submission.assemblyRevision === revision
-      ) {
-        continue;
-      }
-      const decision = this.decidePiRecovery(submission, {
-        kind: "repin-assembly",
-        nextAssemblyRevision: revision,
-      });
-      plans.push({ submission, decision });
-    }
-    let settled = false;
-    let committed = false;
-    const cleanup = () => {
-      for (const { submission } of plans) {
-        this.migratedSubmissions.delete(submission.submissionId);
-      }
-    };
-    return {
-      commit: () => {
-        if (settled) throw new Error("Parked Submission repin already settled");
-        for (const { submission } of plans) {
-          this.migratedSubmissions.add(submission.submissionId);
-        }
-        try {
-          this.db.transaction(() => {
-            for (const { submission, decision } of plans) {
-              this.applyPiRecoveryMutations(submission, decision.mutations);
-              this.db.submissions.repinAssembly(
-                submission.submissionId,
-                revision,
-                descriptor,
-              );
-            }
-          });
-          committed = true;
-        } catch (error) {
-          settled = true;
-          cleanup();
-          throw error;
-        }
-      },
-      interrupt: async () => {
-        if (!committed || settled) return;
-        try {
-          for (const { submission } of plans) {
-            const submissionId = submission.submissionId;
-            await this.submissions.interrupt(
-              submissionId,
-              () => this.approvals.discardWaiters(submissionId),
-            );
-          }
-        } finally {
-          settled = true;
-          cleanup();
-        }
-      },
-      abort: () => {
-        if (settled) return;
-        settled = true;
-        cleanup();
-      },
-    };
-  }
-
-  // 作用：检查 Submission 保存的装配描述与 revision 仍然匹配。
-  // 调用：普通恢复和审批续跑在重建 Pi Turn 前调用。
-  // 原因：若持久描述已变，继续执行会把同一 Turn 切成两套能力语义。
-  private async assertPinnedSubmission(
-    submission: StoredSubmission,
-  ): Promise<void> {
-    if (
-      submission.assemblyRevision !==
-      await this.hash(submission.assemblyDescriptor)
-    ) {
-      throw new Error(
-        "Pinned Runtime assembly descriptor is invalid",
-      );
-    }
-  }
-
-  // 作用：按当前模型输入预算压缩 Pi 上下文。
-  // 调用：Pi Turn 适配器在发模型请求前通过 `transformContext` 回调。
-  // 原因：模型窗口必须预留最大输出，压缩也必须使用本 Snapshot 的模型。
-  private async transformPiContext(
-    submissionId: string,
-    messages: Parameters<PiRuntimeTranscript["compactContext"]>[0],
-    signal?: AbortSignal,
-  ): ReturnType<PiRuntimeTranscript["compactContext"]> {
-    const snapshot = this.assembly();
-    const inputBudget = snapshot.pi.model.contextWindow -
-      snapshot.pi.model.maxTokens;
-    const force = this.readSubmission(submissionId)?.recoveryReason ===
-      "context_overflow";
-    const compacted = await this.transcript.compactContext(messages, {
-      compactAfterTokens: inputBudget * 0.85,
-      force,
-      model: snapshot.pi.model,
-      signal,
-      submissionId,
-      onCompactionUsage: (event, didCompact) => {
-        this.db.runtimeEvents.insert({
-          eventId: event.eventId,
-          body: json({
-            type: "model-usage",
-            event: {
-              ...event,
-              runId: submissionId,
-            },
-          }),
-          createdAt: Date.now(),
-        });
-        if (didCompact) this.telemetry.capture("contextCompacted", {
-          submissionId,
-          compactionId: event.eventId,
-          inputTokens: event.usage.input,
-          outputTokens: event.usage.output,
-        });
-      },
-    });
-    if (force) this.db.submissions.clearRecoveryReason(submissionId);
-    await this.drainRuntimeEvents();
-    return compacted;
-  }
-
-  // 作用：按 Submission ID 读取一条 Runtime 提交记录。
-  // 调用：执行、恢复、审批和终态路径需要当前持久状态时调用。
-  // 原因：在 Kernel 边界统一收窄为 `StoredSubmission`，避免上层分散重复转型。
-  private readSubmission(
-    submissionId: string,
-  ): StoredSubmission | null {
-    return this.db.submissions.find(submissionId) as StoredSubmission | null;
-  }
-
-  // 作用：按客户端 request ID 找到对应 Submission。
-  // 调用：聊天取消、恢复分类和提交去重时调用。
-  // 原因：request ID 是传输层身份，在此集中完成它到领域 Submission 的映射。
-  private findSubmissionByRequest(
-    requestId: string,
-  ): StoredSubmission | null {
-    return this.db.submissions.findByRequestId(requestId) as StoredSubmission | null;
-  }
-
-  // 作用：按业务幂等键找到已接收的 Submission。
-  // 调用：SubmissionLifecycle 在新提交准入前调用。
-  // 原因：去重必须查持久层，只看内存无法覆盖 Durable Object 重启。
-  private findSubmissionByKey(
-    idempotencyKey: string,
-  ): StoredSubmission | null {
-    return this.db.submissions.findByIdempotencyKey(idempotencyKey) as StoredSubmission | null;
-  }
-
-  // 作用：组装一个可由 SubmissionLifecycle 原子准入的用户消息。
-  // 调用：即时提交和等待稳定的定时提交共用。
-  // 原因：延迟真正写入到事务内，可让去重、忙碌检查、revision 固定和 transcript 更新一起成功或失败。
-  private submissionInput(
-    userMessage: PiCanonicalUserInput,
-    options: SubmitMessageOptions,
-  ): SubmissionInput<StoredSubmission> {
-    return {
-      requestId: options.requestId,
-      ...(options.idempotencyKey
-        ? { idempotencyKey: options.idempotencyKey }
-        : {}),
-      prepareAdmission: async () => {
-        await this.ensureRuntimeReady();
-        const regenerateEntry =
-          options.regenerate && options.userMessageId
-            ? await this.transcript.findUserMessage(options.userMessageId)
-            : undefined;
-        if (
-          options.regenerate &&
-          (!regenerateEntry ||
-            userContentKey(regenerateEntry) !== userContentKey(userMessage))
-        ) {
-          throw new Error(
-            "Regenerate request must match an existing user message",
-          );
-        }
-        const hook = this.activeRuntime?.admission;
-        let existing: StoredSubmissionAdmission | null = null;
-        if (hook) {
-          const attemptedAt = Date.now();
-          const reservedRunId = crypto.randomUUID();
-          this.db.transaction(() => {
-            const current = this.db.submissionAdmissions.find(
-              options.requestId,
-              options.idempotencyKey,
-            );
-            if (current) {
-              // 同一 identity 重投：沿用已固定的 runId，只把这次尝试的时间推到现在，
-              // 使它重新占住一个在途名额。
-              if (current.status === "pending") {
-                this.db.submissionAdmissions.recordAttempt(
-                  current.requestId,
-                  attemptedAt,
-                );
-              }
-              return;
-            }
-            if (
-              this.db.submissions.countPending() +
-                  this.db.submissionAdmissions.countPending(
-                    attemptedAt - ADMISSION_ATTEMPT_WINDOW_MS,
-                  ) >=
-                MAX_PENDING_SUBMISSIONS
-            ) {
-              throw new SubmissionQueueFullError();
-            }
-            this.db.submissionAdmissions.begin(
-              options.requestId,
-              options.idempotencyKey ?? null,
-              reservedRunId,
-              attemptedAt,
-            );
-          });
-          existing = this.db.submissionAdmissions.find(
-            options.requestId,
-            options.idempotencyKey,
-          );
-        }
-        const runId = existing?.runId ?? crypto.randomUUID();
-        const admissionRequestId = existing?.requestId ?? options.requestId;
-        const admissionIdempotencyKey = existing
-          ? existing.idempotencyKey ?? undefined
-          : options.idempotencyKey;
-        const admissionKey = admissionIdempotencyKey
-          ? `idempotency:${admissionIdempotencyKey}`
-          : `request:${admissionRequestId}`;
-        const pendingAdmission = hook && existing?.status === "pending"
-          ? this.admissionsInFlight.get(admissionKey)
-          : undefined;
-        const admissionPromise = pendingAdmission ?? (hook && (!existing || existing.status === "pending")
-          ? hook({
-              requestId: admissionRequestId,
-              ...(admissionIdempotencyKey
-                ? { idempotencyKey: admissionIdempotencyKey }
-                : {}),
-              runId,
-            }).then(validateAdmissionResult).catch((error) => {
-              this.admissionsInFlight.delete(admissionKey);
-              throw error;
-            })
-          : undefined);
-        if (hook && admissionPromise && !pendingAdmission) {
-          this.admissionsInFlight.set(
-            admissionKey,
-            admissionPromise,
-          );
-        }
-        let admission = existing?.status === "accepted"
-          ? {
-              accepted: true as const,
-            }
-          : existing?.status === "rejected"
-            ? {
-                accepted: false as const,
-                code: existing.code ?? "admission_rejected",
-                retryable: existing.retryable ?? false,
-              }
-            : admissionPromise
-              ? await admissionPromise
-              : undefined;
-        return () => {
-          if (admission && !admission.accepted) {
-            this.db.submissionAdmissions.saveRejected(
-              admissionRequestId,
-              runId,
-              admission.code,
-              admission.retryable ?? false,
-            );
-            const rejected = this.insertSkippedSubmission({
-              submissionId: runId,
-              requestId: admissionRequestId,
-              idempotencyKey: admissionIdempotencyKey ?? null,
-              createdAt: userMessage.timestamp,
-              code: admission.code,
-              retryable: admission.retryable ?? false,
-            });
-            this.admissionsInFlight.delete(admissionKey);
-            return {
-              ...rejected,
-              admissionRejected: true,
-            };
-          }
-          const submissionId = runId;
-          const assistantMessageId = crypto.randomUUID();
-          const createdAt = userMessage.timestamp;
-          const userMessageId =
-            options.userMessageId ?? crypto.randomUUID();
-          if (admission?.accepted) {
-            this.db.submissionAdmissions.saveAccepted(
-              admissionRequestId,
-              runId,
-            );
-          }
-          this.db.submissions.insert({
-            submissionId,
-            requestId: admissionRequestId,
-            idempotencyKey: admissionIdempotencyKey ?? null,
-            createdAt,
-            assemblyRevision: "",
-            assemblyDescriptor: "",
-            assistantMessageId,
-            queuedInputJson: json(userMessage),
-            queuedUiMessageJson: options.userMessage
-              ? json(options.userMessage)
-              : null,
-            userMessageId,
-            regenerateMessageId: options.regenerate
-              ? options.userMessageId ?? null
-              : null,
-            runId,
-          });
-          if (admission?.accepted) {
-            const fact: RuntimeLifecycleFact = {
-              kind: "submission-admitted",
-              eventId: `${submissionId}:admitted`,
-              submissionId,
-              runId: submissionId,
-            };
-            this.db.runtimeEvents.insert({
-              eventId: fact.eventId,
-              body: json({ type: "lifecycle", event: fact }),
-              createdAt,
-            });
-          }
-          this.telemetry.capture("turnAdmitted", {
-            submissionId,
-            requestId: admissionRequestId,
-            ...(admissionIdempotencyKey
-              ? { idempotencyKey: admissionIdempotencyKey }
-              : {}),
-            occurredAt: createdAt,
-          });
-          if (hook) this.admissionsInFlight.delete(admissionKey);
-          return this.readSubmission(submissionId)!;
-        };
-      },
-    };
-  }
-
-  // 作用：立即尝试准入一条用户消息并返回执行句柄。
-  // 调用：WebSocket 聊天、RPC prompt 和其他同步入口在收到消息时调用。
-  // 原因：所有即时入口收口到同一 SubmissionLifecycle，才会共享去重和单 Turn 约束。
-  private submitMessage(
-    userMessage: PiCanonicalUserInput,
-    options: SubmitMessageOptions,
-  ): Promise<SubmissionHandle<StoredSubmission>> {
-    return this.submitMessageAndBroadcast(userMessage, options);
-  }
-
-  private async submitMessageAndBroadcast(
-    userMessage: PiCanonicalUserInput,
-    options: SubmitMessageOptions,
-  ): Promise<SubmissionHandle<StoredSubmission>> {
-    const submitted = await this.submissions.submit(
-      this.submissionInput(userMessage, options),
-    );
-    this.ctx.waitUntil(this.drainRuntimeEvents());
-    await this.broadcastApprovals();
-    return submitted;
-  }
-
-  // 作用：等待 Runtime 稳定后再准入一条用户消息。
-  // 调用：定时任务在不应打断正在运行的 Turn 时调用。
-  // 原因：有界等待比无限排队更适合定时任务，超时可返回明确的 skipped 回执。
-  private async submitMessageWhenStable(
-    userMessage: PiCanonicalUserInput,
-    options: SubmitMessageOptions,
-    timeoutMs: number,
-  ): Promise<SubmissionHandle<StoredSubmission> | null> {
-    const submitted = await this.submissions.submitWhenStable(
-      this.submissionInput(userMessage, options),
-      timeoutMs,
-    );
-    if (submitted) {
-      await this.drainRuntimeEvents();
-      await this.broadcastApprovals();
-    }
-    return submitted;
-  }
-
-  // #endregion
-
-  // #region 持久化、恢复与终态提交
-
-  // 作用：更新 Submission 状态并返回数据库中的最新记录。
-  // 调用：终态提交在决定 completed、aborted 或 error 后调用。
-  // 原因：完成时间只能跟终态一起写入，然后必须回读以防止返回过期对象。
-  private updateSubmission(
-    submissionId: string,
-    status: SubmissionStatus,
-    error?: string,
-  ): StoredSubmission {
-    const completedAt = isTerminalSubmissionStatus(status) ? Date.now() : null;
-    this.db.submissions.updateTerminal(
-      submissionId,
-      status,
-      error,
-      completedAt ?? undefined,
-    );
-    const submission = this.readSubmission(submissionId);
-    if (!submission) {
-      throw new Error(`Unknown SpringBrand submission: ${submissionId}`);
-    }
-    return submission;
-  }
-
-  private insertSubmissionTerminalFact(submission: StoredSubmission): void {
-    const terminalFact: RuntimeLifecycleFact = {
-      kind: "submission-terminal",
-      eventId: `${submission.submissionId}:terminal`,
-      submissionId: submission.submissionId,
-      runId: submission.runId ?? submission.submissionId,
-      status: submission.status as "completed" | "aborted" | "skipped" | "error",
-      childRegistrationClosed: true,
-      zeroUsage: !this.db.runtimeEvents.hasNonZeroModelUsage(
-        submission.submissionId,
-      ),
-    };
-    this.db.runtimeEvents.insert({
-      eventId: terminalFact.eventId,
-      body: json({ type: "lifecycle", event: terminalFact }),
-      createdAt: submission.completedAt ?? Date.now(),
-    });
-  }
-
-  private insertSkippedSubmission(input: {
-    submissionId: string;
-    requestId: string;
-    idempotencyKey: string | null;
-    createdAt: number;
-    code: string;
-    retryable: boolean;
-  }): StoredSubmission {
-    this.db.submissions.insertRejected(input);
-    const skipped = this.readSubmission(input.submissionId)!;
-    this.insertSubmissionTerminalFact(skipped);
-    return skipped;
-  }
-
-  // 作用：读取某个 Submission 已持久的全部 Pi 恢复里程碑。
-  // 调用：恢复决策器每次检查或应用命令前调用。
-  // 原因：决策只依赖持久事实，重启后才会得到同样结果。
-  private recoveryMilestoneBodies(submissionId: string): string[] {
-    return this.db.milestones.listBodies(submissionId);
-  }
-
-  // 作用：让 Pi 根据已持久里程碑决定下一个恢复动作。
-  // 调用：Tool 输入与结果、审批、终态和唤醒恢复路径调用。
-  // 原因：决策集中在 Pi 状态机，Kernel 只提供身份和事实，避免两份恢复规则漂移。
-  private decidePiRecovery(
-    submission: StoredSubmission,
-    command: PiRecoveryCommand = { kind: "inspect" },
-    now = Date.now(),
-  ): PiRecoveryDecision {
-    return this.pi.decideRecovery({
-      milestoneBodies: this.recoveryMilestoneBodies(
-        submission.submissionId,
-      ),
-      identity: {
-        turnId: submission.submissionId,
-        assemblyRevision: submission.assemblyRevision,
-      },
-      command,
-      now,
-    });
-  }
-
-  private recordPiToolMilestone(
-    submission: StoredSubmission,
-    command: Extract<PiRecoveryCommand, {
-      kind: "record-tool-input" | "record-tool-result";
-    }>,
-  ): readonly PiDurableMutation[] {
-    const key = command.kind === "record-tool-input"
-      ? `tool-input:${command.record.toolCallId}`
-      : `tool-result:${command.toolCallId}`;
-    const body = this.db.milestones.findBody(submission.submissionId, key);
-    return this.pi.recordToolMilestone({
-      milestoneBodies: body === null ? [] : [body],
-      identity: {
-        turnId: submission.submissionId,
-        assemblyRevision: submission.assemblyRevision,
-      },
-      command,
-      now: Date.now(),
-    });
-  }
-
-  // 作用：把 Pi 恢复决策产生的变更写入 Runtime 数据库。
-  // 调用：记录 Tool、终态、审批或恢复步骤时，通常在事务内调用。
-  // 原因：upsert 保证重放幂等，而 terminal intent 允许后来的更强结果更新早期意图。
-  private applyPiRecoveryMutations(
-    submission: StoredSubmission,
-    mutations: readonly PiDurableMutation[],
-  ): boolean {
-    let appended = false;
-    for (const mutation of mutations) {
-      if (mutation.kind === "decide-approval") {
-        this.db.approvals.decide(
-          mutation.executionId,
-          mutation.status as any,
-          mutation.decidedAt,
-          mutation.reason,
-        );
-        continue;
-      }
-      if (mutation.kind === "record-interaction") {
-        this.db.interactions.insert({
-          interactionId: mutation.interaction.interactionId,
-          submissionId: submission.submissionId,
-          requestId: mutation.interaction.requestId,
-          toolCallId: mutation.interaction.toolCallId,
-          toolName: mutation.interaction.toolName,
-          inputJson: mutation.interaction.inputJson,
-          status: "pending",
-          createdAt: mutation.interaction.createdAt,
-        });
-        continue;
-      }
-      if (mutation.kind === "settle-interaction") {
-        this.db.interactions.settle(
-          mutation.interactionId,
-          mutation.status,
-          mutation.settledAt,
-          mutation.responseJson,
-        );
-        continue;
-      }
-      const inserted = this.db.milestones.upsert(
-        submission.submissionId,
-        mutation.key,
-        mutation.body,
-      );
-      appended ||= inserted;
-      if (!inserted && mutation.key === "terminal:intent") {
-        this.db.milestones.updateTerminalIntent(
-          submission.submissionId,
-          mutation.body,
-        );
-      }
-    }
-    return appended;
-  }
-
-  // 作用：在 Tool 执行前持久记录它的名称和输入。
-  // 调用：Pi Turn 适配器通过 durability 回调在每个 Tool 开始时调用。
-  // 原因：先留下 durable intent，中断后才能区分“未执行”和“结果不确定”。
-  private appendToolInput(
-    submission: StoredSubmission,
-    input: PiToolInputRecord,
-  ): boolean {
-    const appended = this.db.transaction(() => {
-      const mutations = this.recordPiToolMilestone(submission, {
-        kind: "record-tool-input",
-        record: input,
-      });
-      const inserted = this.applyPiRecoveryMutations(submission, mutations);
-      if (inserted) {
-        this.telemetry.capture("toolStarted", {
-          submissionId: submission.submissionId,
-          toolCallId: input.toolCallId,
-          toolName: input.toolName,
-          input: input.input,
-        });
-      }
-      return inserted;
-    });
-    if (appended) this.announceToolStart(submission.submissionId, input);
-    return appended;
-  }
-
-  // 作用：把「这个 Tool 开始跑了」连同参数投给 Host。
-  // 调用：durable intent 第一次落库之后，Tool 真正执行之前。
-  // 原因：人在等的是「正在写一个网页」，不是三十秒后的「write 完成了」。
-  //
-  // 只在第一次落库时发：恢复重放会再走一遍这条路径，那时 Tool 可能早就结束了，
-  // 再宣布一次「开始」比不宣布更糟。也不进 durable outbox —— 这是活性信号，
-  // 补投一条迟到的开始事件没有意义，投失败就算了，终态有 onToolSettled 兜底。
-  private announceToolStart(
-    submissionId: string,
-    input: PiToolInputRecord,
-  ): void {
-    const turnEvents = this.turnEventsPort();
-    if (!turnEvents?.onToolStart) return;
-    const delivery = turnEvents.onToolStart({
-      submissionId,
-      toolCallId: input.toolCallId,
-      toolName: input.toolName,
-      args: input.input,
-    }).catch((error: unknown) => {
-      console.warn(
-        "[runtime-tool-start:degraded]",
-        json({ toolCallId: input.toolCallId, error: errorText(error) }),
-      );
-    });
-    this.ctx.waitUntil(delivery);
-  }
-
-  // 作用：持久化一次 Tool 结果，并推进相应的恢复里程碑。
-  // 调用：正常 Tool 执行和恢复 Tool 结果落地时调用。
-  // 原因：同一 `toolCallId` 只允许内容完全相同的重放，冲突结果必须立即失败以保护恢复确定性。
-  private settleTool(
-    submissionId: string,
-    call: PiToolSettlement & { readonly createdAt?: number },
-  ): Promise<void> {
-    this.db.transaction(() => this.settleToolSync(submissionId, call));
-    return this.drainRuntimeEvents();
-  }
-
-  private projectNestedToolSettlement(
-    submissionId: string,
-    event: Readonly<{
-      toolCallId: string;
-      toolName: string;
-      outcome: "completed" | "failed" | "cancelled";
-      occurredAt: number;
-    }>,
-  ): void {
-    const settlement: RuntimeToolSettlementEvent = {
-      eventId: `${submissionId}:tool:${event.toolCallId}`,
-      submissionId,
-      toolCallId: event.toolCallId,
-      toolName: event.toolName,
-      status: event.outcome === "completed" ? "success" : "error",
-    };
-    this.db.transaction(() => {
-      this.db.runtimeEvents.insert({
-        eventId: settlement.eventId,
-        body: json({ type: "tool-settlement", event: settlement }),
-        createdAt: event.occurredAt,
-      });
-    });
-    this.ctx.waitUntil(this.drainRuntimeEvents());
-  }
-
-  // 终态事务用这个同步内核先补齐 ToolResult，再在同一事务末尾写 marker。
-  private settleToolSync(
-    submissionId: string,
-    call: PiToolSettlement & { readonly createdAt?: number },
-  ): void {
-    const submission = this.readSubmission(submissionId);
-    if (!submission) {
-      throw new Error(`Unknown SpringBrand submission: ${submissionId}`);
-    }
-    const existing = this.db.settlements.find(submissionId, call.toolCallId);
-    const args = json(call.args);
-    const result = json(call.result);
-    const createdAt = existing?.createdAt ?? call.createdAt ?? Date.now();
-    if (existing) {
-      if (
-        existing.toolName !== call.toolName ||
-        existing.args !== args ||
-        existing.result !== result ||
-        existing.isError !== call.isError
-      ) {
-        throw new Error(
-          `Conflicting durable Tool settlement: ${call.toolCallId}`,
-        );
-      }
-    } else {
-      this.db.settlements.insert({
-        toolCallId: call.toolCallId,
-        submissionId,
-        toolName: call.toolName,
-        args,
-        result,
-        isError: call.isError,
-        createdAt,
-      });
-      const event: RuntimeToolSettlementEvent = {
-        eventId: `${submissionId}:tool:${call.toolCallId}`,
-        submissionId,
-        toolCallId: call.toolCallId,
-        toolName: call.toolName,
-        status: call.isError ? "error" : "success",
-      };
-      this.db.runtimeEvents.insert({
-        eventId: event.eventId,
-        body: json({ type: "tool-settlement", event }),
-        createdAt,
-      });
-      const details = call.result.details as {
-        kind?: string;
-        bytes?: number;
-      } | undefined;
-      this.telemetry.capture("toolFinished", {
-        submissionId,
-        toolCallId: call.toolCallId,
-        toolName: call.toolName,
-        outcome: call.isError ? "failed" : "completed",
-        outputBytes: details?.kind === "artifact_ref" &&
-            typeof details.bytes === "number"
-          ? details.bytes
-          : result.length,
-        spilled: details?.kind === "artifact_ref",
-        output: call.result,
-        ...(call.isError && call.cause
-          ? { error: errorText(call.cause) }
-          : {}),
-        occurredAt: createdAt,
-      });
-    }
-    const mutations = this.recordPiToolMilestone(submission, {
-      kind: "record-tool-result",
-      toolCallId: call.toolCallId,
-      toolName: call.toolName,
-      result: call.result,
-      isError: call.isError,
-      timestamp: createdAt,
-      // The current execution is already continuing. After a crash, recovery
-      // materializes this result before resuming; no per-Tool dispatch is needed.
-      needsContinuation: false,
-    });
-    this.applyPiRecoveryMutations(submission, mutations);
-    this.approvals.commitContinuation(submission, call.toolCallId);
-  }
-
-  // 作用：按 Submission 和 Tool Call ID 读取已持久结果。
-  // 调用：Pi 执行去重、恢复物化和审批续跑在重做 Tool 前调用。
-  // 原因：只在边界解析 JSON，数据库仍保留可精确比较的原始文本。
-  private readToolSettlement(
-    submissionId: string,
-    toolCallId: string,
-  ): {
-    toolName: string;
-    args: unknown;
-    result: PiStoredToolSettlement["result"];
-    isError: boolean;
-    createdAt: number;
-  } | null {
-    const row = this.db.settlements.find(submissionId, toolCallId);
-    return row
-      ? {
-          toolName: row.toolName,
-          args: JSON.parse(row.args) as unknown,
-          result: JSON.parse(
-            row.result,
-          ) as PiStoredToolSettlement["result"],
-          isError: row.isError,
-          createdAt: row.createdAt,
-        }
-      : null;
-  }
-
-  // 作用：把恢复状态机已知的 Tool 结果补全到 settlement 和 transcript 投影。
-  // 调用：Turn 恢复、审批决定和终态收尾在继续前调用。
-  // 原因：恢复记录可能比浏览器 transcript 更新，先去重落库再按 canonical 顺序投影才不会丢失或重复 ToolResult。
-  private materializeRecoveredToolResultsSync(
-    submission: StoredSubmission,
-  ): PiRecoveryDecision {
-    let decision = this.decidePiRecovery(submission);
-    for (const settlement of decision.recoveredToolSettlements) {
-      const message = settlement.message;
-      if (
-        this.readToolSettlement(
-          submission.submissionId,
-          message.toolCallId,
-        )
-      ) {
-        continue;
-      }
-      this.settleToolSync(submission.submissionId, {
-        toolCallId: message.toolCallId,
-        toolName: message.toolName,
-        args: settlement.args,
-        result: {
-          content: message.content,
-          details: message.details,
-          ...(message.usage ? { usage: message.usage } : {}),
-          ...(message.addedToolNames?.length
-            ? { addedToolNames: message.addedToolNames }
-            : {}),
-        },
-        isError: message.isError,
-        createdAt: message.timestamp,
-      });
-      decision = this.decidePiRecovery(submission);
-    }
-    const results = this.transcript.orderRecoveredToolSettlements(
-      decision.recoveredToolSettlements,
-    );
-    for (const recovered of results) {
-      this.transcript.appendRecoveredToolSettlement(
-        submission.submissionId,
-        recovered,
-      );
-    }
-    return decision;
-  }
-
-  private async materializeRecoveredToolResults(
-    submission: StoredSubmission,
-  ): Promise<PiRecoveryDecision> {
-    const decision = this.db.transaction(() =>
-      this.materializeRecoveredToolResultsSync(submission)
-    );
-    await this.drainRuntimeEvents();
-    return decision;
-  }
-
-  // 作用：在改写 Submission 终态前持久化 Turn 的结束意图。
-  // 调用：模型终止回调、取消和最终提交都会调用。
-  // 原因：intent 早于状态行落地，即使两步之间中断，恢复也能重建权威结果。
-  private appendTerminalIntent(
-    submission: StoredSubmission,
-    outcome: "succeeded" | "failed" | "aborted",
-    message?: string,
-  ): void {
-    const decision = this.decidePiRecovery(submission, {
-      kind: "record-terminal",
-      phase: "intent",
-      outcome,
-      ...(message === undefined ? {} : { message }),
-    });
-    this.applyPiRecoveryMutations(submission, decision.mutations);
-    if (outcome === "aborted") {
-      this.telemetry.capture("turnCancelled", {
-        submissionId: submission.submissionId,
-        ...(message ? { reason: message } : {}),
-      });
-    }
-  }
-
-  // 作用：把 Turn 的权威结果一次提交到 Submission、恢复里程碑和聊天续传标记。
-  // 调用：SubmissionLifecycle 完成成功、失败或取消时调用。
-  // 原因：已持久的 abort 和 terminal intent 优先于调用方参数，可避免并发收尾覆盖更早的真实结果。
-  private async commitTerminalOutcome(
-    submission: StoredSubmission,
-    outcome: "succeeded" | "failed" | "aborted",
-    message?: string,
-  ): Promise<StoredSubmission> {
-    const latest = this.readSubmission(submission.submissionId);
-    if (!latest) {
-      throw new Error(
-        `Unknown SpringBrand submission: ${submission.submissionId}`,
-      );
-    }
-    if (isTerminalSubmissionStatus(latest.status)) return latest;
-
-    for (const steer of this.db.steers.listForSubmission(latest.submissionId)) {
-      const userMessage = JSON.parse(steer.canonicalJson) as PiCanonicalUserInput;
-      const uiMessage = steer.uiMessageJson
-        ? JSON.parse(steer.uiMessageJson) as UIMessage & { role: "user" }
-        : undefined;
-      const submitted = await this.submitMessage(userMessage, {
-        requestId: steer.messageId,
-        idempotencyKey: steer.messageId,
-        userMessageId: steer.messageId,
-        ...(uiMessage ? { userMessage: uiMessage } : {}),
-      });
-      this.ctx.waitUntil(submitted.completion);
-      this.db.transaction(() =>
-        this.db.steers.deleteByMessageId(steer.messageId)
-      );
-    }
-
-    const durableIntent = this.decidePiRecovery(latest).terminal;
-    const effectiveOutcome = latest.abortReason
-      ? "aborted"
-      : durableIntent?.outcome ?? outcome;
-    const effectiveMessage =
-      latest.abortReason ?? durableIntent?.message ?? message;
-    const turnOutput = (await this.transcript.storedMessages())
-      .filter((entry) =>
-        entry.submissionId === latest.submissionId &&
-        entry.message.role === "assistant"
-      )
-      .at(-1)?.message;
-    const terminal = this.db.transaction(() => {
-      this.appendTerminalIntent(
-        latest,
-        effectiveOutcome,
-        effectiveMessage,
-      );
-      const closedApprovals = this.approvals.rejectPending(
-        latest,
-        effectiveMessage ?? "Turn ended before approval",
-      );
-      // 还挂着的 interaction 同样要收尾，否则 Turn 结束后 pending 行会变成孤儿，
-      // 用户还能看见一张点了没反应的卡。
-      const closedInteractions = this.interactions
-        .cancelPendingForSubmissionSync(latest);
-      if (closedApprovals || closedInteractions) {
-        this.materializeRecoveredToolResultsSync(latest);
-      }
-      const status =
-        effectiveOutcome === "succeeded"
-          ? "completed"
-          : effectiveOutcome === "aborted"
-            ? "aborted"
-            : "error";
-      const terminal = this.updateSubmission(
-        latest.submissionId,
-        status,
-        effectiveMessage,
-      );
-      this.insertSubmissionTerminalFact(terminal);
-      if (
-        effectiveOutcome === "aborted" &&
-        effectiveMessage === USER_STOP_REASON
-      ) {
-        if (terminal.completedAt == null) {
-          throw new Error(
-            `Aborted SpringBrand submission has no completion time: ${latest.submissionId}`,
-          );
-        }
-        this.transcript.appendTurnAbortedMarker(
-          latest.submissionId,
-          terminal.completedAt,
-        );
-      }
-      const committed = this.decidePiRecovery(latest, {
-        kind: "record-terminal",
-        phase: "committed",
-        outcome: effectiveOutcome,
-        ...(effectiveMessage === undefined
-          ? {}
-          : { message: effectiveMessage }),
-      });
-      this.applyPiRecoveryMutations(
-        latest,
-        committed.mutations,
-      );
-      this.telemetry.capture("turnFinished", {
-        submissionId: latest.submissionId,
-        outcome: effectiveOutcome === "succeeded"
-          ? "completed"
-          : effectiveOutcome === "aborted"
-            ? "cancelled"
-            : "failed",
-        durationMs: Math.max(
-          0,
-          (terminal.completedAt ?? Date.now()) - latest.createdAt,
-        ),
-        ...(turnOutput === undefined ? {} : { output: turnOutput }),
-        ...(effectiveMessage ? { error: effectiveMessage } : {}),
-        occurredAt: terminal.completedAt ?? Date.now(),
-      });
-      return terminal;
-    });
-    await this.drainRuntimeEvents();
-    try {
-      await this.settleChatRecovery(
-        latest.requestId,
-        effectiveOutcome === "succeeded"
-          ? "completed"
-          : effectiveOutcome === "aborted"
-            ? "skipped"
-            : "failed",
-        effectiveMessage,
-      );
-    } catch (error) {
-      console.error("[chat-recovery] terminal settlement failed", error);
-    }
-    await this.broadcastApprovals();
-    try {
-      if (
-        effectiveOutcome === "failed" ||
-        (effectiveOutcome === "aborted" &&
-          effectiveMessage !== USER_STOP_REASON)
-      ) {
-        await recordChatTerminal(
-          this.ctx.storage,
-          latest.requestId,
-          effectiveMessage ?? "",
-        );
-      } else {
-        await clearChatTerminal(this.ctx.storage);
-      }
-    } catch (error) {
-      console.error("[pi-terminal] resume marker failed", error);
-    }
-    return terminal;
-  }
-
-  // 作用：按持久事实把一个中断 Turn 推进到可继续或已收尾状态。
-  // 调用：`executeNonTerminalSubmission` 以 recovery 模式重起 Pi Turn 前调用。
-  // 原因：用有界循环执行状态机效果，既允许 Tool 重试产生新事实，也防止错误规则无限自旋。
-  //
-  // 返回值必须区分「在等人」和「续不下去」：以前两者都压成 false，调用方一律原样返回
-  // 非终态记录，于是「续不下去」这一类会让 Submission 永久停在 running。
-  private async prepareRecoveredTurn(
-    submission: StoredSubmission,
-    adapter: PreparedPiTurnAdapter,
-  ): Promise<RecoveredTurnPreparation> {
-    let decision = await this.materializeRecoveredToolResults(submission);
-    for (let step = 0; step < 32; step += 1) {
-      const latest = this.readSubmission(submission.submissionId);
-      if (!latest || isTerminalSubmissionStatus(latest.status)) {
-        return { kind: "settled" };
-      }
-      if (latest.abortReason) {
-        await this.submissions.finish(
-          latest,
-          "aborted",
-          latest.abortReason,
-        );
-        return { kind: "settled" };
-      }
-      this.db.transaction(() => {
-        this.applyPiRecoveryMutations(
-          submission,
-          decision.mutations,
-        );
-      });
-      switch (decision.effect.kind) {
-        case "wait":
-          // 这里必须逐个 reason 判，不能按「不是 approval 就算续不下去」一刀切：
-          // - approval / interaction：等人，用户迟早会点。
-          // - complete：终态里程碑已提交，行状态同事务写入，上层的终态检查会收掉。
-          // - undefined：续跑里程碑已暂存待派发，`dispatchPendingContinuations`
-          //   会来接手 —— 判它失败等于杀掉一轮本来有人管的 Turn。
-          // - uncertain-tool：**没有任何人会来解开**。非幂等工具结果不确定，恢复
-          //   拒绝重放；停在这里就是永久挂死。
-          return decision.effect.reason === "uncertain-tool"
-            ? {
-                kind: "unresumable",
-                reason: unresumableWaitMessage(decision.effect.reason),
-              }
-            : { kind: "parked" };
-        case "retry-tool": {
-          try {
-            if (
-              !await adapter.retryTool({
-                toolName: decision.effect.toolName,
-                toolCallId: decision.effect.toolCallId,
-                input: decision.effect.input,
-              })
-            ) {
-              return {
-                kind: "unresumable",
-                reason:
-                  `SpringBrand could not resume this turn: Tool "${decision.effect.toolName}" is no longer available.`,
-              };
-            }
-          } catch {
-            // The governed Tool persisted its bounded error ToolResult.
-          }
-          decision = await this.materializeRecoveredToolResults(
-            submission,
-          );
-          continue;
-        }
-        case "schedule-continuation":
-          await this.approvals.dispatchContinuation(
-            submission,
-            decision.effect.approvalExecutionId,
-          );
-          return { kind: "parked" };
-        case "finish":
-          await this.submissions.finish(
-            submission,
-            decision.effect.outcome,
-            decision.effect.message,
-          );
-          return { kind: "settled" };
-        case "resume-turn": {
-          const last = (await this.transcript.canonicalMessages()).at(-1);
-          if (last?.role === "assistant" && last.stopReason === "toolUse") {
-            // Tool input 会在真正执行前持久化。恢复状态仍为 idle 证明这些
-            // canonical Tool Call 还没越过 attempt 边界，包括非幂等 Tool 也可以安全首次执行。
-            const unstartedCalls = last.content.filter((part) =>
-              part.type === "toolCall"
-            );
-            if (unstartedCalls.length > 0) {
-              for (const call of unstartedCalls) {
-                try {
-                  if (
-                    !await adapter.retryTool({
-                      toolName: call.name,
-                      toolCallId: call.id,
-                      input: call.arguments,
-                    })
-                  ) {
-                    return {
-                      kind: "unresumable",
-                      reason:
-                        `SpringBrand could not resume this turn: Tool "${call.name}" is no longer available.`,
-                    };
-                  }
-                } catch {
-                  // The governed Tool persisted its bounded error ToolResult.
-                }
-              }
-              decision = await this.materializeRecoveredToolResults(submission);
-              continue;
-            }
-          }
-          // Pi 的 agentLoopContinue 拒绝从 assistant 消息继续。悬空的尾部 assistant
-          // 意味着这条 transcript 续不下去了 —— 判断出来就必须收尾,不能默默退场。
-          return last?.role === "user" || last?.role === "toolResult"
-            ? { kind: "resume" }
-            : {
-                kind: "unresumable",
-                reason:
-                  "SpringBrand could not resume this turn: the transcript ends on an assistant message.",
-              };
-        }
-      }
-    }
-    throw new Error("SpringBrand recovery plan did not converge");
-  }
-
-  // #endregion
-
-  // #region Turn 执行、流式记录与完成投影
-
-  private async activateQueuedSubmission(
-    submission: StoredSubmission,
-  ): Promise<StoredSubmission> {
-    if (!submission.queuedInputJson) {
-      const started = this.db.submissions.transition(
-        submission.submissionId,
-        "running",
-        ["pending"],
-      );
-      const activated = this.readSubmission(submission.submissionId)!;
-      if (started) {
-        this.telemetry.capture("turnStarted", {
-          submissionId: activated.submissionId,
-          assemblyRevision: activated.assemblyRevision,
-        });
-      }
-      await this.broadcastApprovals();
-      return activated;
-    }
-
-    const userMessage = JSON.parse(
-      submission.queuedInputJson,
-    ) as PiCanonicalUserInput;
-    if (
-      userMessage?.role !== "user" ||
-      typeof userMessage.timestamp !== "number" ||
-      !submission.userMessageId
-    ) {
-      throw new Error("Queued SpringBrand user message is invalid");
-    }
-    const uiMessage = submission.queuedUiMessageJson
-      ? JSON.parse(submission.queuedUiMessageJson) as UIMessage & {
-          role: "user";
-        }
-      : undefined;
-    if (uiMessage && uiMessage.role !== "user") {
-      throw new Error("Queued UI user message is invalid");
-    }
-    if (submission.regenerateMessageId) {
-      const regenerateEntry = await this.transcript.findUserMessage(
-        submission.regenerateMessageId,
-      );
-      if (
-        !regenerateEntry ||
-        userContentKey(regenerateEntry) !== userContentKey(userMessage)
-      ) {
-        throw new Error(
-          "Regenerate request must match an existing user message",
-        );
-      }
-    }
-
-    const activated = this.db.transaction(() => {
-      const latest = this.readSubmission(submission.submissionId);
-      if (!latest || latest.status !== "pending") {
-        if (!latest) {
-          throw new Error(
-            `Unknown SpringBrand submission: ${submission.submissionId}`,
-          );
-        }
-        return latest;
-      }
-      const running = this.db.submissions.findRunning();
-      if (running) {
-        throw new Error(
-          `SpringBrand submission ${running.submissionId} is already running`,
-        );
-      }
-      if (submission.regenerateMessageId) {
-        this.transcript.moveLeaf(submission.regenerateMessageId);
-      } else {
-        const appended = this.transcript.append(
-          submission.userMessageId!,
-          userMessage,
-          {
-            submissionId: submission.submissionId,
-            ...(uiMessage ? { userMessage: uiMessage } : {}),
-          },
-        );
-        if (!appended) {
-          throw new Error(
-            `SpringBrand Session message ${submission.userMessageId} already exists`,
-          );
-        }
-      }
-      if (!this.db.submissions.transition(
-        submission.submissionId,
-        "running",
-        ["pending"],
-      )) {
-        throw new Error(
-          `SpringBrand submission ${submission.submissionId} could not activate`,
-        );
-      }
-      this.db.submissions.clearQueuedPayload(
-        submission.submissionId,
-      );
-      const started = this.readSubmission(submission.submissionId)!;
-      this.telemetry.capture("turnStarted", {
-        submissionId: started.submissionId,
-        assemblyRevision: started.assemblyRevision,
-        input: userMessage,
-      });
-      return started;
-    });
-    this.broadcast(json({
-      type: MessageType.CF_AGENT_CHAT_MESSAGES,
-      messages: await this.getMessages(),
-    }));
-    await this.broadcastApprovals();
-    return activated;
-  }
-
-  // 作用：执行一条 Submission，并保证任何异常都被收口为持久终态。
-  // 调用：SubmissionLifecycle 启动新提交或恢复未完提交时调用。
-  // 原因：把失败帧、可续传流和 pre-stream 清理放在最外层，避免内部分支遗留半开传输状态。
-  private async executeSubmission(
-    submissionId: string,
-    mode: SubmissionExecutionMode = "fresh",
-  ): Promise<StoredSubmission> {
-    const submission = this.readSubmission(submissionId);
-    if (!submission) {
-      throw new Error(`Unknown SpringBrand submission: ${submissionId}`);
-    }
-    if (isTerminalSubmissionStatus(submission.status)) {
-      return submission;
-    }
-    if (submission.abortReason) {
-      return this.submissions.finish(
-        submission,
-        "aborted",
-        submission.abortReason,
-      );
-    }
-    if (mode === "recovery") {
-      // 只有真中断才记恢复事实。计划让步也走这里的话,每个执行片都会伪造一条
-      // `runtime_restart`,并且抹掉真实的 stall 原因 —— 真崩溃和主动让出在观测上就分不开了。
-      this.telemetry.capture("turnRecovering", {
-        submissionId,
-        reason: submission.recoveryReason ?? "runtime_restart",
-        attempt: Math.max(1, submission.recoveryErrorCount),
-      });
-      if (submission.recoveryReason !== "context_overflow") {
-        this.db.submissions.clearRecoveryReason(submissionId);
-      }
-      await this.broadcastApprovals();
-    }
-    if (mode !== "fresh") await this.ensureRuntimeReady();
-    try {
-      return await this.executeNonTerminalSubmission(
-        submission,
-        mode,
-      );
-    } catch (error) {
-      if (
-        mode === "recovery" &&
-        (error instanceof ChatStreamStalledError ||
-          error instanceof RetryableModelError)
-      ) {
-        throw error;
-      }
-      const failed = await this.submissions.finish(
-        submission,
-        "failed",
-        errorText(error),
-      );
-      const streamId =
-        this.streamBySubmission.get(submission.submissionId);
-      if (streamId) {
-        this.failRecoverableStream(streamId);
-      }
-      this.sendChatTerminal(
-        submission.requestId,
-        failed.status === "error"
-          ? failed.error ?? "SpringBrand turn failed"
-          : undefined,
-        mode !== "fresh",
-      );
-      return failed;
-    } finally {
-      const streamId =
-        this.streamBySubmission.get(submission.submissionId);
-      if (streamId) {
-        this.streamBySubmission.delete(submission.submissionId);
-      }
-      this.settlePreStream(submission.requestId);
-    }
-  }
-
-  // 作用：运行一条未结束 Submission 的完整 Pi Turn。
-  // 调用：外层 `executeSubmission` 确认记录存在且未终态后调用。
-  // 原因：恢复补全、状态迁移、fiber、流式记录与终态投影必须保持固定顺序，否则唤醒后会重复执行或丢失回答。
-  private async executeNonTerminalSubmission(
-    submission: StoredSubmission,
-    mode: SubmissionExecutionMode,
-  ): Promise<StoredSubmission> {
-    // 续跑和恢复一样要给客户端打 continuation 标记(否则前端会另起一个空累加器,
-    // 把已经渲染出来的半条回答整条换掉),但只有恢复需要重建持久事实。
-    const continuation = mode !== "fresh";
-    const submissionId = submission.submissionId;
-    if (submission.abortReason) {
-      return this.submissions.finish(
-        submission,
-        "aborted",
-        submission.abortReason,
-      );
-    }
-    submission = await this.pinSubmissionAssembly(submission, mode);
-    await this.assertPinnedSubmission(submission);
-    if (submission.status === "pending" && mode === "fresh") {
-      submission = await this.activateQueuedSubmission(submission);
-    }
-    const recoveryAdapter = this.createSubmissionExecutionAdapter(submission);
-    let awaitingHumanInput = false;
-    // 让步续跑跳过整套里程碑重放:这一片是主动让出的,transcript 完好、没有半路的
-    // Tool 要重建。走恢复通道不只是白跑,重放成本还随让步次数增长 —— 第 N 片要
-    // 重放前 N-1 片积累的全部里程碑。但调度回调可能跨过等人的停靠期，所以下面仍需检查
-    // 恢复决策，不能把尾部 assistant Tool Use 直接交给 Pi 续跑。
-    if (mode === "recovery") {
-      const deactivatePreparation = this.submissions.activate(submission, {
-        submissionId,
-        requestId: submission.requestId,
-        messageId: submission.assistantMessageId,
-        startedAt: submission.createdAt,
-        continuation: true,
-        agent: recoveryAdapter,
-      });
-      let preparation: RecoveredTurnPreparation;
-      try {
-        preparation = await this.prepareRecoveredTurn(
-          submission,
-          recoveryAdapter,
-        );
-      } finally {
-        deactivatePreparation();
-      }
-      if (preparation.kind !== "resume") {
-        const latest = this.readSubmission(submissionId)!;
-        if (latest.abortReason) {
-          return this.submissions.finish(
-            latest,
-            "aborted",
-            latest.abortReason,
-          );
-        }
-        if (isTerminalSubmissionStatus(latest.status)) return latest;
-        // 非终态还想退场,只有「在等人」这一种是合法的。其余一律收成失败终态:
-        // 停在 running 会让 `pump()` 的 `findRunning()` 永远有值,这个 Session
-        // 之后所有消息都排不进去,而且没有任何东西会再唤醒它。
-        if (preparation.kind === "parked") return latest;
-        // `settled` 走到这里说明它没真的写成终态 —— 契约破了也不能放它挂着。
-        return this.submissions.finish(
-          latest,
-          "failed",
-          preparation.kind === "unresumable"
-            ? preparation.reason
-            : unresumableWaitMessage(undefined),
-        );
-      }
-    } else {
-      const decision = await this.materializeRecoveredToolResults(submission);
-      awaitingHumanInput = mode === "continuation" &&
-        decision.effect.kind === "wait" &&
-        (decision.effect.reason === "approval" ||
-          decision.effect.reason === "interaction");
-    }
-
-    const ready = this.readSubmission(submissionId);
-    if (!ready) {
-      throw new Error(`Unknown SpringBrand submission: ${submissionId}`);
-    }
-    if (isTerminalSubmissionStatus(ready.status)) return ready;
-    if (ready.abortReason) {
-      return this.submissions.finish(
-        ready,
-        "aborted",
-        ready.abortReason,
-      );
-    }
-    if (awaitingHumanInput) return ready;
-    if (ready.status === "pending") {
-      if (this.db.submissions.transition(submissionId, "running", ["pending"])) {
-        this.telemetry.capture("turnStarted", {
-          submissionId,
-          assemblyRevision: ready.assemblyRevision,
-        });
-      }
-    }
-    const storedMessages = await this.transcript.storedMessages();
-    const assistantOrdinal = storedMessages.filter(
-      (entry) =>
-        entry.submissionId === submissionId &&
-        entry.message.role === "assistant",
-    ).length;
-    let terminalIntent:
-      | {
-          outcome: "succeeded" | "failed" | "aborted";
-          message?: string;
-        }
-      | undefined;
-    const startedAt = ready.createdAt;
-    let turn!: ActiveTurn;
-    const adapter = this.createSubmissionExecutionAdapter(submission, {
-      startedAt,
-      continuation,
-      assistantOrdinal,
-      onRecord: (record) =>
-        this.migratedSubmissions.has(submissionId)
-          ? undefined
-          : this.persistAndBroadcastRecord(turn, record),
-      onTerminal: async (intent) => {
-        terminalIntent = intent;
-        this.appendTerminalIntent(
-          submission,
-          intent.outcome,
-          intent.message,
-        );
-      },
-    });
-    for (const pending of this.db.steers.listForSubmission(submissionId)) {
-      const message = JSON.parse(
-        pending.canonicalJson,
-      ) as PiCanonicalUserInput;
-      if (message?.role !== "user") {
-        throw new Error(`Pending steer ${pending.steerId} is invalid`);
-      }
-      adapter.steer(message, pending.messageId);
-    }
-    turn = {
-      submissionId,
-      requestId: submission.requestId,
-      messageId: submission.assistantMessageId,
-      startedAt,
-      continuation,
-      agent: adapter,
-    };
-    let streamId: string | undefined;
-    let runResult: import("./pi/runtime-adapter").PiTurnRunResult | undefined;
-
-    const deactivate = this.submissions.activate(submission, turn);
-    await this.broadcastApprovals();
-    try {
-      await this.runRecoverableChatFiber(
-        {
-          requestId: submission.requestId,
-          messageId: submission.assistantMessageId,
-          continuation,
-          messages: await this.transcript.snapshotMessages(),
-          recoveryData: {
-            submissionId,
-            requestId: submission.requestId,
-          },
-        },
-        async (_fiber, activeStreamId) => {
-          streamId = activeStreamId;
-          this.streamBySubmission.set(submissionId, streamId);
-          try {
-            runResult = await adapter.run({});
-          } finally {
-            this.streamBySubmission.delete(submissionId);
-          }
-        },
-      );
-      // 换装配把这条执行器中断掉了：Submission 没有结束，它在等持久续跑用新
-       // 装配重建一条接着跑。这里写终态会把那一轮当场杀掉。
-      if (this.migratedSubmissions.has(submissionId)) {
-        if (streamId) this.failRecoverableStream(streamId);
-        return this.readSubmission(submissionId)!;
-      }
-      if (runResult?.kind === "yielded") {
-        const latest = this.readSubmission(submissionId)!;
-        if (latest.abortReason) {
-          return this.submissions.finish(
-            latest,
-            "aborted",
-            latest.abortReason,
-          );
-        }
-        if (!streamId) {
-          throw new Error("Yielded SpringBrand Turn has no recoverable stream");
-        }
-        // 回合数和续跑标识必须先落库、再排调度：调度一旦到期就会读这两个值，
-        // 反过来写会让续跑看到上一片的状态。
-        this.db.transaction(() =>
-          this.db.submissions.recordYieldedSlice(
-            submissionId,
-            runResult!.modelTurns,
-            streamId!,
-          )
-        );
-        // 让步必须密封本切片的流，但不能发 done —— 这一轮还没有权威结果。
-        // 不密封的话下一个切片的 start() 会直接顶掉 activeStreamId，旧行永远
-        // 停在 streaming，元数据和 chunk 要等 abandoned 保留期才回收。
-        this.sealRecoverableStreamSlice(streamId);
-        await this.schedule(
-          0,
-          "_piPlannedContinuation",
-          {
-            submissionId,
-            requestId: submission.requestId,
-            continuationId: streamId,
-          },
-          { idempotent: true },
-        );
-        await this.scheduleContinuationWatchdog(
-          submissionId,
-          submission.requestId,
-          streamId,
-        );
-        return latest;
-      }
-      if (runResult) {
-        this.db.transaction(() =>
-          this.db.submissions.recordModelTurns(
-            submissionId,
-            runResult!.modelTurns,
-          )
-        );
-      }
-      const intent = terminalIntent ?? {
-        outcome: "failed" as const,
-        message:
-          "SpringBrand turn ended without an authoritative assistant message",
-      };
-      const terminal = await this.submissions.finish(
-        submission,
-        intent.outcome,
-        intent.message,
-      );
-      if (streamId) this.settleRecoverableStream(streamId, terminal);
-      await this.projectTerminal(turn, terminal);
-      return terminal;
-    } catch (error) {
-      // 同上：中断出来的 abort 不是失败，也不是取消。
-      if (this.migratedSubmissions.has(submissionId)) {
-        if (streamId) this.failRecoverableStream(streamId);
-        return this.readSubmission(submissionId)!;
-      }
-      const stalled = error instanceof ChatStreamStalledError;
-      const contextOverflow = error instanceof ContextOverflowError;
-      const resetModelSession = error instanceof RetryableModelSessionError;
-      const abortReason = this.readSubmission(submissionId)?.abortReason;
-      if (!abortReason && (stalled || error instanceof RetryableModelError)) {
-        if (resetModelSession) {
-          this.modelSessionId = crypto.randomUUID();
-          await this.ctx.storage.put(
-            MODEL_SESSION_ID_STORAGE_KEY,
-            this.modelSessionId,
-          );
-        }
-        const recoveryReason: SubmissionRecoveryReason = stalled
-          ? "no_meaningful_model_progress"
-          : resetModelSession
-            ? "server_tool_timeout"
-            : contextOverflow
-              ? "context_overflow"
-              : "transient_model_error";
-        let contextOverflowRecoveryClaimed = false;
-        const recoveryErrorCount = this.db.transaction(() => {
-          if (contextOverflow) {
-            contextOverflowRecoveryClaimed = this.db.submissions
-              .claimContextOverflowRecovery(submissionId);
-          }
-          return this.db.submissions.incrementRecoveryErrorCount(
-            submissionId,
-            recoveryReason,
-          );
-        });
-        if (stalled) {
-          const stallDetails = readModelStreamStallDetails(errorText(error)) ?? {
-            lastMeaningfulActivityAt:
-              Date.now() - MODEL_STREAM_STALL_TIMEOUT_MS,
-            lastMeaningfulActivityType: "model_stream_started",
-            idleMs: MODEL_STREAM_STALL_TIMEOUT_MS,
-          };
-          this._emit("chat:stream:stalled", {
-            requestId: submission.requestId,
-            submissionId,
-            attempt: recoveryErrorCount,
-            timeoutMs: MODEL_STREAM_STALL_TIMEOUT_MS,
-            ...stallDetails,
-            reason: "no_meaningful_model_progress",
-          });
-        }
-        await this.broadcastApprovals();
-        const stoppedDuringRecovery = this.readSubmission(submissionId)
-          ?.abortReason;
-        const retryAllowed = contextOverflow
-          ? contextOverflowRecoveryClaimed &&
-            recoveryErrorCount < CHAT_RECOVERY_MAX_ATTEMPTS
-          : recoveryErrorCount <
-            (stalled
-              ? CHAT_STALL_MAX_ATTEMPTS
-              : resetModelSession
-                ? SERVER_TOOL_TIMEOUT_MAX_ATTEMPTS
-                : CHAT_RECOVERY_MAX_ATTEMPTS);
-        if (
-          !stoppedDuringRecovery &&
-          retryAllowed
-        ) {
-          const recoveryOutcome = await this.scheduleChatRecoveryRetry(
-            {
-              submissionId,
-              requestId: submission.requestId,
-            },
-            async () => {
-              this.broadcast(json({
-                type: MessageType.CF_AGENT_CHAT_MESSAGES,
-                messages: await this.getMessages(),
-              }));
-              if (streamId) this.completeRecoverableStream(streamId);
-              this.sendChatResponse(submission.requestId, "", true, {
-                continuation: turn.continuation,
-              });
-            },
-          );
-          const stoppedAfterScheduling = this.readSubmission(submissionId)
-            ?.abortReason;
-          if (stoppedAfterScheduling) {
-            await this.settleChatRecovery(
-              submission.requestId,
-              "skipped",
-              stoppedAfterScheduling,
-            );
-          }
-          if (!stoppedAfterScheduling) {
-            // 只有恢复通道的调用方(`_chatRecoveryRetry`)靠这次重抛判定 "scheduled"。
-            // 让步续跑由 alarm 驱动，重抛只会把那次 alarm 变成一次失败。
-            if (mode === "recovery" && recoveryOutcome === "scheduled") {
-              throw error;
-            }
-            return this.readSubmission(submissionId)!;
-          }
-        } else if (!stoppedDuringRecovery) {
-          terminalIntent = {
-            outcome: "failed",
-            message: contextOverflow
-              ? CONTEXT_OVERFLOW_TERMINAL_MESSAGE
-              : CHAT_RECOVERY_TERMINAL_MESSAGE,
-          };
-        }
-      }
-      const latest = this.readSubmission(submissionId);
-      const intent = terminalIntent ?? (latest?.abortReason
-        ? {
-            outcome: "aborted" as const,
-            message: latest.abortReason,
-          }
-        : {
-            outcome: "failed" as const,
-            message: errorText(error),
-          });
-      const failed = await this.submissions.finish(
-        submission,
-        intent.outcome,
-        intent.message,
-      );
-      if (streamId) this.settleRecoverableStream(streamId, failed);
-      await this.projectTerminal(turn, failed);
-      return failed;
-    } finally {
-      deactivate();
-    }
-  }
-
-  private settleRecoverableStream(
-    streamId: string,
-    submission: StoredSubmission,
-  ): void {
-    if (
-      submission.status === "completed" ||
-      (submission.status === "aborted" &&
-        submission.error === USER_STOP_REASON)
-    ) {
-      this.completeRecoverableStream(streamId);
-    } else {
-      this.failRecoverableStream(streamId);
-    }
-  }
-
-  // 作用：持久化一条 Pi 流记录并广播给在线客户端。
-  // 调用：活跃 Turn 适配器每产生一条 stream record 时调用。
-  // 原因：先发 WebSocket 再等持久化完成，让客户端零延迟收到 token，同时
-  // await 保证 Pi 的事件循环不越过尚未落盘的 chunk，续传完整性不受影响。
-  private async persistAndBroadcastRecord(
-    turn: ActiveTurn,
-    chunk: UIMessageChunk,
-  ): Promise<void> {
-    const streamId = this.streamBySubmission.get(turn.submissionId);
-    const body = json(chunk);
-    const persist = streamId
-      ? this.appendRecoverableChunk(streamId, body)
-      : Promise.resolve();
-    this.sendChatResponse(turn.requestId, body, false, {
-      continuation: turn.continuation,
-    });
-    await persist;
-  }
-
-  private sendChatTerminal(
-    requestId: string,
-    error?: string,
-    continuation = false,
-  ): void {
-    this.sendChatResponse(
-      requestId,
-      error
-        ? json({ type: "error", errorText: error } satisfies UIMessageChunk)
-        : "",
-      true,
-      { continuation },
-    );
-  }
-
-  // 作用：把已提交的 Submission 终态投影到聊天协议、审批状态和可选业务事件。
-  // 调用：非终态 Turn 成功收尾且可续传流已标记完成后调用。
-  // 原因：Submission 是权威状态，其他都是后续投影；业务投影失败只降级记录，不能推翻已完成 Turn。
-  private async projectTerminal(
-    turn: ActiveTurn,
-    submission: StoredSubmission,
-  ): Promise<void> {
-    this.sendChatTerminal(
-      turn.requestId,
-      submission.status === "error"
-        ? submission.error ?? "SpringBrand turn failed"
-        : undefined,
-      turn.continuation,
-    );
-    const messages = await this.getMessages();
-    await this.broadcastApprovals();
-    this.broadcast(
-      json({
-        type: MessageType.CF_AGENT_CHAT_MESSAGES,
-        messages,
-      }),
-    );
-    const events = this.turnEventsPort();
-    if (events) {
-      try {
-        await events.onResponse(
-          messages.flatMap((message) =>
-            message.role === "user" || message.role === "assistant"
-              ? [
-                  {
-                    role: message.role,
-                    text: message.parts
-                      .filter(
-                        (
-                          part,
-                        ): part is Extract<UIMessage["parts"][number], { type: "text" }> =>
-                          part.type === "text",
-                      )
-                      .map((part) => part.text)
-                      .join(""),
-                  },
-                ]
-              : [],
-          ),
-        );
-      } catch (error) {
-        console.warn(
-          "[runtime-turn-projection:degraded]",
-          json({ error: errorText(error) }),
-        );
-      }
-      try {
-        if (
-          submission.status === "completed" ||
-          submission.status === "aborted" ||
-          submission.status === "skipped" ||
-          submission.status === "error"
-        ) {
-          await events.onSubmissionTerminal?.({
-            submissionId: submission.submissionId,
-            status: submission.status,
-            ...(submission.error ? { error: submission.error } : {}),
-            resultMessageId: submission.assistantMessageId,
-          });
-        }
-      } catch (error) {
-        console.warn(
-          "[runtime-terminal-projection:degraded]",
-          json({ error: errorText(error) }),
-        );
-      }
-    }
-  }
-
-  // #endregion
-
-  // #region Cloudflare Agent 通信生命周期
-
-  /**
-   * 在新 WebSocket 建立后向该连接发送当前聊天快照。
-   *
-   * @remarks
-   * Cloudflare Agents SDK 为每条新 WebSocket 连接调用。
-   *
-   * 先发送已完成 transcript，再让恢复基类独自重建 active assistant，
-   * 使持久化历史和 resumable stream 只有一个生产者。
-   */
-  async onConnect(connection: Connection): Promise<void> {
-    await this.sendHydrationSnapshot(connection);
-    await super.onConnect(connection);
-  }
-
-  /**
-   * 处理直接发给 Agent 实例的 HTTP 请求。
-   *
-   * @remarks
-   * Cloudflare Agents SDK 在每个非 WebSocket HTTP 请求到达时调用。
-   *
-   * Kernel 只拦截 `get-messages` 读取口，其余路由基类处理，
-   * 避免在这里复制 Agents SDK 的默认协议行为。
-   */
-  async onRequest(request: Request): Promise<Response> {
-    const url = new URL(request.url);
-    if (url.pathname.endsWith("/get-messages")) {
-      return Response.json(
-        url.searchParams.get("view") === "hydration"
-          ? await this.hydrationMessages()
-          : await this.getMessages(),
-      );
-    }
-    return super.onRequest(request);
-  }
-
-  /**
-   * 验证并处理一条来自聊天 WebSocket 的协议消息。
-   *
-   * @remarks
-   * Cloudflare Agents SDK 在已连接 WebSocket 收到消息时调用。
-   *
-   * 提交、取消、清空、续传和 Tool 审批都在这一信任边界先验证再分流，
-   * 这样领域层不会接到半解析的客户端输入。
-   */
-  async onMessage(
-    connection: Connection,
-    raw: string | ArrayBuffer,
-  ): Promise<void> {
-    if (typeof raw !== "string") return;
-    const event = parseProtocolMessage(raw);
-    if (!event) return;
-
-    if (event.type === "chat-request") {
-      let body: UIChatRequestBody;
-      try {
-        body = JSON.parse(
-          String(event.init.body ?? "{}"),
-        ) as UIChatRequestBody;
-      } catch {
-        this.sendChatTerminal(event.id, "Chat request body is invalid JSON");
-        return;
-      }
-      const latest = Array.isArray(body.messages)
-        ? [...body.messages].reverse().find(
-            (message): message is UIMessage & { role: "user" } =>
-              message?.role === "user",
-          )
-        : undefined;
-      if (
-        !latest ||
-        latest.role !== "user" ||
-        typeof latest.id !== "string" ||
-        !Array.isArray(latest.parts) ||
-        !latest.parts.every((part) => {
-          if (part === null || typeof part !== "object") return false;
-          return part.type === "text"
-            ? typeof part.text === "string"
-            : part.type === "file" &&
-              typeof part.mediaType === "string" &&
-              typeof part.url === "string" &&
-              (part.filename === undefined || typeof part.filename === "string");
-        }) ||
-        (body.trigger !== "submit-message" &&
-          body.trigger !== "regenerate-message")
-      ) {
-        this.sendChatTerminal(event.id, "Chat request user message is invalid");
-        return;
-      }
-      let submitted: Awaited<
-        ReturnType<AgentRuntimeKernel["submitMessage"]>
-      >;
-      try {
-        const normalized = await this.normalizeUIUserInput(latest);
-        submitted = await this.submitMessage(normalized, {
-          requestId: event.id,
-          idempotencyKey: event.id,
-          userMessageId: latest.id,
-          userMessage: latest,
-          regenerate: body.trigger === "regenerate-message",
-        });
-      } catch (error) {
-        this.sendChatTerminal(event.id, errorText(error));
-        return;
-      }
-      if (submitted.receipt.accepted) {
-        this.beginPreStream(event.id);
-      }
-      await submitted.completion;
-      return;
-    }
-
-    if (event.type === "cancel") {
-      const submission = this.findSubmissionByRequest(event.id);
-      if (submission) {
-        await this.cancelSubmissionById(
-          submission.submissionId,
-          USER_STOP_REASON,
-        );
-      }
-      return;
-    }
-
-    if (event.type === "clear") {
-      if (this.submissions.isBusy()) return;
-      this.db.transaction(() => {
-        this.transcript.clear();
-        this.db.clearAll();
-        this.clearRecoverableStreamStorage();
-      });
-      this.clearRecoverableChatState();
-      await this.broadcastApprovals();
-      this.broadcast(json({ type: MessageType.CF_AGENT_CHAT_CLEAR }));
-      return;
-    }
-
-    if (event.type === "stream-resume-request") {
-      // The client sends this only after its listener mounts; onConnect's snapshot
-      // may have arrived while initial history suspended. Active replies still
-      // come exclusively from CF replay, never from this history snapshot.
-      await this.sendHydrationSnapshot(connection);
-      await this.handleResumeRequest(
-        connection,
-        event.probeId,
-      );
-      return;
-    }
-
-    if (event.type === "stream-resume-ack") {
-      await this.handleResumeAck(
-        connection,
-        event.id,
-      );
-      return;
-    }
-
-    if (event.type === "tool-approval") {
-      const executionId = this.approvals.findPendingExecution(
-        event.toolCallId,
-      );
-      if (!executionId) return;
-      await this.decideApproval(
-        executionId,
-        event.approved
-          ? { decision: "allow_once" }
-          : { decision: "deny", reason: "User denied the Tool" },
-      );
-    }
-  }
-
-  /**
-   * 返回当前 canonical transcript 的浏览器投影。
-   *
-   * @remarks
-   * 新连接、HTTP 读取、Turn 完成投影和 RPC 调用方需要消息快照时调用。
-   *
-   * 统一从 transcript 生成完整视图；HTTP fallback、fork 和 RPC 读取保留 active assistant。
-   */
-  async getMessages(): Promise<UIMessage[]> {
-    return this.transcript.browserMessages();
-  }
-
-  private async sendHydrationSnapshot(connection: Connection): Promise<void> {
-    sendIfOpen(connection, json({
-      type: MessageType.CF_AGENT_CHAT_MESSAGES,
-      messages: await this.hydrationMessages(),
-    }));
-  }
-
-  private async hydrationMessages(): Promise<UIMessage[]> {
-    const messages = await this.getMessages();
-    const running = this.db.submissions.findRunning();
-    // After a restart there is no in-memory replay stream. In particular, a
-    // parked approval cannot recreate one until the user can see and decide it.
-    return running?.assistantMessageId && this.streamBySubmission.has(running.submissionId)
-      ? messages.filter((message) =>
-          message.role !== "assistant" ||
-          (message.id !== running.assistantMessageId &&
-            (message.metadata as { turnId?: unknown } | undefined)?.turnId !==
-              running.submissionId)
-        )
-      : messages;
-  }
-
-  /** 读取当前 canonical transcript 中最后一条助手文本。 */
-  protected async latestAssistantText(): Promise<string | undefined> {
-    const message = [...await this.transcript.canonicalMessages()]
-      .reverse()
-      .find((entry): entry is AssistantMessage => entry.role === "assistant");
-    const text = message?.content
-      .flatMap((part) => part.type === "text" ? [part.text] : [])
-      .join("")
-      .trim();
-    return text || undefined;
-  }
-
-  // #endregion
-
-  // #region Runtime Extension Host 回环端口
-
-  // 作用：代表扩展从当前 Runtime Workspace 读取文件。
-  // 调用：已获文件读权限的 HostBridgeLoopback 在处理扩展请求时调用。
-  // 原因：扩展只经过已裁剪的 Host 端口访问工作区，不直接持有平台绑定。
-  private async runtimeWorkspace() {
-    await this.ensureRuntimeReady();
-    const workspace = this.assembly().bindings.workspace;
-    if (!workspace) throw new Error("Runtime Workspace is unavailable");
-    return workspace;
-  }
-
-  async _hostReadFile(path: string): Promise<string | null> {
-    return (await this.runtimeWorkspace()).readFile(path);
-  }
-
-  // 作用：代表扩展把文本写入当前 Runtime Workspace。
-  // 调用：已获文件写权限的 HostBridgeLoopback 在处理扩展请求时调用。
-  // 原因：统一在 Session 边界检查 Workspace 是否可用，避免扩展自行解析平台能力。
-  async _hostWriteFile(
-    path: string,
-    content: string,
-  ): Promise<void> {
-    await (await this.runtimeWorkspace()).writeFile(path, content);
-  }
-
-  // 作用：代表扩展删除当前 Runtime Workspace 中的路径。
-  // 调用：已获文件删除权限的 HostBridgeLoopback 在处理扩展请求时调用。
-  // 原因：Host 契约用布尔值表示删除结果，所以 Workspace 抛错在这一边界被收窄为 `false`。
-  async _hostDeleteFile(path: string): Promise<boolean> {
-    const workspace = await this.runtimeWorkspace();
-    try {
-      await workspace.rm(path);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  // 作用：代表扩展列出当前 Runtime Workspace 目录。
-  // 调用：已获目录读权限的 HostBridgeLoopback 在处理扩展请求时调用。
-  // 原因：只投影稳定的名称、类型、大小和路径，不把 Workspace 的内部目录对象泄漏给扩展。
-  async _hostListFiles(
-    dir: string,
-  ): Promise<
-    Array<{ name: string; type: string; size: number; path: string }>
-  > {
-    const workspace = await this.runtimeWorkspace();
-    return (await workspace.readDir(dir)).map((entry) => ({
-      name: entry.name,
-      type: entry.type,
-      size: entry.size,
-      path: entry.path,
-    }));
-  }
-
-  // 作用：读取一份按 label 保存的 Runtime Extension Context。
-  // 调用：已获对应 label 读权限的 HostBridgeLoopback 在扩展运行期调用。
-  // 原因：Context 与 Durable Object 共享 SQLite 持久性，唤醒后不需要从扩展重建。
-  async _hostGetContext(label: string): Promise<string | null> {
-    return this.db.extContext.get(label) ?? null;
-  }
-
-  // 作用：按 label 写入一份 Runtime Extension Context。
-  // 调用：已获对应 label 写权限的 HostBridgeLoopback 在扩展运行期调用。
-  // 原因：由 Host 集中选择持久存储，扩展不必获得任意 SQL 访问权。
-  async _hostSetContext(
-    label: string,
-    content: string,
-  ): Promise<void> {
-    this.db.extContext.set(label, content);
-  }
-
-  // 作用：为扩展返回精简的 Session 消息历史。
-  // 调用：已获消息读权限的 HostBridgeLoopback 按需传入数量上限时调用。
-  // 原因：使用 transcript 的 Host 投影，避免把 Pi 专用 part 和持久化细节暴露给扩展。
-  async _hostGetMessages(
-    limit?: number,
-  ): Promise<
-    Array<{ id: string; role: string; content: string }>
-  > {
-    return this.transcript.hostMessages(limit);
-  }
-
-  // 作用：把扩展生成的文本作为用户消息送入当前 Session。
-  // 调用：已获消息写权限的 HostBridgeLoopback 在扩展需要追加或 steer 时调用。
-  // 原因：有活跃 Turn 时交给它的 adapter steer，空闲时才直接写 transcript，从而保持单一执行流。
-  async _hostSendMessage(content: string): Promise<void> {
-    if (typeof content !== "string" || content.trim().length === 0) {
-      throw new Error("Extension message content is required");
-    }
-    const message: PiCanonicalUserInput = {
-      role: "user",
-      content: [{ type: "text", text: content }],
-      timestamp: Date.now(),
-    };
-    const active = this.submissions.currentActive();
-    if (active) {
-      const messageId = crypto.randomUUID();
-      this.db.transaction(() => {
-        this.db.steers.insert({
-          steerId: crypto.randomUUID(),
-          submissionId: active.submissionId,
-          messageId,
-          canonicalJson: json(message),
-          uiMessageJson: null,
-          createdAt: message.timestamp,
-        });
-      });
-      active.agent.steer(message, messageId);
-      await this.broadcastApprovals();
-      return;
-    }
-    this.transcript.append(crypto.randomUUID(), message);
-  }
-
-  // 作用：返回扩展可见的当前 Session 摘要。
-  // 调用：HostBridgeLoopback 在扩展请求 Session 信息时调用。
-  // 原因：先只提供真实需要的消息数，不暴露 Durable Object 身份或数据库结构。
-  async _hostGetSessionInfo(): Promise<{ messageCount: number }> {
-    return {
-      messageCount: (await this._hostGetMessages()).length,
-    };
-  }
-
-  // #endregion
-
-  // #region Session 消息与 Submission 公开控制面
-
-  /**
-   * 把一组已有消息导入当前 canonical transcript。
-   *
-   * @remarks
-   * Inbox 只在真实 fork 或 import 会话历史时调用。
-   *
-   * 导入统一交给 transcript 并传入当前模型，
-   * 避免外部调用方自行拼接 Pi 的持久化形式。
-   */
-  async getCanonicalSnapshot(
-    throughMessageId: string,
-  ): Promise<PiCanonicalTranscriptSnapshot> {
-    return this.transcript.exportSnapshot(throughMessageId);
-  }
-
-  async addCanonicalSnapshot(
-    snapshot: PiCanonicalTranscriptSnapshot,
-  ): Promise<void> {
-    this.transcript.importSnapshot(snapshot);
-  }
-
-  // 作用：把一段纯文本包装成标准用户消息并提交。
-  // 调用：公开 `submitPrompt` 为 RPC 调用创建 request ID 时调用。
-  // 原因：RPC 只需提供文本，内部仍走与 WebSocket 相同的 canonical admission。
-  private submitText(
-    text: string,
-    options?: { idempotencyKey?: string },
-  ): Promise<SubmissionHandle<StoredSubmission>> {
-    const requestId = crypto.randomUUID();
-    const userMessage: PiCanonicalUserInput = {
-      role: "user",
-      content: [{ type: "text", text }],
-      timestamp: Date.now(),
-    };
-    return this.submitMessage(userMessage, {
-      requestId,
-      idempotencyKey: options?.idempotencyKey,
-    });
-  }
-
-  /**
-   * 可靠提交一段用户文本，并立即返回可查询回执。
-   *
-   * @remarks
-   * Inbox、子任务或其他 RPC 调用方需要启动新 Turn 时调用。
-   *
-   * 接口不等待模型完成，而是把同一 completion 留给 Durable Object 继续处理，
-   * 调用方用 Submission ID 查询状态。
-   */
-  async submitPrompt(
-    text: string,
-    options?: { idempotencyKey?: string },
-  ): Promise<SubmissionReceipt> {
-    const submitted = await this.submitText(text, options);
-    this.ctx.waitUntil(submitted.completion);
-    return submitted.receipt;
-  }
-
-  // 作用：找出当前停在「等客户端结算某个 Tool」上的 Submission。
-  // 调用：dispatchMessage 判断要不要把 delivery 提升成 steer 时调用。
-  // 原因：park 期间 DO 可能已经睡过一觉，内存里的 active turn 不可信，只能问数据库。
-  private findInteractionParkedSubmission(): StoredSubmission | null {
-    const running = this.db.submissions.findRunning() as
-      | StoredSubmission
-      | null;
-    return running &&
-      this.interactions.hasPendingForSubmission(running.submissionId)
-      ? running
-      : null;
-  }
-
-  async dispatchMessage(
-    message: UIMessage,
-    delivery: MessageDelivery,
-  ): Promise<MessageDispatchReceipt> {
-    if (
-      message.role !== "user" ||
-      !message.id ||
-      !Array.isArray(message.parts) ||
-      (delivery !== "steer" && delivery !== "enqueue")
-    ) {
-      return {
-        kind: "rejected",
-        code: "invalid_message",
-        message: "A valid user message is required",
-      };
-    }
-
-    let userMessage: PiCanonicalUserInput;
-    try {
-      userMessage = await this.normalizeUIUserInput(
-        message as UIMessage & { role: "user" },
-      );
-    } catch (error) {
-      return {
-        kind: "rejected",
-        code: "invalid_message",
-        message: errorText(error),
-      };
-    }
-    // 停在 interaction park 上的 Turn 一律按 steer 处理，哪怕客户端发的是 enqueue：
-    // enqueue 要等本 Turn 结束，而本 Turn 正在等一个永远不会来的答案 —— 死锁。
-    const parked = this.findInteractionParkedSubmission();
-    const effectiveDelivery = parked ? "steer" : delivery;
-    if (effectiveDelivery === "steer") {
-      const active = this.submissions.currentActive();
-      const target = parked ??
-        active ??
-        this.db.submissions.findRunning() ??
-        this.db.submissions.findNextPending();
-      if (target) {
-        if (
-          this.db.approvals.listPendingForSubmission(
-            target.submissionId,
-          ).length > 0
-        ) {
-          return {
-            kind: "rejected",
-            code: "not_steerable",
-            message: "The current Turn is waiting for approval",
-          };
-        }
-        const steerId = crypto.randomUUID();
-        const inserted = this.db.transaction(() => {
-          if (this.db.steers.findByMessageId(message.id)) return false;
-          this.db.steers.insert({
-            steerId,
-            submissionId: target.submissionId,
-            messageId: message.id,
-            canonicalJson: json(userMessage),
-            uiMessageJson: json(message),
-            createdAt: userMessage.timestamp,
-          });
-          this.telemetry.capture("turnSteered", {
-            submissionId: target.submissionId,
-            steerId,
-            messageId: message.id,
-            content: userMessage,
-            occurredAt: userMessage.timestamp,
-          });
-          return true;
-        });
-        if (inserted) {
-          if (active?.submissionId === target.submissionId) {
-            active.agent.steer(userMessage, message.id);
-          }
-          await this.broadcastApprovals();
-        }
-        // 先落 steer 再取消：取消会唤醒 park 住的 Tool 让 Turn 继续跑，
-        // 顺序反过来 Turn 可能在这条消息落盘前就跑完了。
-        if (parked?.submissionId === target.submissionId) {
-          await this.interactions.cancelPendingForSubmission(
-            target.submissionId,
-            "user_replied_freeform",
-          );
-        }
-        return {
-          kind: "accepted",
-          submissionId: target.submissionId,
-          messageId: message.id,
-        };
-      }
-    }
-
-    try {
-      const submitted = await this.submitMessage(userMessage, {
-        requestId: message.id,
-        idempotencyKey: message.id,
-        userMessageId: message.id,
-        userMessage: message as UIMessage & { role: "user" },
-      });
-      this.ctx.waitUntil(submitted.completion);
-      const position = this.db.submissions.listPending()
-        .findIndex((item) =>
-          item.submissionId === submitted.receipt.submissionId
-        ) + 1;
-      return position > 0
-        ? {
-            kind: "queued",
-            submission: submitted.receipt,
-            position,
-          }
-        : {
-            kind: "accepted",
-            submissionId: submitted.receipt.submissionId,
-            messageId: message.id,
-          };
-    } catch (error) {
-      if (error instanceof SubmissionQueueFullError) {
-        return {
-          kind: "rejected",
-          code: "queue_full",
-          message: error.message,
-        };
-      }
-      throw error;
-    }
-  }
-
-  async steerQueuedSubmission(
-    submissionId: string,
-  ): Promise<MessageDispatchReceipt> {
-    const active = this.submissions.currentActive();
-    const target = active ??
-      this.db.submissions.findRunning() ??
-      this.db.submissions.findNextPending();
-    if (
-      !target ||
-      this.db.approvals.listPendingForSubmission(
-        target.submissionId,
-      ).length > 0
-    ) {
-      return {
-        kind: "rejected",
-        code: "not_steerable",
-        message: "The current Turn is not accepting steering",
-      };
-    }
-
-    const queued = this.readSubmission(submissionId);
-    if (
-      !queued ||
-      queued.submissionId === target.submissionId ||
-      queued.status !== "pending" ||
-      !queued.queuedInputJson ||
-      !queued.userMessageId
-    ) {
-      return {
-        kind: "rejected",
-        code: "invalid_message",
-        message: "The queued message is no longer available",
-      };
-    }
-    const message = JSON.parse(
-      queued.queuedInputJson,
-    ) as PiCanonicalUserInput;
-    if (message?.role !== "user") {
-      return {
-        kind: "rejected",
-        code: "invalid_message",
-        message: "The queued message is invalid",
-      };
-    }
-    const uiMessage = queued.queuedUiMessageJson
-      ? JSON.parse(queued.queuedUiMessageJson) as UIMessage
-      : undefined;
-    if (
-      uiMessage &&
-      (uiMessage.role !== "user" || uiMessage.id !== queued.userMessageId)
-    ) {
-      return {
-        kind: "rejected",
-        code: "invalid_message",
-        message: "The queued message is invalid",
-      };
-    }
-
-    const steerId = crypto.randomUUID();
-    const moved = this.db.transaction(() => {
-      const latest = this.readSubmission(submissionId);
-      const current = this.db.submissions.findRunning() ??
-        this.db.submissions.findNextPending();
-      if (
-        !latest ||
-        latest.status !== "pending" ||
-        current?.submissionId !== target.submissionId ||
-        this.db.steers.findByMessageId(queued.userMessageId!)
-      ) {
-        return false;
-      }
-      this.db.steers.insert({
-        steerId,
-        submissionId: target.submissionId,
-        messageId: queued.userMessageId!,
-        canonicalJson: queued.queuedInputJson!,
-        uiMessageJson: queued.queuedUiMessageJson ?? null,
-        createdAt: queued.createdAt,
-      });
-      this.telemetry.capture("turnSteered", {
-        submissionId: target.submissionId,
-        steerId,
-        messageId: queued.userMessageId!,
-        content: message,
-        occurredAt: queued.createdAt,
-      });
-      const reason = "Moved to active Turn";
-      this.appendTerminalIntent(latest, "aborted", reason);
-      this.db.submissions.updateAbortReason(submissionId, reason);
-      this.insertSubmissionTerminalFact(
-        this.updateSubmission(submissionId, "aborted", reason),
-      );
-      return true;
-    });
-    if (!moved) {
-      return {
-        kind: "rejected",
-        code: "invalid_message",
-        message: "The queued message is no longer available",
-      };
-    }
-
-    try {
-      if (active?.submissionId === target.submissionId) {
-        active.agent.steer(message, queued.userMessageId);
-      }
-    } finally {
-      await this.drainRuntimeEvents();
-      await this.broadcastApprovals();
-    }
-    return {
-      kind: "steered",
-      submissionId: target.submissionId,
-      messageId: queued.userMessageId,
-      ...(uiMessage ? { message: uiMessage } : {}),
-    };
-  }
-
-  /**
-   * 等待 Session 稳定后提交定时提示，并在准入后立即返回。
-   *
-   * @remarks
-   * Agent 定时回调在不应与人工 Turn 并发时调用。
-   *
-   * 最多等待固定的稳定窗口；超时返回 skipped，
-   * 避免定时任务无限占住调用链。
-   */
-  async submitScheduledPrompt(
-    prompt: string,
-    options?: { idempotencyKey?: string },
-  ): Promise<SubmissionReceipt> {
-    const requestId = crypto.randomUUID();
-    const submitted = await this.submitMessageWhenStable(
-      {
-        role: "user",
-        content: [{ type: "text", text: prompt }],
-        timestamp: Date.now(),
-      },
-      {
-        requestId,
-        idempotencyKey: options?.idempotencyKey,
-      },
-      SCHEDULED_STABLE_TIMEOUT_MS,
-    );
-    if (!submitted) {
-      const skipped = this.db.transaction(() => {
-        const duplicate = options?.idempotencyKey
-          ? this.db.submissions.findByIdempotencyKey(options.idempotencyKey)
-          : this.db.submissions.findByRequestId(requestId);
-        return duplicate ?? this.insertSkippedSubmission({
-          submissionId: requestId,
-          requestId,
-          idempotencyKey: options?.idempotencyKey ?? null,
-          createdAt: Date.now(),
-          code: "Runtime not stable within timeout",
-          retryable: true,
-        });
-      }) as StoredSubmission;
-      await this.drainRuntimeEvents();
-      await this.broadcastApprovals();
-      return skipped;
-    }
-    this.ctx.waitUntil(submitted.completion.then(() => undefined));
-    return submitted.receipt;
-  }
-
-  /**
-   * 按 Submission ID 读取当前回执。
-   *
-   * @remarks
-   * 提交后的 RPC 调用方用它轮询或核对终态。
-   *
-   * 直接读取 SubmissionLifecycle 的持久存储，不用内存执行状态猜测结果。
-   */
-  async getSubmission(
-    submissionId: string,
-  ): Promise<SubmissionReceipt | null> {
-    return this.submissions.get(submissionId);
-  }
-
-  /**
-   * 取消一条指定 Submission。
-   *
-   * @remarks
-   * Inbox 或调度清理路径在已知 Submission ID 时调用。
-   *
-   * 取消交给 SubmissionLifecycle 先持久化 abort intent 再停活跃 adapter，
-   * 避免重启后丢失取消决定。
-   */
-  async cancelSubmissionById(
-    submissionId: string,
-    reason?: string,
-  ): Promise<{ ok: boolean }> {
-    const result = await this.submissions.cancel(
-      submissionId,
-      reason ?? "Cancelled",
-    );
-    await this.broadcastApprovals();
-    return result;
-  }
-
-  /**
-   * 按 request ID 停止 Turn，未给 ID 时停止所有未完成提交。
-   *
-   * @remarks
-   * Inbox 的停止控制面或 Agent 内部清理在传输请求结束前调用。
-   *
-   * 复用 SubmissionLifecycle 的批量选择与取消语义，
-   * 避免再从活跃 Pi adapter 反向推断持久记录。
-   */
-  async stopTurn(
-    requestId?: string,
-    reason?: string,
-  ): Promise<{ ok: boolean }> {
-    const result = await this.submissions.stop(
-      requestId,
-      reason ?? "Stopped",
-    );
-    await this.broadcastApprovals();
-    return result;
-  }
-
-  /** Stops every running, queued, or steered user request in this Session. */
-  async stopAllSubmissions(reason?: string): Promise<{ ok: boolean }> {
-    const current = this.db.submissions.findRunning() ??
-      this.db.submissions.findNextPending();
-    if (current) {
-      this.db.transaction(() => {
-        for (const steer of this.db.steers.listForSubmission(
-          current.submissionId,
-        )) {
-          const message = JSON.parse(
-            steer.canonicalJson,
-          ) as PiCanonicalUserInput;
-          const userMessage = steer.uiMessageJson
-            ? JSON.parse(steer.uiMessageJson) as UIMessage & { role: "user" }
-            : undefined;
-          this.transcript.append(steer.messageId, message, {
-            submissionId: current.submissionId,
-            ...(userMessage ? { userMessage } : {}),
-          });
-          this.db.steers.deleteByMessageId(steer.messageId);
-        }
-      });
-    }
-    const result = await this.submissions.stopAll(reason ?? "Stopped");
-    await this.broadcastApprovals();
-    return result;
-  }
-
-  /** 返回当前已装配 User Agent 的执行档位，不提供 Session 覆盖。 */
-  executionLevel(): ExecutionLevel {
-    return this.assembly().profile.executionLevel;
-  }
-
-  /**
-   * 读取一条仍待决定的 Tool 或临时 Agent 执行。
-   *
-   * @remarks
-   * Host 在处理 `allow_level` 前读取可信的 Tool 所需档位，客户端不能提交目标档位。
-   */
-  getPendingApproval(executionId: string): ApprovalReceipt | null {
-    const temporary = this.temporaryAgentApprovals.get(executionId);
-    if (temporary) return temporary.receipt;
-    const approval = this.approvals.read(executionId);
-    if (!approval || approval.status !== "pending") return null;
-    return {
-      executionId: approval.executionId,
-      source: approval.source,
-      action: approval.toolName,
-      summary: approval.summary,
-      executionLevel: approval.executionLevel,
-      requiredExecutionLevel: approval.requiredExecutionLevel,
-      inputJson: approval.inputJson,
-      requestId: approval.requestId,
-    };
-  }
-
-  /**
-   * 把客户端投递的响应作为某次 Tool 调用的结果，并续跑原 Turn。
-   *
-   * @remarks
-   * 前端经 WS RPC 调用，只带 `toolCallId` —— 它不知道 submissionId，也不该知道。
-   *
-   * 这是「结果由客户端提供」的 Tool 的唯一入口。与审批不同，这里没有任何业务身份
-   * （审批的 `allow_level` 要改 User Agent 授权档位，所以必须经 Host），因此留在 Runtime。
-   *
-   * 查无、已结算、Tool 未声明 `interaction`、响应体不过校验，一律返回 `{ ok: false }` 而不抛 ——
-   * 口径对齐 `cancelSubmissionById`：客户端重复点击不该看到异常。
-   */
-  async respondToolInteraction(
-    toolCallId: string,
-    response: unknown,
-  ): Promise<{ ok: boolean }> {
-    const pending = this.interactions.findPending(toolCallId);
-    if (!pending) return { ok: false };
-    const submission = this.readSubmission(pending.submissionId);
-    if (!submission) return { ok: false };
-    await this.ensureRuntimeReady();
-
-    const adapter = this.createSubmissionExecutionAdapter(submission);
-    const spec = adapter.interactionSpec(pending.toolName);
-    if (!spec) return { ok: false };
-
-    const input = safeParseJson(pending.inputJson);
-    if (!spec.validateResponse(input, response)) return { ok: false };
-    const prepared = await this.prepareToolInteractionResponse({
-      toolCallId,
-      toolName: pending.toolName,
-      toolInput: input,
-      response,
-    });
-    if (prepared === null || !spec.validateResponse(input, prepared)) {
-      return { ok: false };
-    }
-    const settled = spec.settle
-      ? spec.settle(input, prepared)
-      : defaultInteractionResult(prepared);
-    return this.interactions.respond(pending.interactionId, prepared, settled);
-  }
-
-  /**
-   * 对一条待处理执行应用一次允许或拒绝决定。
-   *
-   * @remarks
-   * `allow_level` 必须由 Host 先更新 User Agent，再以 `allow_once` 续跑当前固定 Turn。
-   */
-  async decideApproval(
-    executionId: string,
-    decision: ApprovalDecision,
-  ): Promise<{ ok: boolean }> {
-    if (decision.decision === "allow_level") {
-      throw new Error(
-        "allow_level must be applied by the User Agent Host before resuming the Tool",
-      );
-    }
-    const temporary = this.temporaryAgentApprovals.get(executionId);
-    if (temporary) {
-      this.temporaryAgentApprovals.delete(executionId);
-      temporary.resolve(
-        decision.decision === "allow_once"
-          ? { approved: true }
-          : { approved: false, reason: decision.reason },
-      );
-      if (temporary.submissionId) {
-        this.telemetry.capture("approvalDecided", {
-          submissionId: temporary.submissionId!,
-          toolCallId: temporary.toolCallId,
-          executionId,
-          decision: decision.decision === "allow_once"
-            ? "approved"
-            : "rejected",
-          ...(decision.decision === "deny" && decision.reason
-            ? { reason: decision.reason }
-            : {}),
-        });
-      }
-      await this.broadcastApprovals();
-      return { ok: true };
-    }
-    return this.approvals.decide(executionId, decision);
-  }
-
-  // 作用：在用户做出持久 Tool 审批决定后续跑对应 Submission。
-  // 调用：Cloudflare Agents SDK 按 `schedule` 保存的回调名唤醒 Agent 时调用。
-  // 原因：审批等待可跨 Durable Object 休眠，因此续跑必须重读持久决定、去重 Tool 结果并重进恢复入口。
-  async _piApprovalContinuation(
-    data?: ApprovalContinuationData,
-  ): Promise<void> {
-    if (!data?.submissionId || !data.approvalExecutionId) return;
-    const submission = this.readSubmission(data.submissionId);
-    if (!submission || isTerminalSubmissionStatus(submission.status)) {
-      return;
-    }
-    const approval = this.approvals.read(data.approvalExecutionId);
-    if (!approval) {
-      await this.submissions.finish(
-        submission,
-        "failed",
-        `Approval continuation is missing: ${data.approvalExecutionId}`,
-      );
-      return;
-    }
-    await this.ensureRuntimeReady();
-    try {
-      await this.assertPinnedSubmission(submission);
-      let decision = await this.materializeRecoveredToolResults(
-        submission,
-      );
-      if (approval.status === "approved") {
-        const settled = this.readToolSettlement(
-          submission.submissionId,
-          approval.toolCallId,
-        );
-        if (!settled) {
-          const adapter = this.createSubmissionExecutionAdapter(submission);
-          let available = true;
-          try {
-            available = await adapter.retryTool({
-              toolName: approval.toolName,
-              toolCallId: approval.toolCallId,
-              input: JSON.parse(approval.inputJson),
-            });
-          } catch {
-            // The governed Tool persisted its bounded error ToolResult.
-          }
-          if (!available) {
-            throw new Error(
-              `Approved Tool is denied: ${approval.toolName}`,
-            );
-          }
-          if (!this.readToolSettlement(
-            submission.submissionId,
-            approval.toolCallId,
-          )) {
-            throw new Error(
-              `Approved Tool produced no durable settlement: ${approval.toolName}`,
-            );
-          }
-        }
-        decision = await this.materializeRecoveredToolResults(
-          submission,
-        );
-      }
-      if (approval.status === "rejected") {
-        decision = await this.materializeRecoveredToolResults(
-          submission,
-        );
-      }
-      const result = decision.recoveredToolSettlements.find(
-        (item) => item.message.toolCallId === approval.toolCallId,
-      );
-      if (!result) {
-        throw new Error(
-          `Approval continuation has no ToolResult: ${approval.toolCallId}`,
-        );
-      }
-      await this.submissions.recover(submission.submissionId);
-    } catch (error) {
-      await this.submissions.finish(
-        submission,
-        "failed",
-        errorText(error),
-      );
-    }
-  }
-
-  // 作用：为一个让步执行片排一次兜底唤醒。
-  // 调用：`executeNonTerminalSubmission` 排出计划续跑之后立即调用。
-  // 原因：计划续跑只有一次机会 —— schedule 抛错、alarm 回调抛错、实例中途被换掉，
-  // 这一轮就再也没人唤醒了。看门狗是唯一能兜住未知丢失路径的东西；
-  // 它按续跑标识判断有没有推进，所以正常情况下醒来即空转返回。
-  private async scheduleContinuationWatchdog(
-    submissionId: string,
-    requestId: string,
-    continuationId: string,
-  ): Promise<void> {
-    try {
-      await this.schedule(
-        CONTINUATION_WATCHDOG_SECONDS,
-        "_piContinuationWatchdog",
-        { submissionId, requestId, continuationId },
-        { idempotent: true },
-      );
-    } catch (error) {
-      // 看门狗排不上不该反过来杀掉这一轮：计划续跑本身已经排好了。
-      console.warn(
-        "[pi-continuation-watchdog:degraded]",
-        json({ submissionId, error: errorText(error) }),
-      );
-    }
-  }
-
-  // 判断一条让步提交是否仍停在 `continuationId` 这一片上。
-  // 计划续跑和看门狗都用它决定该不该接手，避免和更新的执行片重复派发。
-  //
-  // `allowUnrecorded` 给看门狗用：让步的落库万一没生效（记录已不在
-  // pending/running），`continuationId` 会是 null，此时严格比对会把续跑和看门狗
-  // 一起丢掉 —— 那正是这次要根除的静默挂死。计划续跑不放宽，它的职责就是去重。
-  private stalledOnContinuation(
-    data: PlannedContinuationData,
-    { allowUnrecorded = false }: { allowUnrecorded?: boolean } = {},
-  ): StoredSubmission | null {
-    const submission = this.readSubmission(data.submissionId);
-    if (
-      !submission ||
-      submission.requestId !== data.requestId ||
-      isTerminalSubmissionStatus(submission.status)
-    ) {
-      return null;
-    }
-    const onThisSlice = submission.continuationId === data.continuationId ||
-      (allowUnrecorded && submission.continuationId === null);
-    return onThisSlice ? submission : null;
-  }
-
-  async _piPlannedContinuation(
-    data?: PlannedContinuationData,
-  ): Promise<void> {
-    if (!data?.submissionId || !data.requestId || !data.continuationId) return;
-    // 校验续跑标识:两条 alarm 同时到期时，晚到的那条对应的已经是上一片，
-    // 放它进去会白跑一整个执行片。
-    const submission = this.stalledOnContinuation(data);
-    if (!submission) return;
-    await this.submissions.continueAfterCurrent(submission.submissionId);
-  }
-
-  /**
-   * 在计划续跑丢失时接手一条让步提交。
-   *
-   * @remarks
-   * Agents SDK 的调度器在 `scheduleContinuationWatchdog` 排的延时任务到期时按方法名调用。
-   *
-   * 正常情况下这一片早就推进了（`continuationId` 已换或已终态），此时直接返回。
-   *
-   * 走 `recover` 而不是 `continueAfterCurrent`，有两个都不能省的理由：
-   * 一是续跑会丢通常就是实例中途没了，那属于崩溃，必须重放里程碑、补齐半路的
-   * Tool，续跑模式恰恰跳过这些；二是这一轮可能正停在审批或客户端交互上等人
-   * （被驱逐后内存里没有执行器，看起来就像「没人在跑」），只有恢复准备认得出
-   * 这是合法停靠并原样放过 —— 续跑模式会直接在它上面重起一轮。
-   *
-   * `recover` 复用 `executions` 的实例内去重，因此和一片刚进序幕、还没登记执行器的
-   * 竞态也一并合流，不会多跑一片。
-   */
-  async _piContinuationWatchdog(
-    data?: PlannedContinuationData,
-  ): Promise<void> {
-    if (!data?.submissionId || !data.requestId || !data.continuationId) return;
-    const submission = this.stalledOnContinuation(data, {
-      allowUnrecorded: true,
-    });
-    if (!submission) return;
-    try {
-      await this.ensureRuntimeReady();
-      await this.submissions.recover(submission.submissionId);
-    } catch (error) {
-      const latest = this.readSubmission(data.submissionId);
-      if (latest && !isTerminalSubmissionStatus(latest.status)) {
-        await this.submissions.finish(
-          latest,
-          "failed",
-          `SpringBrand could not continue this turn: ${errorText(error)}`,
-        );
-      }
-    }
-  }
-
-  // 作用：Agent Tool 子运行开始后重算一次活动投影。
-  // 调用：Agents SDK 在登记子运行后调用。
-  // 原因：分离的子运行不进 Submission 表，不在这里重算，Host 的列表会显示成已经空闲。
-  override async onAgentToolStart(run: AgentToolRunInfo): Promise<void> {
-    await super.onAgentToolStart(run);
-    const metadata = runtimeSubagentRunMetadata(run.inputPreview);
-    if (metadata) {
-      await this.subagentLifecycle(metadata).register(run.runId);
-      this.telemetry.capture("subagentStarted", {
-        submissionId: metadata.submissionId,
-        ...(run.parentToolCallId
-          ? { toolCallId: run.parentToolCallId }
-          : {}),
-        subagentId: run.runId,
-        agentType: run.agentType,
-        occurredAt: run.startedAt,
-      });
-    }
-    await this.broadcastApprovals();
-  }
-
-  // 作用：Agent Tool 子运行结束后重算一次活动投影。
-  // 调用：Agents SDK 在子运行进入终态或被中断后调用。
-  // 原因：中断且子进程仍在跑时活动不能落回空闲，判定只在 `hasRunningAgentTools` 一处。
-  override async onAgentToolFinish(
-    run: AgentToolRunInfo,
-    result: AgentToolLifecycleResult,
-  ): Promise<void> {
-    await super.onAgentToolFinish(run, result);
-    const metadata = runtimeSubagentRunMetadata(run.inputPreview);
-    if (metadata) {
-      const lifecycle = this.subagentLifecycle(metadata);
-      await lifecycle.register(run.runId);
-      if (!(result.status === "interrupted" && result.childStillRunning)) {
-        const completion = decodeSubagentCompletion(result.summary);
-        const hasUsage = completion && !isZeroSubagentUsage(completion.usage);
-        const status = subagentTerminalStatus(result.status);
-        if (completion && hasUsage) {
-          await lifecycle.usage({
-            eventId: `${run.runId}:usage`,
-            submissionId: metadata.submissionId,
-            runId: run.runId,
-            subagentRunId: run.runId,
-            parentRunId: metadata.parentRunId,
-            kind: "subagent",
-            status,
-            usage: completion.usage,
-          });
-        }
-        await lifecycle.terminal({
-          subagentRunId: run.runId,
-          status,
-          zeroUsage: !hasUsage,
-        });
-        this.telemetry.capture("subagentFinished", {
-          submissionId: metadata.submissionId,
-          ...(run.parentToolCallId
-            ? { toolCallId: run.parentToolCallId }
-            : {}),
-          subagentId: run.runId,
-          outcome: status === "completed"
-            ? "completed"
-            : status === "aborted" || status === "skipped"
-              ? "cancelled"
-              : "failed",
-          durationMs: Math.max(
-            0,
-            (run.completedAt ?? Date.now()) - run.startedAt,
-          ),
-          ...(completion ? { output: completion.output } : {}),
-          ...(result.error ? { error: result.error } : {}),
-          occurredAt: run.completedAt ?? Date.now(),
-        });
-      }
-    }
-    await this.broadcastApprovals();
-  }
-
-  async _cfDetachedNotifyFinish(
-    run: AgentToolRunInfo,
-    result: AgentToolLifecycleResult,
-  ): Promise<void> {
-    const completion = decodeSubagentCompletion(result.summary);
-    const outcome = result.status === "completed"
-      ? completion
-        ? JSON.stringify(completion.output)
-        : result.summary ?? "Completed without a result."
-      : result.error ?? `Background run ${result.status}.`;
-    await this.submitPrompt(
-      [
-        "A background sub-agent run has finished.",
-        `runId: ${run.runId}`,
-        `status: ${result.status}`,
-        `result: ${outcome}`,
-      ].join("\n"),
-      { idempotencyKey: `detached-agent-tool:${run.runId}:${result.status}` },
-    );
-  }
-
-  // 作用：把审批、队列和 Session 活动投影到 Agent 可广播状态。
-  // 调用：启动、准入、审批变化、interaction 变化、子运行变化和 Turn 完成时调用。
-  // 原因：这些都是可重建的 UI 投影，相同内容不重复 `setState`，投影失败也不能阻断执行。
-  protected async broadcastApprovals(): Promise<void> {
-    try {
-      const approvals = [
-        ...this.approvals.list(),
-        ...[...this.temporaryAgentApprovals.values()].map(
-          ({ receipt }) => receipt,
-        ),
-      ];
-      const running = this.db.submissions.findRunning();
-      const pending = this.db.submissions.listPending();
-      const current = running ?? pending[0];
-      const queued = (running ? pending : pending.slice(1)).map(
-        (submission, index) => {
-          let preview = "Queued message";
-          if (submission.queuedInputJson) {
-            try {
-              const message = JSON.parse(
-                submission.queuedInputJson,
-              ) as PiCanonicalUserInput;
-              preview = (typeof message.content === "string"
-                ? message.content
-                : message.content
-                    .flatMap((part) =>
-                      part.type === "text" ? [part.text] : []
-                    )
-                    .join(" ")
-              ).trim().slice(0, 160) || preview;
-            } catch {
-              // Corrupt payload is surfaced when the queue pump activates it.
-            }
-          }
-          return {
-            submissionId: submission.submissionId,
-            messageId:
-              submission.userMessageId ?? submission.submissionId,
-            preview,
-            position: index + 1,
-            createdAt: submission.createdAt,
-          };
-        },
-      );
-      const turn: RuntimeTurnState = {
-        ...(current
-          ? {
-              activeSubmissionId: current.submissionId,
-              activeMessageId: current.assistantMessageId,
-              ...(current.requestId
-                ? { activeRequestId: current.requestId }
-                : {}),
-              ...(current.recoveryErrorCount === undefined
-                ? {}
-                : {
-                    recoveryAttempt:
-                      current.recoveryReason === "context_overflow"
-                        ? 1
-                        : current.recoveryErrorCount,
-                    // 上限按当前恢复原因取,否则 stall 会显示 "2/5" 却在第 3 次就终止。
-                    recoveryMax:
-                      current.recoveryReason === "context_overflow"
-                        ? 1
-                        : current.recoveryReason ===
-                            "no_meaningful_model_progress"
-                          ? CHAT_STALL_MAX_ATTEMPTS
-                          : current.recoveryReason === "server_tool_timeout"
-                            ? SERVER_TOOL_TIMEOUT_MAX_ATTEMPTS
-                            : CHAT_RECOVERY_MAX_ATTEMPTS,
-                    ...(current.recoveryReason &&
-                        current.recoveryReason !== "context_overflow"
-                      ? { recoveryReason: current.recoveryReason }
-                      : {}),
-                  }),
-            }
-          : {}),
-        steerable: Boolean(
-          current &&
-          this.db.approvals.listPendingForSubmission(
-            current.submissionId,
-          ).length === 0
-        ),
-        hasPendingSteer: Boolean(
-          current &&
-          this.db.steers.listForSubmission(current.submissionId).length > 0
-        ),
-        queued,
-      };
-      // activity 与这里其他字段一样，是当前 DB 的纯函数：不接受调用方的提示，
-      // 也不粘住上一次的值。needs-input 只有一个意思 —— 此刻真挂着一件等人回应
-      // 的事（审批，或结果由客户端结算的 Tool）。可重算因而能自愈：任何一次广播
-      // 都会把陈旧状态冲掉，不需要谁记得来清。
-      const activity: RuntimeActivity = approvals.length > 0 ||
-          (current &&
-            this.interactions.hasPendingForSubmission(current.submissionId))
-        ? "needs-input"
-        : current || queued.length > 0
-          ? "working"
-          : "idle";
-      const backgroundWork = this.db.agentTools.hasRunning();
-      const currentActivity = this.state.activity;
-      const nextActivity = currentActivity?.activity === activity &&
-          currentActivity.backgroundWork === backgroundWork
-        ? currentActivity
-        : {
-            activity,
-            backgroundWork,
-            revision: (currentActivity?.revision ?? 0) + 1,
-          };
-      if (
-        this.state?.approvals === undefined ||
-        json(this.state.approvals) !== json(approvals) ||
-        json(this.state.turn) !== json(turn) ||
-        nextActivity !== currentActivity
-      ) {
-        this.setState({
-          ...this.state,
-          activity: nextActivity,
-          approvals,
-          turn,
-        });
-      }
-      const projection = this.turnEventsPort()?.onActivityChanged?.(nextActivity);
-      if (projection) {
-        this.ctx.waitUntil(
-          projection.catch(() => undefined),
-        );
-      }
-    } catch {
-      // Approval projection is best effort and must not block execution.
-    }
-  }
-
-  // #endregion
-
-}