@downcity/agent 1.1.438 → 1.1.446

package/src/session/{SessionLoop.ts → loop/SessionLoop.ts}

@@ -18,25 +18,27 @@ import type {
   AgentSessionTurnResult,
 } from "@/types/sdk/AgentSessionTurn.js";
 import { is_agent_session_prompt_input_empty } from "@/types/sdk/AgentSessionPrompt.js";
-import type {
+import type { SessionStepExecutionInput, SessionTurnExecutionResult } from "@/types/session/SessionExecution.js";
+import {
+  is_provider_context_limit_error,
   SessionExecutor,
-  SessionTurnExecutionResult,
-} from "@/types/session/SessionExecution.js";
-import type { SessionTurnContext } from "@/types/executor/SessionTurnContext.js";
-import { create_session_turn_context } from "@/session/runtime/SessionTurnContext.js";
-import { SessionEventHub } from "@/session/runtime/SessionEventHub.js";
-import { SessionState } from "@/session/SessionState.js";
+  type SessionExecutorPort,
+} from "@/session/runner/SessionExecutor.js";
+import type { StepInput } from "@/session/input/StepInput.js";
+import type { SessionTurnContext } from "@/types/turn/SessionTurnContext.js";
+import { create_session_turn_context } from "@/session/loop/SessionTurnContext.js";
+import { SessionEventHub } from "@/session/messages/SessionEventHub.js";
+import { SessionState } from "@/session/loop/SessionState.js";
 import {
   normalize_session_user_parts,
   SessionMessages,
-} from "@/session/SessionMessages.js";
-import type { ShellApprovalGateway } from "@downcity/type";
+} from "@/session/messages/SessionMessages.js";
 import type {
   SessionInteractionLifecycle,
   SessionInteractionPort,
 } from "@downcity/type";
-import { SessionAssistantOutputAdapter } from "@/session/execution/SessionAssistantOutputAdapter.js";
-import { SessionQueue } from "@/session/SessionQueue.js";
+import { SessionAssistantOutputAdapter } from "@/session/messages/SessionAssistantOutputAdapter.js";
+import { SessionQueue } from "@/session/loop/SessionQueue.js";
 import { extract_session_message_text } from "@/session/messages/SessionMessageText.js";
 import type {
   ActiveSessionTurnState,
@@ -47,18 +49,18 @@ import type {
   SessionCommand,
   SessionCommandCompletion,
 } from "@/types/session/SessionCommand.js";
-import { create_session_model_request_warning } from "@/session/runtime/SessionModelRequestWarning.js";
+import { create_session_model_request_warning } from "@/session/messages/SessionModelRequestWarning.js";
 import {
   complete_session_turn,
   fail_session_turn,
-} from "@/session/runtime/SessionTurnCompletion.js";
+  TURN_STOPPED_MESSAGE,
+} from "@/session/loop/SessionTurnCompletion.js";
 import {
   append_session_turn_file_diff,
   publish_session_turn_file_diff,
-} from "@/session/runtime/SessionTurnFileDiff.js";
+} from "@/session/loop/SessionTurnFileDiff.js";
 import type { SessionTurnCompletionOptions } from "@/types/session/SessionTurnCompletion.js";
 
-const TURN_STOPPED_MESSAGE = "Turn stopped";
 const QUEUED_PROMPT_CANCELLED_MESSAGE =
   "Prompt cancelled because session was stopped";
 
