@springbrand/agent-runtime 0.2.0-alpha.68 → 0.2.0-alpha.70

package/src/pi/assembly/context.ts

@@ -1,3 +1,5 @@
+import { summarizeModelUsage } from "../../model-usage";
+import { BACKGROUND_CONTEXT, withAbortSignal } from "@earendil-works/pi-agent-core/harness/context";
 import {
   buildSessionContext,
   compact as compactPiTranscript,
@@ -7,7 +9,7 @@ import {
   prepareCompaction,
   type AgentMessage,
   type CompactionEntry,
-  type SessionTreeEntry,
+  type Entry,
 } from "@earendil-works/pi-agent-core";
 import type {
   AssistantMessage,
@@ -45,31 +47,9 @@ const COMPACTION_RETRY: RetryPolicy = {
 const COLD_MEMORY_INDEX = "/userspace/memories/MEMORY.md";
 const TRUNCATION_MARKER = "\n[truncated to memory budget]";
 
-function sumUsage(responses: readonly AssistantMessage[]): Usage | undefined {
-  const first = responses[0];
-  if (!first) return undefined;
-
-  const total = structuredClone(first.usage);
-  for (const response of responses.slice(1)) {
-    const usage = response.usage;
-    total.input += usage.input;
-    total.output += usage.output;
-    total.cacheRead += usage.cacheRead;
-    total.cacheWrite += usage.cacheWrite;
-    if (usage.cacheWrite1h !== undefined) {
-      total.cacheWrite1h = (total.cacheWrite1h ?? 0) + usage.cacheWrite1h;
-    }
-    if (usage.reasoning !== undefined) {
-      total.reasoning = (total.reasoning ?? 0) + usage.reasoning;
-    }
-    total.totalTokens += usage.totalTokens;
-    total.cost.input += usage.cost.input;
-    total.cost.output += usage.cost.output;
-    total.cost.cacheRead += usage.cost.cacheRead;
-    total.cost.cacheWrite += usage.cost.cacheWrite;
-    total.cost.total += usage.cost.total;
-  }
-  return total;
+function compactionUsage(responses: readonly AssistantMessage[], requested: Model<any>) {
+  const [first, ...remaining] = responses;
+  return first ? { modelUsage: summarizeModelUsage(requested, [first, ...remaining]) } : {};
 }
 
 // #region Transcript compaction
@@ -85,7 +65,7 @@ function sumUsage(responses: readonly AssistantMessage[]): Usage | undefined {
  * 核心术语见包入口 `index.ts`。
  */
 export async function compactPiContext(input: Readonly<{
-  branch: readonly SessionTreeEntry[];
+  branch: readonly Entry[];
   compactAfterTokens: number;
   force?: boolean;
   models: Models;
@@ -95,7 +75,7 @@ export async function compactPiContext(input: Readonly<{
   messages: AgentMessage[];
   compactionEntry?: Omit<
     CompactionEntry,
-    "id" | "parentId" | "timestamp"
+    "id" | "parentId" | "seq" | "timestamp"
   >;
   modelUsage?: {
     api: string;
@@ -108,12 +88,14 @@ export async function compactPiContext(input: Readonly<{
   didCompact: boolean;
   degraded: boolean;
 }> {
+  const responses: AssistantMessage[] = [];
   const branch = [...input.branch];
+  const context = input.signal ? withAbortSignal(input.signal, BACKGROUND_CONTEXT) : BACKGROUND_CONTEXT;
   let currentMessages = branch.flatMap((entry) =>
     entry.type === "message" ? [entry.message] : []
   );
   try {
-    currentMessages = buildSessionContext(branch).messages;
+    currentMessages = await buildSessionContext(branch, undefined, context);
     const settings = DEFAULT_COMPACTION_SETTINGS;
     if (
       !settings.enabled ||
@@ -133,6 +115,7 @@ export async function compactPiContext(input: Readonly<{
         messages: currentMessages,
         didCompact: false,
         degraded: true,
+        ...compactionUsage(responses, input.model),
       };
     }
     if (!preparation.value) {
@@ -143,7 +126,6 @@ export async function compactPiContext(input: Readonly<{
       };
     }
 
-    const responses: AssistantMessage[] = [];
     const models = {
       completeSimple: async (
         model: Model<any>,
@@ -152,6 +134,7 @@ export async function compactPiContext(input: Readonly<{
       ) => {
         const response = await input.models.completeSimple(model, context, options);
         responses.push(response);
+        input.signal?.throwIfAborted();
         return response;
       },
     } as Models;
@@ -160,46 +143,38 @@ export async function compactPiContext(input: Readonly<{
       models,
       input.model,
       undefined,
-      input.signal,
       undefined,
       COMPACTION_RETRY,
+      undefined,
+      context,
     );
     if (!compacted.ok) {
       return {
         messages: currentMessages,
         didCompact: false,
         degraded: true,
+        ...compactionUsage(responses, input.model),
       };
     }
 
     const compactionEntry = {
       type: "compaction",
+      fromHook: false,
       ...compacted.value,
     } satisfies Omit<
       CompactionEntry,
-      "id" | "parentId" | "timestamp"
+      "id" | "parentId" | "seq" | "timestamp"
     >;
     const previewEntry: CompactionEntry = {
       ...compactionEntry,
       id: `compaction-preview:${branch[branch.length - 1]?.id ?? "root"}`,
       parentId: branch[branch.length - 1]?.id ?? null,
-      timestamp: new Date().toISOString(),
+      timestamp: Date.now(),
+      seq: (branch.at(-1)?.seq ?? 0) + 1,
     };
-    const firstResponse = responses[0];
-    const responseModel = firstResponse?.responseModel && responses.every(
-        (response) => response.responseModel === firstResponse.responseModel,
-      )
-      ? firstResponse.responseModel
-      : undefined;
-    const stopReason = firstResponse && responses.every(
-        (response) => response.stopReason === firstResponse.stopReason,
-      )
-      ? firstResponse.stopReason
-      : undefined;
-    const usage = sumUsage(responses);
-    const messages = buildSessionContext(
-      [...branch, previewEntry],
-    ).messages;
+    const messages = await buildSessionContext(
+      [...branch, previewEntry], undefined, context,
+    );
     if (
       input.force &&
       messages.reduce((total, message) => total + estimateTokens(message), 0) >=
@@ -212,23 +187,13 @@ export async function compactPiContext(input: Readonly<{
         messages: currentMessages,
         didCompact: false,
         degraded: true,
+        ...compactionUsage(responses, input.model),
       };
     }
     return {
       messages,
       compactionEntry,
-      ...(firstResponse && usage
-        ? {
-            modelUsage: {
-              api: firstResponse.api,
-              provider: firstResponse.provider,
-              model: firstResponse.model,
-              ...(responseModel ? { responseModel } : {}),
-              ...(stopReason ? { stopReason } : {}),
-              usage,
-            },
-          }
-        : {}),
+      ...compactionUsage(responses, input.model),
       didCompact: true,
       degraded: false,
     };
@@ -237,6 +202,7 @@ export async function compactPiContext(input: Readonly<{
       messages: currentMessages,
       didCompact: false,
       degraded: true,
+      ...compactionUsage(responses, input.model),
     };
   }
 }

package/src/pi/runtime-adapter/assembly.ts

@@ -51,6 +51,7 @@ interface PiAssemblySnapshot {
   readonly bindings: {
     readonly platform: Pick<RuntimePlatformPort, "loader">;
     readonly workspace?: RuntimeBindings["workspace"];
+    readonly mcp?: RuntimeBindings["mcp"];
   };
 }
 
@@ -390,10 +391,13 @@ async function preparePiAssembly(
     ...(options.gatewaySession
       ? createPiGatewayToolCandidates(options.gatewaySession)
       : []),
-    ...createPiMcpToolCandidates(
+    ...await createPiMcpToolCandidates(
       options.mcpHost,
-      snapshot.profile.mcpServers,
+      snapshot.profile.mcpServers.filter(server => !server.hostManaged),
     ),
+    ...(snapshot.bindings.mcp
+      ? await createPiMcpToolCandidates(snapshot.bindings.mcp, snapshot.bindings.mcp.servers)
+      : []),
   ]);
   return Object.freeze({
     loaded: extensions.loaded,

package/src/pi/runtime-adapter/execution.ts

@@ -1,9 +1,9 @@
 import {
-  Agent as PiCore,
+  runAgentLoopContinue,
   convertToLlm,
   type AgentEvent,
   type AgentMessage,
-  type AgentOptions,
+  type AgentLoopConfig,
   type ThinkingLevel,
 } from "@earendil-works/pi-agent-core";
 import type {
@@ -114,7 +114,7 @@ interface PiTurnAdapterOptions {
   readonly models: Models;
   readonly modelSessionId: string;
   // 读取这次执行真正要交给 Pi 的 canonical transcript。
-  // PiTurnAdapter.run 在创建 PiCore 前调用它，宿主应返回当时最新的 transcript。
+  // PiTurnAdapter.run 在创建 Pi Loop 前调用它，宿主应返回当时最新的 transcript。
   // 这里保留为延迟读取，是为了避免适配器创建后新增的恢复消息被旧快照漏掉。
   readonly canonicalMessages: () => Promise<readonly AgentMessage[]>;
   // 把工具的最终结果交回宿主持久化。
@@ -124,10 +124,9 @@ interface PiTurnAdapterOptions {
     call: SettledPiToolCall,
   ) => void | Promise<void>;
   readonly onGeneration?: PiGenerationLifecycleObserver;
-  // 在模型调用前调整 Pi 的消息上下文。
-  // PiCore 通过 AgentOptions.transformContext 调用它，Runtime 用它接入现有上下文处理。
+  // 在模型调用前通过 AgentLoopConfig.transformContext 调整上下文。
   // 直接复用 Pi 的回调类型可避免这里维护另一套上下文转换约定。
-  readonly transformContext: NonNullable<AgentOptions["transformContext"]>;
+  readonly transformContext: NonNullable<AgentLoopConfig["transformContext"]>;
   readonly workspace?: SpillWorkspace;
   // 之前的执行片已经用掉的模型回合数。首次执行传 0。
   readonly modelTurnsConsumed: number;
@@ -137,7 +136,7 @@ interface PiTurnAdapterOptions {
  * 收集那些结果已经由工具自己收口的 Tool 名字。
  *
  * @remarks
- * `run` 在建 PiCore 前调用，把结果交给 `projectToolResultsForModel`。
+ * `run` 在建 Pi Loop 前调用，把结果交给 `projectToolResultsForModel`。
  *
  * `outputBudget: "structure"` 的语义就是“这个结果不需要 Runtime 再替它省”：read
  * 按页返回并在页脚写明覆盖的行号，activate_skill 返回的是模型接下来要照做的指令，
@@ -216,8 +215,6 @@ function orderLateToolResultsBeforeTurnAbortMarker(
 }
 
 class PiTurnAdapter {
-  private piInstance?: PiCore;
-  private abortRequested = false;
   private readonly pendingSteers: UserMessage[] = [];
   private readonly governance: PiToolGovernance;
 
@@ -255,25 +252,16 @@ class PiTurnAdapter {
     return true;
   }
 
-  // 在 Pi 运行实例可用后尽快停止这个 Turn。
-  // Runtime 可能在 run() 之前或期间发出取消，因此尚未创建 PiCore 时先记住请求。
-  // canonical transcript 读取是异步的，其间没有可中止的 Pi 实例，所以不能删掉启动前标记。
-  abort(): void {
-    if (this.piInstance) this.piInstance.abort();
-    else this.abortRequested = true;
-  }
-
   // 把一条用户消息排入当前 Turn。
   // 提交仍在运行时收到扩展宿主消息，Runtime 会调用这里。
-  // PiCore 创建前先缓冲消息，可覆盖异步启动窗口，同时不引入第二份 transcript 来源。
+  // Pi Loop 创建前先缓冲消息，可覆盖异步启动窗口，同时不引入第二份 transcript 来源。
   steer(message: UserMessage): void {
-    if (this.piInstance) this.piInstance.steer(message);
-    else this.pendingSteers.push(message);
+    this.pendingSteers.push(message);
   }
 
   // 从当前 canonical transcript 继续运行 Pi，并把生命周期事件交给监听器。
   // Submission 的首次执行或恢复执行取得 Pinned Runtime 后，PreparedPiTurnAdapter 调用这里。
-  // 每次新建 PiCore 可隔离运行状态；等待订阅回调并在 finally 清理可保住 Pi 的事件屏障语义。
+  // 每次运行持有独立上下文；Loop 等待事件 sink 完成后才继续。
   async run(
     opts: {
       readonly systemPrompt: string;
@@ -285,6 +273,7 @@ class PiTurnAdapter {
     const { systemPrompt, signal } = opts;
     signal?.throwIfAborted();
     const canonicalMessages = await this.opts.canonicalMessages();
+    signal?.throwIfAborted();
     const tools = this.compile(opts.tools);
     const selfBounded = selfBoundedToolNames(opts.tools);
     // `modelTurns` 是跨执行片的累计数，`sliceTurns` 只数本片 —— 前者管任务预算，
@@ -292,16 +281,14 @@ class PiTurnAdapter {
     let modelTurns = this.opts.modelTurnsConsumed;
     let sliceTurns = 0;
     let reachedModelTurnLimit = false;
-    let wrappingUp = false;
+    let wrapUpMessage: UserMessage | undefined;
     let wrapUpTurns = 0;
-    const pi = new PiCore({
+    const config: AgentLoopConfig = {
+      model: this.opts.pi.model,
+      reasoning: this.opts.pi.thinkingLevel === "off" ? undefined : this.opts.pi.thinkingLevel,
+      toolExecution: "parallel",
       convertToLlm,
-      streamFn: withProviderRetry(
-        this.opts.models.streamSimple.bind(this.opts.models),
-        0,
-        this.opts.modelSessionId,
-        this.opts.onGeneration,
-      ),
+      getSteeringMessages: async () => this.pendingSteers.splice(0, 1),
       // transformMessages 在宿主上下文变换之后运行，确保跨 provider 的 tool call ID 格式兼容。
       // OpenAI Responses API 生成含 `|` 的 450+ 字符 ID，Anthropic 只接受 ^[a-zA-Z0-9_-]+$(64 字符上限)；
       // 切换 provider 或消息跨 provider 回放时若不规范化，provider 会静默拒绝。
@@ -309,50 +296,36 @@ class PiTurnAdapter {
         const ctx = await this.opts.transformContext(messages, signal);
         return transformMessages(
           orderLateToolResultsBeforeTurnAbortMarker(
-            projectToolResultsForModel(ctx, selfBounded),
+            projectToolResultsForModel(
+              wrapUpMessage ? [...ctx, wrapUpMessage] : ctx,
+              selfBounded,
+            ),
           ) as Message[],
           this.opts.pi.model,
         ) as AgentMessage[];
       },
       afterToolCall: this.governance.afterToolCall,
-      // Pi 在每个 turn_end 之后先调 prepareNextTurn、再调 shouldStopAfterTurn，
-      // 所以回合计数记在这里，停止判据只读不写。
-      // 用 `WithContext` 变体：只有它拿得到当前上下文，也就拿得到工具表和消息。
-      prepareNextTurnWithContext: ({ context }) => {
-        modelTurns += 1;
-        sliceTurns += 1;
-        if (wrappingUp) {
-          wrapUpTurns += 1;
-          return undefined;
-        }
+      // Pi calls this only when another model turn is needed; counting belongs to turn_end.
+      prepareNextTurn: ({ context }) => {
+        if (wrapUpMessage) return undefined;
         const toolFailureLimitReached = this.governance.wrapUpRequested();
         if (
           !toolFailureLimitReached &&
           modelTurns < MAX_MODEL_TURNS_PER_SUBMISSION - 1
         ) return undefined;
-        // 预算见底或工具熔断：清空工具表并注入收尾指令，逼出一条真正的
-        // 终止助手消息。直接判失败的话用户拿不到任何交代。
-        // 这条指令不进 newMessages，因此不会写进 transcript —— 它是控制指令，不是历史。
-        wrappingUp = true;
-        return {
-          context: {
-            ...context,
-            tools: [],
-            messages: [
-              ...context.messages,
-              {
-                role: "user" as const,
-                content: [{
-                  type: "text" as const,
-                  text: toolFailureLimitReached
-                    ? TOOL_FAILURE_WRAP_UP_MESSAGE
-                    : WRAP_UP_MESSAGE,
-                }],
-                timestamp: Date.now(),
-              },
-            ],
-          },
+        // Control instructions enter only the model projection, after official compaction.
+        // Keeping them out of Loop history preserves its canonical transcript boundary.
+        wrapUpMessage = {
+          role: "user",
+          content: [{
+            type: "text",
+            text: toolFailureLimitReached
+              ? TOOL_FAILURE_WRAP_UP_MESSAGE
+              : WRAP_UP_MESSAGE,
+          }],
+          timestamp: Date.now(),
         };
+        return { context: { ...context, tools: [] } };
       },
       shouldStopAfterTurn: () => {
         if (signal?.aborted === true) return true;
@@ -360,46 +333,34 @@ class PiTurnAdapter {
         // 不等于「不再有上限」：Pi 在这之后还会取 steering 和 follow-up 消息，
         // 一直有新消息进来就会一直发模型请求，而且全在同一个 invocation 里 ——
         // 那正是 MAX_MODEL_TURNS_PER_SLICE 要挡的 CPU 驱逐。
-        if (wrappingUp) return wrapUpTurns >= MAX_WRAP_UP_TURNS;
+        if (wrapUpMessage) return wrapUpTurns >= MAX_WRAP_UP_TURNS;
+        if (this.governance.wrapUpRequested() || modelTurns >= MAX_MODEL_TURNS_PER_SUBMISSION - 1) return false;
         reachedModelTurnLimit = sliceTurns >= MAX_MODEL_TURNS_PER_SLICE;
         return reachedModelTurnLimit;
       },
-      initialState: {
-        model: this.opts.pi.model,
-        systemPrompt,
-        messages: [...canonicalMessages],
-        tools: [...tools],
-        ...(this.opts.pi.thinkingLevel !== undefined
-          ? { thinkingLevel: this.opts.pi.thinkingLevel }
-          : {}),
+    };
+    await runAgentLoopContinue(
+      { systemPrompt, messages: [...canonicalMessages], tools: [...tools] },
+      config,
+      async (event) => {
+        await listener(event);
+        if (event.type === "turn_end") {
+          modelTurns += 1;
+          sliceTurns += 1;
+          if (wrapUpMessage) wrapUpTurns += 1;
+        }
       },
-    });
-
-    this.piInstance = pi;
-    for (const message of this.pendingSteers.splice(0)) {
-      pi.steer(message);
-    }
-    const unsubscribe = pi.subscribe(listener);
-    // 把调用方的 AbortSignal 转发给只存在于本方法内的 Pi 运行实例。
-    // continue() 尚未结束时信号监听器会调用它，所有退出路径都在 finally 中移除监听。
-    // addEventListener 和 removeEventListener 必须使用同一函数引用，因此这里保留稳定的局部函数。
-    const abort = (): void => pi.abort();
-    signal?.addEventListener("abort", abort, { once: true });
-    try {
-      const running = pi.continue();
-      if (this.abortRequested) {
-        this.abortRequested = false;
-        pi.abort();
-      }
-      await running;
-      return reachedModelTurnLimit
-        ? { kind: "yielded", modelTurns }
-        : { kind: "terminal", modelTurns };
-    } finally {
-      signal?.removeEventListener("abort", abort);
-      unsubscribe();
-      if (this.piInstance === pi) this.piInstance = undefined;
-    }
+      signal,
+      withProviderRetry(
+        this.opts.models.streamSimple.bind(this.opts.models),
+        0,
+        this.opts.modelSessionId,
+        this.opts.onGeneration,
+      ),
+    );
+    return reachedModelTurnLimit
+      ? { kind: "yielded", modelTurns }
+      : { kind: "terminal", modelTurns };
   }
 }
 
@@ -429,7 +390,7 @@ export interface PiToolInputRecord {
  *
  * @remarks
  * Runtime 为每个 Submission 实现这个端口，PreparedPiTurnAdapter 会在审批和 Tool 执行前后调用它。
- * 持久化留在 PiCore 之外，恢复流程才能从 Runtime 数据库重建决定，而不是依赖已丢失的内存状态。
+ * 持久化留在 Pi Loop 之外，恢复流程才能从 Runtime 数据库重建决定，而不是依赖已丢失的内存状态。
  */
 export interface PiTurnDurability {
   /**
@@ -487,7 +448,7 @@ export interface PiTurnDurability {
  *
  * @remarks
  * Submission 首次执行或恢复时，Runtime 把它传给 PiRuntimeAdapter.createTurn。
- * 这些回调让 transcript、持久化状态、流投影和终态仍由 Runtime 负责，避免在 PiCore 内复制一份。
+ * 这些回调让 transcript、持久化状态、流投影和终态仍由 Runtime 负责，避免在 Pi Loop 内复制一份。
  * Runtime、Submission、Turn、Prepared Runtime、Pinned Runtime、Tool candidate 和 transcript 沿用 `./index.ts` 的统一定义。
  */
 export interface CreatePreparedPiTurnOptions {
@@ -508,7 +469,7 @@ export interface CreatePreparedPiTurnOptions {
   /**
    * 在 Pi 启动前读取最新 canonical transcript。
    *
-   * PiTurnAdapter.run 在创建 PiCore 前调用它，Runtime 应返回 transcript 当时已提交的消息。
+   * PiTurnAdapter.run 在创建 Pi Loop 前调用它，Runtime 应返回 transcript 当时已提交的消息。
    * 延迟读取可纳入适配器创建后才物化的恢复结果，不能提前固化为数组快照。
    */
   readonly canonicalMessages: () => Promise<readonly AgentMessage[]>;
@@ -557,10 +518,10 @@ export interface CreatePreparedPiTurnOptions {
   /**
    * 调整 Pi 即将发送给模型的消息上下文。
    *
-   * PiCore 在每次模型调用前使用它，Runtime 通过这里接入现有上下文处理。
-   * 直接沿用 AgentOptions 的类型可确保参数和取消信号与 Pi 保持一致。
+   * Pi Loop 在每次模型调用前使用它，Runtime 通过这里接入现有上下文处理。
+   * 直接沿用 AgentLoopConfig 的类型可确保参数和取消信号与 Pi 保持一致。
    */
-  readonly transformContext: NonNullable<AgentOptions["transformContext"]>;
+  readonly transformContext: NonNullable<AgentLoopConfig["transformContext"]>;
   /**
    * 在提交终止助手消息前读取已保存的取消原因。
    *
@@ -681,7 +642,7 @@ export class PreparedPiTurnAdapter {
       tool: {
         ...candidate.tool,
         // 只在 Runtime 的持久化和策略门禁都放行后执行一个 Tool candidate。
-        // 实时运行由 PiCore 调用它，恢复或审批续跑则由 retryTool 进入同一路径。
+        // 实时运行由 Pi Loop 调用它，恢复或审批续跑则由 retryTool 进入同一路径。
         // 顺序不能随便调整：门禁先于结果复用，审批可能生成结果，不确定的非幂等工作不能重放。
         execute: async (toolCallId, input, signal, onUpdate) => {
           if (toolCallIdPrefix) {
@@ -915,11 +876,10 @@ export class PreparedPiTurnAdapter {
    *
    * @remarks
    * 活动提交被中止时 Runtime 会调用它，包括仍在异步启动的阶段。
-   * 转交给 PiTurnAdapter 可保留启动前取消标记；run() 之前还没有可直接调用的 PiCore。
+   * 同一取消信号覆盖历史读取、Loop 和工具重试。
    */
   abort(): void {
     this.abortController.abort();
-    this.turn.abort();
   }
 
   /**
@@ -941,7 +901,7 @@ export class PreparedPiTurnAdapter {
    *
    * @remarks
    * 当前提交仍活动时收到消息，Runtime 的扩展宿主会调用它。
-   * 转交后，启动前缓冲和 PiCore 转向队列共用一条路径；只有没有活动 Turn 时调用方才应直接追加 transcript。
+   * 启动前与运行中都进入同一队列，Loop 每次消费一条；空闲时调用方直接追加 transcript。
    */
   steer(
     message: UserMessage,
@@ -992,7 +952,7 @@ export class PreparedPiTurnAdapter {
   }
 
   /**
-   * 运行这个 Turn，直到 PiCore 和所有等待中的事件回调结束。
+   * 运行这个 Turn，直到 Pi Loop 和所有等待中的事件回调结束。
    *
    * @remarks
    * Submission 首次执行和续跑时，Runtime 都会在可恢复聊天任务中调用它。
@@ -1002,13 +962,16 @@ export class PreparedPiTurnAdapter {
     options: PiPreparedTurnRunOptions,
   ): Promise<PiTurnRunResult> {
     this.terminalIntent = undefined;
+    const signal = options.signal
+      ? AbortSignal.any([options.signal, this.abortController.signal])
+      : this.abortController.signal;
     const result = await this.turn.run(
       {
         systemPrompt: this.systemPrompt,
         tools: this.candidates,
-        signal: options.signal,
+        signal,
       },
-      (event) => this.handleEvent(event),
+      (event) => this.handleEvent(event, signal),
     );
     if (this.terminalIntent) {
       await this.options.onTerminal(this.terminalIntent);
@@ -1018,9 +981,9 @@ export class PreparedPiTurnAdapter {
   }
 
   // 提交完成的 Pi 消息、推导终态意图，并把事件投影给可恢复流。
-  // PiTurnAdapter 会对每个 AgentEvent 调用它，PiCore 会等待该 Promise 后再越过订阅事件屏障。
+  // Loop 等待每个事件的 Promise，canonical 提交失败时直接拒绝本次执行。
   // canonical message 先于流投影提交，恢复才不会依赖仅供浏览器消费的记录；调整顺序必须复核 recovery effect。
-  private async handleEvent(event: AgentEvent): Promise<void> {
+  private async handleEvent(event: AgentEvent, signal: AbortSignal): Promise<void> {
     if (
       event.type === "tool_execution_start" &&
       !this.candidates.some(({ tool }) => tool.name === event.toolName)
@@ -1068,6 +1031,7 @@ export class PreparedPiTurnAdapter {
     if (event.type === "message_end") {
       const message = event.message;
       if (message.role === "assistant") {
+        if (message.stopReason === "deferred") throw new Error("Deferred Pi responses are not supported by this Runtime");
         if (isContextOverflow(message, this.contextWindow)) {
           throw new ContextOverflowError(
             message.errorMessage ?? "Model context window overflow",
@@ -1109,7 +1073,7 @@ export class PreparedPiTurnAdapter {
         message.role === "assistant" ||
         message.role === "toolResult"
       ) {
-        const abortReason = this.options.abortReason?.();
+        const abortReason = this.options.abortReason?.() ?? (signal.aborted ? "Turn aborted" : undefined);
         const authoritativeMessage =
           message.role === "assistant" &&
           message.stopReason !== "toolUse" &&

package/src/pi/runtime-adapter/index.ts

@@ -98,12 +98,12 @@ export class PiRuntimeAdapter {
    * 不要把 RuntimeDatabase 直接传进 Pi 层；持久化职责应继续通过这里的窄回调提供。
    */
   createTranscript(options: {
-    readonly sql: SqlTaggedTemplate;
+    readonly storage: DurableObjectStorage;
     readonly durability: PiTranscriptDurability;
     readonly hasActiveTurn: () => boolean;
   }): PiRuntimeTranscript {
     return new PiRuntimeTranscript(
-      options.sql,
+      options.storage,
       options.durability,
       this.models,
       options.hasActiveTurn,
@@ -224,8 +224,7 @@ export class PiRuntimeAdapter {
    * @remarks
    * 调用方：Runtime 在创建 Turn 前调用一次，并把结果作为 `createTurn` 的 `toolExecutors` 传入。
    *
-   * 实现理由：SubAgent Tool 的名称、Schema 和执行语义属于 Pi Tool 层，而 accountId、
-   * rateVersion 和 slot identity 这些计费事实属于 Submission。两者在这里汇合：Pi 提供工具，
+   * 实现理由：SubAgent Tool 的名称、Schema 和执行语义属于 Pi Tool 层，而父子执行身份属于 Submission。两者在这里汇合：Pi 提供工具，
    * Runtime 提供本次 Submission 的 lifecycle 端口，因此 Runtime 不需要认识 Tool 模块本身。
    * 没有可用 SubAgent 类型时返回 `undefined`，让 Turn 继续使用装配期的无 lifecycle 执行器。
    */