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

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

@@ -12,6 +12,8 @@ import type {
   MessageDelivery,
   MessageDispatchReceipt,
   SubmissionReceipt,
+  StoredRuntimeKey,
+  RuntimeKeyRewrite,
 } from "../../submission";
 import type { RuntimeState } from "../../conversation";
 import type {
@@ -31,7 +33,9 @@ import {
 } from "../../lib/execution-level";
 import {
   assembleRuntimeSnapshot,
+  verifyRuntimeCandidateGuards,
   type RuntimeCandidate,
+  type RuntimeSubmissionAdmissionHook,
 } from "../../config";
 import type {
   ResolvedResources,
@@ -71,6 +75,7 @@ export type {
   RuntimeAgentToolResult,
   RuntimeAssemblyContext,
 } from "../../config";
+export type { RuntimeKeyRewrite, StoredRuntimeKey } from "../../submission";
 
 /** Host 一次性准备的完整 Runtime 加载结果。 */
 export interface LoadedRuntime<Config> {
@@ -99,9 +104,9 @@ interface RuntimeAgentDefinitionBase<
   /** Refresh Host-owned inputs before a new Submission records its Runtime key. */
   readonly beforeSubmission?: (
     context: RuntimeAgentPlanningContext<Env, Command, Change>,
-  ) => Promise<boolean>;
+  ) => Promise<void>;
 
-  /** Prepare per-Submission Host state after admission and before its first assembly pin. */
+  /** Prepare per-Submission Host state after admission and before first execution. */
   readonly afterSubmission?: (
     context: RuntimeAgentPlanningContext<Env, Command, Change>,
   ) => Promise<void>;
@@ -111,6 +116,12 @@ interface RuntimeAgentDefinitionBase<
     requestedRuntimeKey?: string,
   ) => Promise<LoadedRuntime<Config>>;
 
+  /** Resolve saved identities; unfinished work must still belong to the selected Agent. */
+  readonly migrateStoredRuntimeKeys?: (
+    context: RuntimeAgentPlanningContext<Env, Command, Change>,
+    keys: readonly StoredRuntimeKey[],
+  ) => Promise<readonly RuntimeKeyRewrite[]>;
+
   readonly tools: (
     context: RuntimeAgentPlanningContext<Env, Command, Change>,
     config: Config,
@@ -321,6 +332,7 @@ declare class RuntimeAgentHostSeam {
   protected prepareToolInteractionResponse(
     input: import("./agent").ToolInteractionResponsePreparation,
   ): Promise<unknown | null>;
+  protected hasUnfinishedRuntimeWork(): boolean;
 }
 
 /**
@@ -364,6 +376,7 @@ const TERMINAL_AGENT_TOOL_STATUSES = [
   "interrupted",
 ] as const;
 const AGENT_TOOL_RETENTION_MS = 24 * 60 * 60 * 1_000;
+export const STABLE_RUNTIME_KEY_MIGRATION = "agent-runtime:stable-runtime-key-migration-v1";
 
 function parseTemporaryAgentLaunch(input: unknown): TemporaryAgentLaunchSelection {
   const record = input != null && typeof input === "object"
@@ -421,6 +434,8 @@ export function defineRuntimeAgent<
       context: RuntimeAgentPlanningContext<Env, Command, Change>,
     ) => AgentTelemetryBinding | undefined | Promise<AgentTelemetryBinding | undefined>)(context);
   };
+  const migrateSavedKeys = definition.migrateStoredRuntimeKeys as
+    RuntimeAgentDefinitionBase<Env, Config, Command, Change>["migrateStoredRuntimeKeys"];
 
   const GeneratedRuntimeAgent = {
     [definition.name]: class extends AgentToolRuntimeKernel<Env> {
@@ -432,6 +447,68 @@ export function defineRuntimeAgent<
       private temporaryLaunch?: TemporaryAgentLaunchSelection;
       private temporaryDispose?: () => Promise<void>;
       private temporaryCleanup?: Promise<void>;
+      private storedKeyMigration?: Promise<void>;
+
+      async onStart(): Promise<void> {
+        await this.migrateStoredRuntimeKeys();
+        await super.onStart();
+      }
+
+      private async resolveSavedKeyRewrites(
+        keys: readonly StoredRuntimeKey[],
+      ): Promise<readonly RuntimeKeyRewrite[]> {
+        if (!migrateSavedKeys) {
+          return keys.map(({ runtimeKey }) => ({ from: runtimeKey, to: runtimeKey }));
+        }
+        const rewrites = await migrateSavedKeys(this.createDefinitionContext(), keys);
+        if (
+          rewrites.length !== keys.length ||
+          rewrites.some(({ from, to }, index) =>
+            from !== keys[index]?.runtimeKey || !to.trim())
+        ) {
+          throw new Error("Saved Runtime key migration returned an invalid rewrite plan");
+        }
+        return rewrites;
+      }
+
+      private migrateStoredRuntimeKeys(): Promise<void> {
+        if (!migrateSavedKeys) return Promise.resolve();
+        if (this.storedKeyMigration) return this.storedKeyMigration;
+        const migration = (async () => {
+          if (await this.ctx.storage.get<boolean>(STABLE_RUNTIME_KEY_MIGRATION)) return;
+          const savedLaunch = await this.ctx.storage.get<unknown>(TEMPORARY_AGENT_LAUNCH_KEY);
+          const launch = savedLaunch === undefined
+            ? undefined
+            : parseTemporaryAgentLaunch(savedLaunch);
+          const keysByValue = new Map(
+            this.savedRuntimeKeys().map((key) => [key.runtimeKey, key]),
+          );
+          if (launch) {
+            keysByValue.set(launch.runtimeKey, {
+              runtimeKey: launch.runtimeKey,
+              unfinished: keysByValue.get(launch.runtimeKey)?.unfinished ?? true,
+            });
+          }
+          const keys = [...keysByValue.values()];
+          if (keys.length > 0) {
+            const rewrites = await this.resolveSavedKeyRewrites(keys);
+            this.rewriteSavedRuntimeKeys(rewrites);
+            if (launch) {
+              const runtimeKey = rewrites.find(({ from }) => from === launch.runtimeKey)?.to;
+              if (!runtimeKey) throw new Error("Saved temporary Agent key was not migrated");
+              const currentLaunch = { ...launch, runtimeKey };
+              await this.ctx.storage.put(TEMPORARY_AGENT_LAUNCH_KEY, currentLaunch);
+              this.temporaryLaunch = currentLaunch;
+            }
+          }
+          await this.ctx.storage.put(STABLE_RUNTIME_KEY_MIGRATION, true);
+        })().catch((error) => {
+          this.storedKeyMigration = undefined;
+          throw error;
+        });
+        this.storedKeyMigration = migration;
+        return migration;
+      }
 
       protected get role(): RuntimeAgentRole {
         return this.parentPath.at(-1)?.className === definition.name
@@ -446,19 +523,20 @@ export function defineRuntimeAgent<
         return this.ensureConfig();
       }
 
-      protected override ensureRuntimeVersion(runtimeKey: string): Promise<void> {
-        return this.ensureConfig(runtimeKey);
+      protected override ensureRuntimeVersion(runtimeKey: string, force = false): Promise<void> {
+        return this.ensureConfig(runtimeKey, force);
       }
 
-      protected async prepareRuntimeForAdmission(): Promise<void> {
+      protected async prepareRuntimeForAdmission(): Promise<{
+        runtimeKey: string;
+        admission?: RuntimeSubmissionAdmissionHook;
+      }> {
         const beforeSubmission = definition.beforeSubmission as RuntimeAgentDefinitionBase<Env, Config, Command, Change>["beforeSubmission"];
-        try {
-          const changed = await beforeSubmission?.(this.createDefinitionContext());
-          await this.ensureConfig(undefined, changed === true);
-        } catch (error) {
-          this.hasLoadedRuntime = false;
-          throw error;
-        }
+        await beforeSubmission?.(this.createDefinitionContext());
+        const requestedKey = this.role === "temporary"
+          ? this.loadedRuntimeKey ?? this.temporaryLaunch?.runtimeKey
+          : undefined;
+        return this.inspectCandidate(requestedKey);
       }
 
       protected async prepareRuntimeForSubmission(submissionId: string): Promise<void> {
@@ -479,7 +557,7 @@ export function defineRuntimeAgent<
         runtimeKey?: string,
         options?: { force?: boolean },
       ): Promise<void> {
-        await this.ensureConfig(runtimeKey, options?.force === true);
+        await this.runConfigControl(() => this.ensureConfig(runtimeKey, options?.force === true));
       }
 
       async updateConfig(
@@ -492,26 +570,36 @@ export function defineRuntimeAgent<
         if (!update) {
           return { change: undefined as Change, runtime: "unchanged" };
         }
-        const result = await update(this.createDefinitionContext(), command);
-        if (!result.changed) {
-          return { change: result.change, runtime: "unchanged" };
-        }
-        try {
-          await this.ensureConfig(undefined, true);
-          return { change: result.change, runtime: "reloaded" };
-        } catch (reloadError) {
-          if (result.rollback) {
-            try {
-              await result.rollback();
-            } catch (rollbackError) {
-              throw new AggregateError(
-                [reloadError, rollbackError],
-                "Runtime Config rollback failed",
-              );
+        const deferActivation = this.isSubmissionExecuting();
+        const apply = async (): Promise<RuntimeConfigUpdateResult<Change>> => {
+          const result = await update(this.createDefinitionContext(), command);
+          if (!result.changed) {
+            return { change: result.change, runtime: "unchanged" };
+          }
+          try {
+            if (deferActivation) {
+              await this.inspectCandidate();
+              return { change: result.change, runtime: "deferred" };
+            }
+            await this.ensureConfig(undefined, true);
+            return { change: result.change, runtime: "reloaded" };
+          } catch (reloadError) {
+            if (result.rollback) {
+              try {
+                await result.rollback();
+              } catch (rollbackError) {
+                throw new AggregateError(
+                  [reloadError, rollbackError],
+                  "Runtime Config rollback failed",
+                );
+              }
             }
+            return { change: result.change, runtime: "reload-failed" };
           }
-          return { change: result.change, runtime: "reload-failed" };
-        }
+        };
+        return deferActivation
+          ? apply()
+          : this.runConfigControl(apply);
       }
 
       async getRuntimeAssembly(): Promise<RuntimeAssemblyView> {
@@ -563,13 +651,105 @@ export function defineRuntimeAgent<
         if (this.role !== "temporary") {
           throw new Error("Agent Tool runs require a temporary child facet");
         }
-        const launch = parseTemporaryAgentLaunch(input);
+        const parsed = parseTemporaryAgentLaunch(input);
+        const [rewrite] = await this.resolveSavedKeyRewrites([
+          { runtimeKey: parsed.runtimeKey, unfinished: true },
+        ]);
+        const runtimeKey = rewrite?.to;
+        if (!runtimeKey) throw new Error("Temporary Agent runtime key must not be empty");
+        const launch = { ...parsed, runtimeKey };
         this.temporaryLaunch = launch;
         await this.ctx.storage.put(TEMPORARY_AGENT_LAUNCH_KEY, launch);
         await this.reloadRuntime(launch.runtimeKey, { force: true });
         return launch.task;
       }
 
+      /** One definition load and assembly path for admission and execution. */
+      private async prepareCandidate(requestedRuntimeKey?: string): Promise<{
+        candidate: RuntimeCandidate;
+        runtimeKey: string;
+        dispose?: () => Promise<void>;
+      }> {
+        const loadContext = this.createDefinitionContext();
+        const loaded = await withRuntimeLoadTimeout(
+          "definition.load",
+          () => (
+            definition.load as (
+              context: RuntimeAgentPlanningContext<Env, Command, Change>,
+              requestedRuntimeKey?: string,
+            ) => Promise<LoadedRuntime<Config>>
+          )(loadContext, requestedRuntimeKey),
+          { timeoutMs: RUNTIME_LOAD_TIMEOUT_MS },
+        );
+        const runtimeKey = loaded.runtimeKey.trim();
+        if (!runtimeKey) {
+          throw new Error("Resolved Runtime key must not be empty");
+        }
+        if (requestedRuntimeKey && runtimeKey !== requestedRuntimeKey) {
+          throw new Error(
+            `Requested Runtime key ${requestedRuntimeKey} resolved to ${runtimeKey}`,
+          );
+        }
+        const context = this.createDefinitionContext({ value: loaded.config });
+        let tools = await withRuntimeLoadTimeout(
+          "definition.tools",
+          () => (
+            definition.tools as (
+              context: RuntimeAgentPlanningContext<Env, Command, Change>,
+              config: Config,
+            ) => ToolAssemblyResult | Promise<ToolAssemblyResult>
+          )(context, loaded.config),
+          { timeoutMs: RUNTIME_LOAD_TIMEOUT_MS },
+        );
+        const dispose = tools.dispose;
+        try {
+          let resources = loaded.resources;
+          let commitGuard = loaded.commitGuard;
+          if (!this.telemetryResolved) {
+            this.resolvedTelemetry = await resolveDefinitionTelemetry(context);
+            this.telemetryResolved = true;
+          }
+          const telemetry = this.resolvedTelemetry;
+          if (this.role === "temporary") {
+            tools = this.applyTemporaryToolPolicy(tools);
+            resources = await this.applyTemporaryResources(resources);
+            commitGuard = undefined;
+          }
+          const candidate = await assembleRuntimeSnapshot({
+            ctx: context,
+            tools,
+            resources,
+            ...(commitGuard ? { commitGuard } : {}),
+            ...(telemetry ? { telemetry } : {}),
+          });
+          return {
+            candidate: { ...candidate, runtimeKey },
+            runtimeKey,
+            ...(dispose ? { dispose } : {}),
+          };
+        } catch (error) {
+          await dispose?.();
+          throw error;
+        }
+      }
+
+      /** Validate a candidate without changing the active Runtime or its Gateway. */
+      private async inspectCandidate(requestedRuntimeKey?: string): Promise<{
+        runtimeKey: string;
+        admission?: RuntimeSubmissionAdmissionHook;
+      }> {
+        const prepared = await this.prepareCandidate(requestedRuntimeKey);
+        try {
+          await verifyRuntimeCandidateGuards(prepared.candidate, "admission");
+          return {
+            runtimeKey: prepared.runtimeKey,
+            admission: prepared.candidate.admission,
+          };
+        } finally {
+          await prepared.dispose?.();
+        }
+      }
+
       // 作用：把首次加载和按 key 重载合并成一个串行入口。
       // 调用：Runtime readiness、Session 配置和重载都会调用。
       // 原因：共享同一个 Promise 可合并并发首加载，显式切 key 则等待前序完成后再判断。
@@ -618,69 +798,16 @@ export function defineRuntimeAgent<
           // 先创建局部 Promise，再赋给 `loading`，失败时也能在 finally 中放开重试。
           const pending = (async () => {
             this.runtimeLoad.begin();
-            const loadContext = this.createDefinitionContext();
-            const loaded = await withRuntimeLoadTimeout(
-              "definition.load",
-              () => (
-                definition.load as (
-                  context: RuntimeAgentPlanningContext<Env, Command, Change>,
-                  requestedRuntimeKey?: string,
-                ) => Promise<LoadedRuntime<Config>>
-              )(
-                loadContext,
-                requestedRuntimeKey,
-              ),
-              { timeoutMs: RUNTIME_LOAD_TIMEOUT_MS },
-            );
-            const resolvedRuntimeKey = loaded.runtimeKey.trim();
-            if (!resolvedRuntimeKey) {
-              throw new Error("Resolved Runtime key must not be empty");
-            }
-            if (requestedRuntimeKey && resolvedRuntimeKey !== requestedRuntimeKey) {
-              throw new Error(
-                `Requested Runtime key ${requestedRuntimeKey} resolved to ${resolvedRuntimeKey}`,
-              );
-            }
-            const context = this.createDefinitionContext({
-              value: loaded.config,
-            });
-            let tools = await withRuntimeLoadTimeout(
-              "definition.tools",
-              () => (
-                definition.tools as (
-                  context: RuntimeAgentPlanningContext<Env, Command, Change>,
-                  config: Config,
-                ) => ToolAssemblyResult | Promise<ToolAssemblyResult>
-              )(context, loaded.config),
-              { timeoutMs: RUNTIME_LOAD_TIMEOUT_MS },
-            );
-            let resources = loaded.resources;
-            let commitGuard = loaded.commitGuard;
-            if (!this.telemetryResolved) {
-              this.resolvedTelemetry = await resolveDefinitionTelemetry(context);
-              this.telemetryResolved = true;
-            }
-            const telemetry = this.resolvedTelemetry;
-            if (this.role === "temporary") {
-              this.temporaryDispose = tools.dispose;
-              tools = this.applyTemporaryToolPolicy(tools);
-              resources = await this.applyTemporaryResources(resources);
-              commitGuard = undefined;
+            const prepared = await this.prepareCandidate(requestedRuntimeKey);
+            try {
+              await this.initCandidate(prepared.candidate);
+            } catch (error) {
+              await prepared.dispose?.();
+              throw error;
             }
-            const candidate = await assembleRuntimeSnapshot({
-              ctx: context,
-              tools,
-              resources,
-              ...(commitGuard ? { commitGuard } : {}),
-              ...(telemetry ? { telemetry } : {}),
-            });
-
-            await this.initCandidate({
-              ...candidate,
-              runtimeKey: resolvedRuntimeKey,
-            });
+            if (this.role === "temporary") this.temporaryDispose = prepared.dispose;
             this.hasLoadedRuntime = true;
-            this.loadedRuntimeKey = resolvedRuntimeKey;
+            this.loadedRuntimeKey = prepared.runtimeKey;
             this.runtimeLoad.complete();
             // 提交之前 turnEvents 绑定还不存在，此前每一次广播都到不了 Host。
             // Host 的会话列表把装配后的第一次投影当作「facet 已就绪」的信号。

package/src/adapter/cloudflare/schema.ts

@@ -19,8 +19,6 @@ export function initializeSchema(sql: SqlTaggedTemplate): void {
     error TEXT,
     created_at INTEGER NOT NULL,
     completed_at INTEGER,
-    assembly_revision TEXT NOT NULL,
-    assembly_descriptor TEXT NOT NULL,
     assistant_message_id TEXT NOT NULL,
     abort_reason TEXT
   )`;
@@ -28,6 +26,12 @@ export function initializeSchema(sql: SqlTaggedTemplate): void {
     sql<{ name: string }>`PRAGMA table_info(pi_submissions)`
       .map((column) => column.name),
   );
+  if (submissionColumns.has("assembly_revision")) {
+    sql`ALTER TABLE pi_submissions DROP COLUMN assembly_revision`;
+  }
+  if (submissionColumns.has("assembly_descriptor")) {
+    sql`ALTER TABLE pi_submissions DROP COLUMN assembly_descriptor`;
+  }
   if (!submissionColumns.has("runtime_key")) {
     sql`ALTER TABLE pi_submissions ADD COLUMN runtime_key TEXT NOT NULL DEFAULT ''`;
   }

package/src/config/activation.ts

@@ -2,7 +2,7 @@ import { connectConfiguredMcpServers } from "../lib/mcp";
 import { sha256Hex } from "../lib/artifacts";
 import type { RuntimeCandidate, RuntimeSnapshot } from "./assembler";
 import type { HarnessRuntimeConfig } from "./harness-runtime";
-import type { PreparedPiRuntime, PreparePiRuntimeOptions } from "./pinning";
+import type { PreparedPiRuntime, PreparePiRuntimeOptions } from "./prepared-runtime";
 import type { RuntimeGatewaySession, RuntimeSubmissionAdmissionHook } from "./ports";
 import { withRuntimeLoadTimeout } from "./runtime-load";
 import type { RuntimeLoadPhase } from "../conversation/state";
@@ -16,6 +16,16 @@ export interface ActiveRuntime {
   readonly admission?: RuntimeSubmissionAdmissionHook;
 }
 
+/** Check the same candidate guards during admission and final activation. */
+export async function verifyRuntimeCandidateGuards(
+  candidate: RuntimeCandidate,
+  phase: "admission" | "commit",
+): Promise<void> {
+  for (const [index, guard] of candidate.commitGuards.entries()) {
+    await withRuntimeLoadTimeout(`${phase}-guard:${index}`, guard);
+  }
+}
+
 async function closeRuntimeGatewaySession(
   session: RuntimeGatewaySession | undefined,
   step: string,
@@ -33,7 +43,6 @@ interface RuntimeActivationOptions {
   readonly sessionId: string;
   readonly createExtensionHostBinding: PreparePiRuntimeOptions["createExtensionHostBinding"];
   advance(phase: RuntimeLoadPhase): void;
-  isExecuting(): boolean;
   commit(runtime: ActiveRuntime): void;
 }
 
@@ -92,19 +101,10 @@ export async function activateRuntimeCandidate(
     throw error;
   }
   const revision = await sha256Hex(prepared.revisionDescriptor);
-  const contested = Boolean(previous) &&
-    revision !== previous?.revision &&
-    options.isExecuting();
-  if (contested) {
-    await closeRuntimeGatewaySession(gatewaySession, "gateway.close.contested");
-    throw new Error(
-      "Cannot reload Runtime while a revision-pinned SpringBrand Turn is active",
-    );
-  }
   const next = Object.freeze({
     snapshot: candidateSnapshot,
     revision,
-    runtimeKey: candidate.runtimeKey ?? revision,
+    runtimeKey: candidate.runtimeKey ?? "default",
     pi: prepared,
     ...(gatewaySession ? { gatewaySession } : {}),
     ...(candidate.admission
@@ -114,9 +114,7 @@ export async function activateRuntimeCandidate(
   let activated = false;
   const previousGatewaySession = previous?.gatewaySession;
   try {
-    for (const [index, guard] of candidate.commitGuards.entries()) {
-      await withRuntimeLoadTimeout(`commit-guard:${index}`, guard);
-    }
+    await verifyRuntimeCandidateGuards(candidate, "commit");
     options.pi.activate(candidateSnapshot);
     activated = true;
     options.commit(next);

package/src/config/harness-runtime.ts

@@ -15,19 +15,17 @@ export {
   readModelStreamStallDetails,
 } from "../models";
 import {
-  pinPiRuntime,
+  assembleCurrentPiContext,
   preparePiRuntime,
-  readPinnedPiRuntime,
   readPreparedPiRuntime,
-  type PinPiRuntimeOptions,
-  type PinnedPiRuntime,
+  type CurrentPiContextOptions,
   type PreparePiRuntimeOptions,
   type PreparedPiRuntime,
-} from "./pinning";
+} from "./prepared-runtime";
 import { refreshModelGuidance } from "./model-guidance";
 
 /**
- * Runtime 通过这个配置入口准备、固定并读取 Harness 的模型、提示和工具输入。
+ * Runtime 通过这个配置入口准备并读取当前 Harness 的模型、提示和工具输入。
  *
  * @remarks
  * Runtime、Pi、Turn、Tool Candidate 和 canonical transcript 等核心术语见包入口 `../../index.ts`。
@@ -37,9 +35,7 @@ import { refreshModelGuidance } from "./model-guidance";
  *   它包含已加载 Extension、Tool candidate 和快照，但 Runtime 只能读取 revision descriptor 与 degradation。
  * - revision descriptor 是影响执行行为的已排序 JSON 描述。
  *   Runtime 会对它取哈希，用来识别当前 Prepared Runtime 的基础版本。
- * - Pinned Runtime 是 Submission 准入时固定的描述符。
- *   它在 Prepared Runtime 基础上加入动态 system context、approval mode 和 base revision。
- * 调用方：`AgentRuntimeKernel` 在配置加载、请求准入与打开 SessionHarness 前调用这些粗粒度能力。
+ * 调用方：`AgentRuntimeKernel` 在配置加载与打开 SessionHarness 前调用这些粗粒度能力。
  *
  * 执行位置仍由 `SessionHarness` 拥有，消息读写和投影由 `ConversationHistory` 拥有。
  */
@@ -86,23 +82,31 @@ export class HarnessRuntimeConfig {
     );
   }
 
-  /** Read the immutable inputs consumed by the Session AgentHarness. */
-  harnessInputs(
+  interaction(prepared: PreparedPiRuntime, name: string) {
+    return readPreparedPiRuntime(prepared, this.owner).candidates.find(
+      (candidate) => candidate.tool.name === name,
+    )?.interaction;
+  }
+
+  /** Read all executable inputs from the current Prepared Runtime. */
+  async harnessInputs(
     prepared: PreparedPiRuntime,
-    pinnedDescriptor: string,
     request: {
       readonly modelSessionId?: string | (() => string);
       readonly onGeneration?: PiGenerationLifecycleObserver;
+      readonly includeMemory?: boolean;
+      readonly readExtensionContext?: CurrentPiContextOptions["readExtensionContext"];
       readonly assertRequestAllowed?: () => void;
       readonly onCompactionGeneration?: PiGenerationLifecycleObserver;
     } = {},
   ) {
-    const { state, descriptor } = readPinnedPiRuntime(
+    const state = readPreparedPiRuntime(prepared, this.owner);
+    const context = await assembleCurrentPiContext({
       prepared,
-      this.owner,
-      pinnedDescriptor,
-    );
-    const pinnedModel = state.snapshot.pi.model;
+      includeMemory: request.includeMemory,
+      readExtensionContext: request.readExtensionContext,
+    }, this.owner);
+    const currentModel = state.snapshot.pi.model;
     let models!: MutableModels;
     const requestStream = (observer = request.onGeneration) => {
       const stream = withProviderBoundary(
@@ -121,8 +125,8 @@ export class HarnessRuntimeConfig {
       get: (target, property) => {
         if (property === "getModel") {
           return (provider: string, modelId: string) =>
-            provider === pinnedModel.provider && modelId === pinnedModel.id
-              ? pinnedModel
+            provider === currentModel.provider && modelId === currentModel.id
+              ? currentModel
               : target.getModel(provider, modelId);
         }
         if (property === "streamSimple") return requestStream();
@@ -147,7 +151,8 @@ export class HarnessRuntimeConfig {
       models,
       model: state.snapshot.pi.model,
       thinkingLevel: state.snapshot.pi.thinkingLevel,
-      systemPrompt: descriptor.systemPrompt,
+      systemPrompt: context.systemPrompt,
+      degradations: context.degradations,
       candidates: state.candidates,
       workspace: state.snapshot.bindings.workspace,
       platform: state.snapshot.bindings.platform,
@@ -179,27 +184,12 @@ export class HarnessRuntimeConfig {
     }
   }
 
-  /**
-   * 在接受 Submission 前固定本次执行使用的动态上下文和审批模式。
-   *
-   * @remarks
-   * 调用方：Runtime 的准入流程为每个新 Submission 调用，并把 descriptor 与其哈希一起持久化。
-   *
-   * 实现理由：memory、workspace 和 Extension context 可能随时间变化，所以把准入时的 Turn 字段保存在 descriptor 中。
-   * 不要把 pin 推迟到 Turn 启动后，否则已持久化的 Submission 将失去可验证的执行基线。
-   */
-  pin(options: PinPiRuntimeOptions): Promise<PinnedPiRuntime> {
-    return pinPiRuntime(options, this.owner);
-  }
-
 }
 
 export type {
-  PinPiRuntimeOptions,
-  PinnedPiRuntime,
   PreparePiRuntimeOptions,
   PreparedPiRuntime,
-} from "./pinning";
+} from "./prepared-runtime";
 
 /**
  * Input tokens above which a Turn compacts its history.

package/src/config/index.ts

@@ -7,7 +7,7 @@ export * from "./assembly-view";
 export * from "./definition";
 export * from "./degradation";
 export * from "./harness-runtime";
-export * from "./pinning";
+export * from "./prepared-runtime";
 export * from "./ports";
 export * from "./profile";
 export * from "./runtime-config";