@@ -69,17 +71,20 @@ export class SessionLoop {
   private readonly session_id: string;
   private readonly session_origin: SessionLoopOptions["session_origin"];
   private readonly workspace_path: string;
-  private readonly executor: SessionExecutor;
+  private readonly step_input: StepInput | null;
+  private readonly session_executor: SessionExecutorPort;
   private readonly maintain_context: SessionLoopOptions["maintain_context"];
   private readonly state: SessionState;
   private readonly messages: SessionMessages;
   private readonly events: SessionEventHub;
   private readonly logger: SessionLoopOptions["logger"];
+  /** 读取当前生效的扩展处理器集合。 */
+  private readonly get_hooks: SessionLoopOptions["get_hooks"];
+  /** 构造当前 Turn 的调用环境快照。 */
+  private readonly create_call_context: SessionLoopOptions["create_call_context"];
   private readonly interactions:
     SessionInteractionLifecycle & SessionInteractionPort;
-  private readonly shell_approval_gateway: ShellApprovalGateway;
-  private readonly queue: SessionQueue;
-  private pending_prompt_count = 0;
+  private readonly queue: SessionQueue;  private pending_prompt_count = 0;
   private processing_promise: Promise<void> | null = null;
   private active_turn: ActiveSessionTurnState | null = null;
   /** 尚未完成 canonical 接收的幂等 Prompt，防止进程内并发重复入队。 */
@@ -89,21 +94,34 @@ export class SessionLoop {
     this.session_id = String(options.session_id || "").trim();
     this.session_origin = options.session_origin;
     this.workspace_path = String(options.workspace_path || "").trim();
-    this.executor = options.executor;
     this.maintain_context = options.maintain_context;
     this.state = options.state;
     this.messages = options.messages;
     this.events = options.events;
     this.logger = options.logger;
+    this.get_hooks = options.get_hooks;
+    this.create_call_context = options.create_call_context;
     this.queue = options.queue;
     this.interactions = options.interactions;
-    this.shell_approval_gateway = options.shell_approval_gateway;
     if (!this.session_id) {
       throw new Error("SessionLoop requires a non-empty session_id");
     }
     if (!this.workspace_path) {
       throw new Error("SessionLoop requires a non-empty workspace_path");
     }
+    this.step_input = options.step_input ?? null;
+    this.session_executor = options.executor ??
+      new SessionExecutor({
+        session_id: this.session_id,
+        logger: this.logger,
+        is_context_limit: is_provider_context_limit_error,
+        advance_context: options.advance_context,
+      });
+  }
+
+  /** 返回当前 Session 是否正在执行模型请求。 */
+  is_executing(): boolean {
+    return this.session_executor.is_executing();
   }
 
   /**
@@ -315,6 +333,27 @@ export class SessionLoop {
     }
   }
 
+  /**
+   * 在 Turn 收口前抽干尚未处理的 Maintenance Command。
+   *
+   * 关键点（中文）
+   * - 收尾窗口内到达的配置变更 Action 借此与当前 Agent Message 共享同一条 Message。
+   * - 只抽 Maintenance；Prompt 继续留在 FIFO 里由下一 Turn 消费。
+   */
+  private async drain_queued_maintenance_commands(): Promise<void> {
+    const drained = this.queue.drain_maintenance();
+    for (let index = 0; index < drained.length; index += 1) {
+      const command = drained[index];
+      try {
+        await this.execute_command(command);
+      } catch {
+        // 失败时保留尚未处理的 Maintenance；Action 自己负责失败观测。
+        this.queue.restore_front(drained.slice(index));
+        break;
+      }
+    }
+  }
+
   /** 执行 Command，并尽力持久化其声明的 canonical 完成信息。 */
   private async execute_command(command: SessionCommand): Promise<void> {
     await command.execute();
@@ -475,7 +514,7 @@ export class SessionLoop {
     }
     let result: SessionTurnExecutionResult;
     try {
-      result = await this.executor.execute({ turn_context });
+      result = await this.run_turn_with_context_advance(turn_context);
     } catch (error) {
       result = {
         text: "",
@@ -487,7 +526,7 @@ export class SessionLoop {
     if (!result.success && !turn_context.lifecycle.abort_signal.aborted && result.error) {
       await assistant_output.append_error({
         scope: "turn",
-        code: "turn_execution_failed",
+        code: result.error_code || "turn_execution_failed",
         message: result.error,
         recoverable: true,
       });
@@ -502,6 +541,8 @@ export class SessionLoop {
       logger: this.logger,
     });
 
+    await this.drain_queued_maintenance_commands();
+
     await assistant_output.finish({
       status: turn_context.lifecycle.abort_signal.aborted
         ? "stopped"
@@ -521,6 +562,40 @@ export class SessionLoop {
     };
   }
 
+  /**
+   * 执行 Turn；上下文推进与重试由执行器内部负责。
+   *
+   * 关键点（中文）：每次重试都重新装配 Step 输入，保证读到刚推进的上下文。
+   */
+  private async run_turn_with_context_advance(
+    turn_context: SessionTurnContext,
+  ): Promise<SessionTurnExecutionResult> {
+    return await this.session_executor.execute({
+      turn_context,
+      resolve_step_input: async (advance_count) =>
+        await this.require_step_input(turn_context, advance_count),
+    });
+  }
+
+  /**
+   * 解析当前 Step 的输入。
+   *
+   * 关键点（中文）：注入执行器时本 Loop 不拥有输入装配能力；回调一旦被调用即说明注入契约
+   * 被破坏，因此直接报错而不是静默返回空输入。
+   */
+  private async require_step_input(
+    turn_context: SessionTurnContext,
+    advance_count: number,
+  ): Promise<SessionStepExecutionInput> {
+    const step_input = this.step_input;
+    if (!step_input) {
+      throw new Error(
+        "SessionLoop was given an executor and cannot assemble step input",
+      );
+    }
+    return await step_input.build(turn_context, advance_count);
+  }
+
   /** 在 Turn 创建时建立其唯一执行上下文和 Assistant 输出端口。 */
   private create_turn_context(
     active_turn: ActiveSessionTurnState,
@@ -550,7 +625,6 @@ export class SessionLoop {
       },
       has_pending_step_input: () => this.has_pending_prompt(),
       assistant_output,
-      shell_approval_gateway: this.shell_approval_gateway,
       interactions: this.interactions,
       on_effects_changed: (effects) => {
         publish_session_turn_file_diff({
@@ -624,6 +698,8 @@ export class SessionLoop {
       events: this.events,
       logger: this.logger,
       stopped_message: TURN_STOPPED_MESSAGE,
+      get_hooks: this.get_hooks,
+      create_call_context: this.create_call_context,
     };
   }
 }

package/src/session/{SessionQueue.ts → loop/SessionQueue.ts}

@@ -31,6 +31,24 @@ export class SessionQueue {
     return this.commands.splice(0, this.commands.length);
   }
 
+  /**
+   * 只取出当前全部 Maintenance Command，并保留 Prompt 的相对顺序。
+   *
+   * Turn 收口前用它抽干配置类命令，让这些 Action 与当前 Agent Message 共享同一条
+   * Message；Prompt 必须留在队列里由后续 Turn 消费，否则会在没有后续 Step 的情况下
+   * 被持久化为 steer 却永远得不到响应。
+   */
+  drain_maintenance(): SessionCommand[] {
+    const drained: SessionCommand[] = [];
+    const retained: SessionCommand[] = [];
+    for (const command of this.commands) {
+      if (command.kind === "maintenance") drained.push(command);
+      else retained.push(command);
+    }
+    this.commands.splice(0, this.commands.length, ...retained);
+    return drained;
+  }
+
   /** 把尚未处理的 Command 恢复到队列头部。 */
   restore_front(commands: SessionCommand[]): void {
     this.commands.unshift(...commands);

package/src/session/{SessionState.ts → loop/SessionState.ts}

@@ -16,18 +16,18 @@ import {
   normalize_session_title,
   resolve_system_timezone,
 } from "@/session/storage/Metadata.js";
-import { ensure_session_title } from "@/session/SessionTitle.js";
+import { ensure_session_title } from "@/session/loop/SessionTitle.js";
 import type {
   AgentSessionConfigSnapshot,
 } from "@/types/agent/SessionTypes.js";
 import type { SessionLocalState } from "@/types/session/SessionLocalState.js";
 import { generate_id } from "@/utils/Id.js";
 import type { Logger } from "@/utils/logger/Logger.js";
-import { SessionTitleTask } from "@/session/runtime/SessionTitleTask.js";
+import { SessionTitleTask } from "@/session/loop/SessionTitleTask.js";
 import type { SessionStateOptions } from "@/types/session/SessionState.js";
 import type { SessionStorage } from "@/types/store/SessionStorage.js";
 import type { SessionApprovalMode } from "@downcity/type";
-import { create_session_model_request_warning } from "@/session/runtime/SessionModelRequestWarning.js";
+import { create_session_model_request_warning } from "@/session/messages/SessionModelRequestWarning.js";
 
 /** 创建单个 Session 唯一的可变内存状态。 */
 export function create_session_local_state(): SessionLocalState {
@@ -38,7 +38,6 @@ export function create_session_local_state(): SessionLocalState {
     created_at: Date.now(),
     timezone: resolve_system_timezone(),
     initialize_promise: null,
-    ensure_configured_promise: null,
   };
 }
 
@@ -60,7 +59,6 @@ export class SessionState {
   private readonly store: SessionStorage;
   private readonly state: SessionLocalState;
   private readonly logger: Logger;
-  private readonly ensure_configured_hook?: SessionStateOptions["ensure_configured_hook"];
   private readonly get_model: SessionStateOptions["get_model"];
   private readonly publish_event: SessionStateOptions["publish_event"];
   private readonly title_task: SessionTitleTask;
@@ -73,7 +71,6 @@ export class SessionState {
     this.store = options.store;
     this.state = options.state;
     this.logger = options.logger;
-    this.ensure_configured_hook = options.ensure_configured_hook;
     this.get_model = options.get_model;
     this.publish_event = options.publish_event;
     this.title_task = new SessionTitleTask({
@@ -153,24 +150,10 @@ export class SessionState {
   }
 
   /**
-   * 在执行前确保当前 session 已完成初始化与宿主装配。
+   * 在执行前确保当前 session 已完成初始化。
    */
   async ensure_ready_for_execution(): Promise<void> {
     await this.initialize();
-    if (this.state.ensure_configured_promise) {
-      await this.state.ensure_configured_promise;
-      return;
-    }
-    this.state.ensure_configured_promise = (async () => {
-      if (!this.ensure_configured_hook) return;
-      await this.ensure_configured_hook();
-    })();
-    try {
-      await this.state.ensure_configured_promise;
-    } catch (error) {
-      this.state.ensure_configured_promise = null;
-      throw error;
-    }
   }
 
   /**

package/src/session/{SessionTitle.ts → loop/SessionTitle.ts}

@@ -11,14 +11,14 @@ import type { ModelClient } from "@downcity/type";
 import {
   build_text_model_messages,
   generate_model,
-} from "@executor/model/ModelGenerate.js";
-import type { SessionHistoryMeta } from "@/executor/types/SessionHistoryMeta.js";
+} from "@/model/ModelGenerate.js";
+import type { SessionHistoryMeta } from "@/types/store/SessionHistoryMeta.js";
 import type { Logger } from "@/utils/logger/Logger.js";
 import { normalize_session_title } from "@/session/storage/Metadata.js";
 import type { SessionStorage } from "@/types/store/SessionStorage.js";
 import type { SessionMessage } from "@downcity/type";
 import { extract_session_message_text } from "@/session/messages/SessionMessageText.js";
-import type { ModelRequestFailureReporter } from "@/types/executor/ModelRequest.js";
+import type { ModelRequestFailureReporter } from "@/types/model/ModelRequest.js";
 
 const GENERATED_SESSION_TITLE_MAX_CHARS = 24;
 

package/src/session/{runtime → loop}/SessionTurnCompletion.ts

@@ -12,7 +12,16 @@ import type { SessionTurnExecutionResult } from "@/types/session/SessionExecutio
 import type { ActiveSessionTurnState } from "@/types/session/SessionLoop.js";
 import type { SessionTurnCompletionOptions } from "@/types/session/SessionTurnCompletion.js";
 import type { SessionTurnCommittedHookValue } from "@downcity/type";
-import { SESSION_HOOK_POINTS } from "@/session/SessionHookPoints.js";
+import { SESSION_HOOK_POINTS } from "@downcity/type";
+import { run_effect_point } from "@/session/input/SessionHookRunner.js";
+
+/**
+ * Turn 被用户中止时的规范错误文本。
+ *
+ * 关键点（中文）：执行器产出该文本，Turn 收口处比对它未决定是否写入 Error Part，
+ * 因此两侧必须引用同一个常量。
+ */
+export const TURN_STOPPED_MESSAGE = "Turn stopped";
 
 /** 使用 Executor 结果完成当前 Turn。 */
 export async function complete_session_turn(
@@ -103,8 +112,7 @@ async function notify_turn_committed(
   active_turn: ActiveSessionTurnState,
   status: SessionTurnCommittedHookValue["status"],
 ): Promise<void> {
-  const hooks = active_turn.turn_context?.step.hooks;
-  if (!hooks) return;
+  const hooks = options.get_hooks();
   try {
     const messages = (await options.messages.list_history_messages())
       .filter((message) => message.turn_id === active_turn.turn_id)
@@ -115,12 +123,23 @@ async function notify_turn_committed(
       status,
       messages: messages as SessionMessage[],
     };
-    await hooks.effect(
-      SESSION_HOOK_POINTS.turn_committed,
-      value as unknown as JsonValue,
-    );
+    const context = options.create_call_context({
+      turn_id: active_turn.turn_id,
+      abort_signal: active_turn.turn_context?.lifecycle.abort_signal
+        ?? new AbortController().signal,
+    });
+    await run_effect_point({
+      hooks,
+      point_name: SESSION_HOOK_POINTS.turn_committed,
+      value: value as unknown as JsonValue,
+      context,
+      on_error: async (point_name, error) =>
+        await log_turn_warning(options, active_turn, "session power effect failed", error, {
+          point_name,
+        }),
+    });
   } catch (error) {
-    await log_turn_warning(options, active_turn, "session plugin effect failed", error, {
+    await log_turn_warning(options, active_turn, "session power effect failed", error, {
       point_name: SESSION_HOOK_POINTS.turn_committed,
     });
   }

package/src/session/{runtime → loop}/SessionTurnContext.ts

@@ -3,42 +3,25 @@
  *
  * 关键点（中文）
  * - Session 创建并拥有上下文，Executor 和 Tool 通过领域分区协作。
- * - 所有可变数组、Plugin lease 与取消监听都封装在本模块内。
- * - Plugin 每次只获得新建的只读快照，不能越过扩展边界访问内核运行能力。
+ * - 所有可变数组、Power lease 与取消监听都封装在本模块内。
+ * - Power 每次只获得新建的只读快照，不能越过扩展边界访问内核运行能力。
  */
 
-import type { RuntimeToolEffect } from "@downcity/type";
+import type { ToolEffect } from "@downcity/type";
 import type { SessionUserMessage } from "@downcity/type";
 import type { SessionAgentContent } from "@downcity/type";
 import type {
   SessionTurnContext,
   SessionTurnContextInit,
-} from "@/types/executor/SessionTurnContext.js";
-import type { SessionHookContext } from "@downcity/type";
-import type { SessionHookScopeRuntime } from "@downcity/type";
+} from "@/types/turn/SessionTurnContext.js";
+import type { SessionHookContextBlock } from "@downcity/type";
 import type { SessionOrigin } from "@downcity/type";
 import { normalize_session_origin } from "@downcity/type";
-import type { SessionHookContextBlock } from "@downcity/type";
-
-/** 非 Turn 查询创建 Plugin 只读快照所需的稳定 Session 状态。 */
-export interface CreateSessionHookContextInput {
-  /** 当前 Session 标识。 */
-  session_id: string;
-  /** 当前 Session 的完整来源元数据。 */
-  session_origin: SessionOrigin;
-  /** 当前 Session 所属项目根目录。 */
-  project_root: string;
-  /** 当前 Session 已生效的 Workspace 环境变量。 */
-  workspace_env: Readonly<Record<string, string>>;
-  /** 当前 Session 已生效的 Agent instruction 文本。 */
-  agent_systems: readonly string[];
-}
 
 /** SessionTurnContext 的唯一内置实现。 */
 class DefaultSessionTurnContext implements SessionTurnContext {
   readonly session: SessionTurnContext["session"];
   readonly interactions: SessionTurnContext["interactions"];
-  readonly shell: SessionTurnContext["shell"];
 
   private readonly abort_controller = new AbortController();
   private readonly upstream_abort_signal?: AbortSignal;
@@ -46,14 +29,13 @@ class DefaultSessionTurnContext implements SessionTurnContext {
   private disposed = false;
   private workspace_env_snapshot?: Readonly<Record<string, string>>;
   private agent_systems_snapshot: readonly string[] = Object.freeze([]);
-  private hook_scope?: SessionHookScopeRuntime;
-  /** 整个 Turn 共享的 Plugin 动态上下文，不随 Step lease 切换而失效。 */
-  private plugin_context_blocks_snapshot: readonly SessionHookContextBlock[] = Object.freeze([]);
+  /** 整个 Turn 共享的扩展动态上下文。 */
+  private power_context_blocks_snapshot: readonly SessionHookContextBlock[] = Object.freeze([]);
   /** 并发或重复解析时复用的唯一 Promise。 */
-  private plugin_context_blocks_promise?: Promise<readonly SessionHookContextBlock[]>;
+  private power_context_blocks_promise?: Promise<readonly SessionHookContextBlock[]>;
   private observed_user_messages: SessionUserMessage[] = [];
   private pending_assistant_parts: SessionAgentContent[] = [];
-  private turn_effects: RuntimeToolEffect[] = [];
+  private turn_effects: ToolEffect[] = [];
 
   readonly lifecycle: SessionTurnContext["lifecycle"];
   readonly step: SessionTurnContext["step"];
@@ -78,11 +60,6 @@ class DefaultSessionTurnContext implements SessionTurnContext {
       ...(project_root ? { project_root } : {}),
     });
     this.interactions = init.interactions;
-    this.shell = Object.freeze({
-      ...(init.shell_approval_gateway
-        ? { approval_gateway: init.shell_approval_gateway }
-        : {}),
-    });
 
     this.upstream_abort_signal = init.abort_signal;
     this.abort_from_upstream = () => {
@@ -118,11 +95,8 @@ class DefaultSessionTurnContext implements SessionTurnContext {
       get agent_systems() {
         return context.agent_systems_snapshot;
       },
-      get hooks() {
-        return context.hook_scope;
-      },
-      get plugin_context_blocks() {
-        return context.plugin_context_blocks_snapshot;
+      get power_context_blocks() {
+        return context.power_context_blocks_snapshot;
       },
       commit: (input) => {
         context.workspace_env_snapshot = Object.freeze({
@@ -132,16 +106,8 @@ class DefaultSessionTurnContext implements SessionTurnContext {
           ...input.agent_systems,
         ]);
       },
-      replace_hooks: async (hooks) => {
-        const previous = context.hook_scope;
-        context.hook_scope = hooks;
-        if (previous && previous !== hooks) await previous.close();
-      },
-      resolve_plugin_context_blocks: async (resolver) =>
-        await context.resolve_plugin_context_blocks(resolver),
-      release: async () => await context.release_extensions(),
-      hook_context: (call_id?: string) =>
-        context.create_hook_context(call_id),
+      resolve_power_context_blocks: async (resolver) =>
+        await context.resolve_power_context_blocks(resolver),
     });
 
     this.input = Object.freeze({
@@ -196,13 +162,13 @@ class DefaultSessionTurnContext implements SessionTurnContext {
     });
   }
 
-  /** 每个 Turn 只执行一次 Plugin 动态上下文解析，并保存不可变快照。 */
-  private async resolve_plugin_context_blocks(
+  /** 每个 Turn 只执行一次 Power 动态上下文解析，并保存不可变快照。 */
+  private async resolve_power_context_blocks(
     resolver: () => Promise<readonly SessionHookContextBlock[]>,
   ): Promise<readonly SessionHookContextBlock[]> {
-    this.plugin_context_blocks_promise ??= (async () => {
+    this.power_context_blocks_promise ??= (async () => {
       const blocks = await resolver();
-      this.plugin_context_blocks_snapshot = Object.freeze(
+      this.power_context_blocks_snapshot = Object.freeze(
         (Array.isArray(blocks) ? blocks : []).map((block) => Object.freeze({
           ...block,
           ...(block.citations
@@ -210,35 +176,9 @@ class DefaultSessionTurnContext implements SessionTurnContext {
             : {}),
         })),
       );
-      return this.plugin_context_blocks_snapshot;
+      return this.power_context_blocks_snapshot;
     })();
-    return await this.plugin_context_blocks_promise;
-  }
-
-  /** 为 City 扩展生成不共享根对象引用的只读快照。 */
-  private create_hook_context(call_id?: string): SessionHookContext {
-    const normalized_call_id = String(call_id || "").trim();
-    return Object.freeze({
-      session_id: this.session.session_id,
-      session_origin: this.session.origin,
-      turn_id: this.session.turn_id,
-      ...(normalized_call_id ? { call_id: normalized_call_id } : {}),
-      ...(this.session.project_root
-        ? { project_root: this.session.project_root }
-        : {}),
-      ...(this.workspace_env_snapshot
-        ? { workspace_env: this.workspace_env_snapshot }
-        : {}),
-      agent_systems: this.agent_systems_snapshot,
-      abort_signal: this.abort_controller.signal,
-    });
-  }
-
-  /** 释放当前 Step 捕获的 Plugin Hook 作用域。 */
-  private async release_extensions(): Promise<void> {
-    const extensions = this.hook_scope;
-    this.hook_scope = undefined;
-    await extensions?.close();
+    return await this.power_context_blocks_promise;
   }
 
   /** 闭合当前运行拥有的全部资源。 */
@@ -249,7 +189,6 @@ class DefaultSessionTurnContext implements SessionTurnContext {
       "abort",
       this.abort_from_upstream,
     );
-    await this.release_extensions();
   }
 }
 
@@ -259,16 +198,3 @@ export function create_session_turn_context(
 ): SessionTurnContext {
   return new DefaultSessionTurnContext(init);
 }
-
-/** 为非 Turn 的 system 查询创建 Plugin 可读取的 Session 快照。 */
-export function create_session_hook_context(
-  input: CreateSessionHookContextInput,
-): SessionHookContext {
-  return Object.freeze({
-    session_id: input.session_id,
-    session_origin: Object.freeze(normalize_session_origin(input.session_origin)),
-    project_root: input.project_root,
-    workspace_env: Object.freeze({ ...input.workspace_env }),
-    agent_systems: Object.freeze([...input.agent_systems]),
-  });
-}

package/src/session/{runtime → loop}/SessionTurnFileDiff.ts

@@ -9,7 +9,7 @@ import { nanoid } from "nanoid";
 import {
   build_session_turn_file_diff,
   build_session_turn_file_diff_summary,
-} from "@/session/messages/SessionTurnFileDiffBuilder.js";
+} from "@/session/loop/SessionTurnFileDiffBuilder.js";
 import { SESSION_TURN_FILE_DIFF_DATA_TYPE } from "@/session/messages/SessionTurnFileDiffData.js";
 import type {
   AppendSessionTurnFileDiffInput,

package/src/session/{messages → loop}/SessionTurnFileDiffBuilder.ts

@@ -13,7 +13,7 @@ import {
   formatPatch,
   structuredPatch,
 } from "diff";
-import type { RuntimeToolEffect } from "@downcity/type";
+import type { ToolEffect } from "@downcity/type";
 import {
   WORKSPACE_FILE_MUTATION_EFFECT_TYPE,
   type WorkspaceFileMutation,
@@ -40,7 +40,7 @@ interface CollectedFileMutation {
 /** 把当前 Turn effects 中的结构化文件修改收敛为可持久化 Diff。 */
 export function build_session_turn_file_diff(
   workspace_path: string,
-  effects: readonly RuntimeToolEffect[],
+  effects: readonly ToolEffect[],
 ): SessionTurnFileDiffData | undefined {
   const files = collect_session_turn_file_diffs(workspace_path, effects);
   if (files.length === 0) return undefined;
@@ -54,7 +54,7 @@ export function build_session_turn_file_diff(
 /** 从当前 Turn effects 收敛只含统计的实时摘要，供 Thinking 状态行轻量展示。 */
 export function build_session_turn_file_diff_summary(
   workspace_path: string,
-  effects: readonly RuntimeToolEffect[],
+  effects: readonly ToolEffect[],
 ): SessionTurnFileDiffSummary {
   const files = collect_session_turn_file_diffs(workspace_path, effects);
   return {
@@ -67,7 +67,7 @@ export function build_session_turn_file_diff_summary(
 /** 把 effects 收敛为稳定排序的文件 Diff 列表；空列表表示当前没有结构化修改。 */
 function collect_session_turn_file_diffs(
   workspace_path: string,
-  effects: readonly RuntimeToolEffect[],
+  effects: readonly ToolEffect[],
 ): SessionTurnFileDiff[] {
   const mutations = effects.flatMap((effect) => {
     const mutation = read_workspace_file_mutation_effect(effect);