@downcity/agent 1.1.12 → 1.1.13

package/src/service/builtins/chat/runtime/ChatSession.ts

@@ -1,5 +1,5 @@
 /**
- * ChatSession：chat 专用 Session 实现。
+ * ChatSession：chat 专用 Executor 实现。
  *
  * 关键点（中文）
  * - ChatSession 在实例化时持有自己的 execution composer 实例。
@@ -7,10 +7,13 @@
  * - 外层仍只调用标准 `run(...)`；chat 语义由 ChatSession 内部收敛。
  */
 
-import { Session } from "@session/Session.js";
+import type { LanguageModel, Tool } from "ai";
+import { Executor } from "@session/Executor.js";
 import type { SessionHistoryComposer } from "@session/composer/history/SessionHistoryComposer.js";
+import type { SessionCompactionComposer } from "@session/composer/compaction/SessionCompactionComposer.js";
+import type { SessionSystemComposer } from "@session/composer/system/SessionSystemComposer.js";
 import type { ChatSessionExecutionComposer } from "@/service/builtins/chat/runtime/ChatSessionExecutionComposer.js";
-import type { SessionExecutor } from "@/session/types/SessionExecutor.js";
+import type { Logger } from "@/utils/logger/Logger.js";
 import type { SessionAssistantStepCallback } from "@/session/types/SessionRun.js";
 import type { SessionRunResult } from "@/session/types/SessionRun.js";
 import type { ChatSessionTurnState } from "@/service/builtins/chat/runtime/ChatSessionTypes.js";
@@ -27,17 +30,34 @@ type ChatSessionOptions = {
   historyComposer: SessionHistoryComposer;
 
   /**
-   * 当前 session 绑定的 chat execution composer。
+   * 读取当前 session 使用的模型实例。
    */
-  executionComposer: ChatSessionExecutionComposer;
+  getModel: () => LanguageModel | undefined;
+
+  /**
+   * 统一日志器。
+   */
+  logger: Logger;
+
+  /**
+   * 当前 session 对应的 compaction Composer。
+   */
+  compactionComposer: SessionCompactionComposer;
 
   /**
-   * 创建当前 session 的执行器。
+   * 当前 session 对应的 system Composer。
    */
-  createExecutor: (
-    historyComposer: SessionHistoryComposer,
-    executionComposer: ChatSessionExecutionComposer,
-  ) => SessionExecutor;
+  systemComposer: SessionSystemComposer;
+
+  /**
+   * 获取当前可用工具集合。
+   */
+  getTools: () => Record<string, Tool>;
+
+  /**
+   * 当前 session 绑定的 chat execution composer。
+   */
+  executionComposer: ChatSessionExecutionComposer;
 
   /**
    * session 更新后的异步回调。
@@ -48,7 +68,7 @@ type ChatSessionOptions = {
 /**
  * Chat 专用 Session。
  */
-export class ChatSession extends Session {
+export class ChatSession extends Executor {
   /**
    * ChatSession 持有的 composer 实例。
    */
@@ -61,8 +81,12 @@ export class ChatSession extends Session {
     super({
       sessionId: options.sessionId,
       historyComposer: options.historyComposer,
-      createExecutor: (historyComposer) =>
-        options.createExecutor(historyComposer, executionComposer),
+      getModel: options.getModel,
+      logger: options.logger,
+      compactionComposer: options.compactionComposer,
+      systemComposer: options.systemComposer,
+      getTools: options.getTools,
+      executionComposer,
       ...(options.runAfterSessionUpdated
         ? { runAfterSessionUpdated: options.runAfterSessionUpdated }
         : {}),

package/src/service/builtins/task/runtime/Runner.ts

@@ -3,7 +3,7 @@
  *
  * 职责（中文）
  * - 创建 run 目录（timestamp）。
- * - 以“干净历史”调用当前 runtime 的 LocalSessionCore（逻辑与正常 chat 一致）。
+ * - 以“干净历史”调用当前 runtime 的 Runner（逻辑与正常 chat 一致）。
  * - 协调 script / agent 两类执行主链。
  * - 把最终产物写入 run 目录的具体格式委托给 `TaskRunArtifacts.ts`。
  */

package/src/service/builtins/task/runtime/TaskRunnerSession.ts

@@ -2,7 +2,7 @@
  * TaskRunnerSession：task runner 的 session 装配模块。
  *
  * 关键点（中文）
- * - 负责构建 task 专用 LocalSessionCore / JsonlSessionHistoryComposer 运行时。
+ * - 负责构建 task 专用 Runner / JsonlSessionHistoryComposer 运行时。
  * - 负责把每轮 user/assistant 消息写入 run 目录对应的 messages.jsonl。
  * - 这些能力与任务编排逻辑解耦后，Runner 主流程会更聚焦于状态流转。
  * - 当前只有 api 执行模式。
@@ -12,7 +12,7 @@ import path from "node:path";
 import type { AgentContext } from "@/runtime/AgentContextTypes.js";
 import type { SessionRunResult } from "@/session/types/SessionRun.js";
 import type { TaskSessionRuntimePort } from "@/service/builtins/task/runtime/TaskRunnerTypes.js";
-import { LocalSessionCore } from "@session/executors/local/LocalSessionCore.js";
+import { Runner } from "@session/executors/local/Runner.js";
 import { drainDeferredPersistedUserMessages } from "@session/SessionRunScope.js";
 import { JsonlSessionHistoryComposer } from "@session/composer/history/jsonl/JsonlSessionHistoryComposer.js";
 import { JsonlSessionCompactionComposer } from "@session/composer/compaction/jsonl/JsonlSessionCompactionComposer.js";
@@ -54,7 +54,7 @@ export async function appendTaskRoundUserMessage(params: {
  * 构建 task 专用 Session 运行时（独立于普通 Session 实例缓存）。
  *
  * 关键点（中文）
- * - 使用 LocalSessionCore 执行，模型来自 context.session.model（agent 级模型）。
+ * - 使用 Runner 执行，模型来自 context.session.model（agent 级模型）。
  */
 export function createTaskSessionRuntimePort(params: {
   context: AgentContext;
@@ -132,7 +132,7 @@ export function createTaskSessionRuntimePort(params: {
         sessionId: key,
         getTools: () => shellTools,
       });
-      const created = new LocalSessionCore({
+      const created = new Runner({
         model: context.session.model,
         logger: context.logger,
         historyComposer,

package/src/service/builtins/task/runtime/TaskRunnerTypes.ts

@@ -170,7 +170,7 @@ export type ScriptExecutionResult = {
  * task 运行专用的 session runtime 端口。
  *
  * 关键点（中文）
- * - task runner 不直接依赖具体 `LocalSessionExecutor` 实现。
+ * - task runner 不直接依赖具体 SDK `Session` 实现。
  * - 这里暴露的是 task 场景最小可用端口：执行器 + history Composer。
  */
 export type TaskSessionRuntimePort = {

package/src/session/{Session.ts → Executor.ts}

@@ -1,23 +1,31 @@
 /**
- * Session：单个会话实例。
+ * Executor：单个 session 的执行编排器。
  *
  * 关键点（中文）
- * - 一个 Session 只对应一个固定的 `sessionId`。
- * - 对外直接暴露 `run / appendUserMessage / appendAssistantMessage / getExecutor / getHistoryComposer`。
- * - 运行态（如 executing）直接收在实例内部，不再拆 `Facade / Runner / ExecutionRegistry`。
+ * - SDK 对外对象叫 `Session`，这里是内部执行层。
+ * - 一个 Executor 只对应一个固定的 `sessionId`。
+ * - 负责 history 写入、run scope、executing 状态与本地 Runner 的懒创建。
  */
 
+import type { LanguageModel, Tool } from "ai";
 import { SessionHistoryWriter } from "@session/composer/history/SessionHistoryWriter.js";
 import type { SessionHistoryComposer } from "@session/composer/history/SessionHistoryComposer.js";
 import { withSessionRunScope } from "@session/SessionRunScope.js";
 import type { SessionRunScope } from "@session/SessionRunScope.js";
 import { buildSessionStepEventMessages } from "@session/messages/SessionStepEventMapper.js";
+import { JsonlSessionCompactionComposer } from "@session/composer/compaction/jsonl/JsonlSessionCompactionComposer.js";
+import { LocalSessionExecutionComposer } from "@session/composer/execution/LocalSessionExecutionComposer.js";
+import type { SessionCompactionComposer } from "@session/composer/compaction/SessionCompactionComposer.js";
+import type { SessionExecutionComposer } from "@session/composer/execution/SessionExecutionComposer.js";
+import type { SessionSystemComposer } from "@session/composer/system/SessionSystemComposer.js";
+import { Runner } from "@session/executors/local/Runner.js";
+import type { Logger } from "@/utils/logger/Logger.js";
 import type { JsonObject } from "@/types/common/Json.js";
 import type { SessionMessageV1 } from "@/session/types/SessionMessages.js";
 import type { SessionExecutor } from "@/session/types/SessionExecutor.js";
 import type { SessionRunResult } from "@/session/types/SessionRun.js";
 
-type SessionOptions = {
+type ExecutorOptions = {
   /**
    * 当前会话 ID。
    */
@@ -29,9 +37,34 @@ type SessionOptions = {
   historyComposer: SessionHistoryComposer;
 
   /**
-   * 创建当前 session 对应的执行器。
+   * 读取当前 session 使用的模型实例。
    */
-  createExecutor: (historyComposer: SessionHistoryComposer) => SessionExecutor;
+  getModel: () => LanguageModel | undefined;
+
+  /**
+   * 统一日志器。
+   */
+  logger: Logger;
+
+  /**
+   * 当前 session 对应的 compaction Composer。
+   */
+  compactionComposer?: SessionCompactionComposer;
+
+  /**
+   * 当前 session 对应的 system Composer。
+   */
+  systemComposer: SessionSystemComposer;
+
+  /**
+   * 获取当前可用工具集合。
+   */
+  getTools: () => Record<string, Tool>;
+
+  /**
+   * 可选自定义 execution Composer。
+   */
+  executionComposer?: SessionExecutionComposer;
 
   /**
    * session 更新后的异步回调。
@@ -40,30 +73,41 @@ type SessionOptions = {
 };
 
 /**
- * Session 单实例实现。
+ * Executor 单实例实现。
  */
-export class Session {
+export class Executor implements SessionExecutor {
   /**
    * 当前 session 标识。
    */
   readonly sessionId: string;
 
   private readonly historyComposer: SessionHistoryComposer;
-  private readonly createExecutor: SessionOptions["createExecutor"];
+  private readonly getModel: ExecutorOptions["getModel"];
+  private readonly logger: Logger;
+  private readonly compactionComposer: SessionCompactionComposer;
+  private readonly systemComposer: SessionSystemComposer;
+  private readonly getTools: ExecutorOptions["getTools"];
+  private readonly runnerExecutionComposer?: SessionExecutionComposer;
   private readonly historyWriter: SessionHistoryWriter;
 
-  private executor: SessionExecutor | null = null;
+  private runner: Runner | null = null;
   private executing = false;
 
-  constructor(options: SessionOptions) {
+  constructor(options: ExecutorOptions) {
     const sessionId = String(options.sessionId || "").trim();
     if (!sessionId) {
-      throw new Error("Session requires a non-empty sessionId");
+      throw new Error("Executor requires a non-empty sessionId");
     }
 
     this.sessionId = sessionId;
     this.historyComposer = options.historyComposer;
-    this.createExecutor = options.createExecutor;
+    this.getModel = options.getModel;
+    this.logger = options.logger;
+    this.compactionComposer =
+      options.compactionComposer || new JsonlSessionCompactionComposer();
+    this.systemComposer = options.systemComposer;
+    this.getTools = options.getTools;
+    this.runnerExecutionComposer = options.executionComposer;
     this.historyWriter = new SessionHistoryWriter({
       sessionId,
       getHistoryComposer: () => this.getHistoryComposer(),
@@ -86,26 +130,52 @@ export class Session {
   }
 
   /**
-   * 获取当前 session 的执行器。
+   * 获取当前 session 的执行端口。
+   *
+   * 关键点（中文）
+   * - 兼容 runtime/service 端口语义：Executor 自己就是执行端口。
    */
   getExecutor(): SessionExecutor {
-    if (this.executor) return this.executor;
-    const created = this.createExecutor(this.getHistoryComposer());
-    this.executor = created;
+    return this;
+  }
+
+  /**
+   * 获取或创建当前本地 Runner。
+   */
+  private getRunner(): Runner {
+    if (this.runner) return this.runner;
+    const model = this.getModel();
+    if (!model) {
+      throw new Error(
+        `Executor for session "${this.sessionId}" requires a configured model`,
+      );
+    }
+    const created = new Runner({
+      model,
+      logger: this.logger,
+      historyComposer: this.getHistoryComposer(),
+      compactionComposer: this.compactionComposer,
+      systemComposer: this.systemComposer,
+      executionComposer:
+        this.runnerExecutionComposer ||
+        new LocalSessionExecutionComposer({
+          sessionId: this.sessionId,
+          getTools: this.getTools,
+        }),
+    });
+    this.runner = created;
     return created;
   }
 
   /**
-   * 清理当前 session 的执行器缓存。
+   * 清理当前 session 的 Runner 缓存。
    *
    * 关键点（中文）
-   * - 这里只清 executor，不清 history Composer。
-   * - history 是事实源，不应随着 executor 一起丢失。
+   * - 这里只清 Runner，不清 history Composer。
+   * - history 是事实源，不应随着 Runner 一起丢失。
    */
   clearExecutor(): void {
-    const current = this.executor;
-    this.executor = null;
-    
+    this.runner = null;
   }
 
   /**
@@ -153,7 +223,7 @@ export class Session {
     if (this.executing) {
       // 关键点（中文）：同一个 Session 实例只允许一个活跃 run，
       // 否则 step 回调、scope 与执行器状态都会互相污染。
-      throw new Error("Session.run does not support concurrent execution");
+      throw new Error("Executor.run does not support concurrent execution");
     }
     const query = String(params.query || "").trim();
     const sessionRunScope: Omit<SessionRunScope, "sessionId"> = {
@@ -206,7 +276,7 @@ export class Session {
           ...sessionRunScope,
           onAssistantStepCallback: wrappedOnAssistantStepCallback,
         },
-        () => this.getExecutor().run({ query }),
+        () => this.getRunner().run({ query }),
       );
       if (persistedAssistantStepCount <= 0) return result;
 

package/src/session/composer/SessionComposer.ts

@@ -15,7 +15,7 @@ export abstract class SessionComposer {
    * 可选初始化钩子。
    *
    * 关键点（中文）
-   * - LocalSessionExecutor 启动时可统一调用。
+   * - Executor / Runner 启动时可统一调用。
    * - 无需初始化的 Composer 可不实现。
    */
   async init(): Promise<void> {

package/src/session/composer/compaction/SessionCompactionComposer.ts

@@ -30,7 +30,7 @@ export type SessionCompactionInput = {
   system: SystemModelMessage[];
 
   /**
-   * 当前重试次数（由 LocalSessionCore 递增）。
+   * 当前重试次数（由 Runner 递增）。
    */
   retryCount: number;
 };
@@ -57,7 +57,7 @@ export abstract class SessionCompactionComposer extends SessionComposer {
    *
    * 关键点（中文）
    * - 由 compaction Composer 实现侧维护错误识别策略。
-   * - LocalSessionCore 不感知具体错误文案，只按该布尔结果决定是否重试。
+   * - Runner 不感知具体错误文案，只按该布尔结果决定是否重试。
    */
   abstract shouldCompactOnError(error: unknown): boolean;
 

package/src/session/composer/execution/LocalSessionExecutionComposer.ts

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - 统一组装 tools。
- * - step 边界回调从 SessionRunScope 读取，LocalSessionCore 不直接管理来源。
+ * - step 边界回调从 SessionRunScope 读取，Runner 不直接管理来源。
  */
 
 import type { ModelMessage } from "ai";

package/src/session/composer/execution/SessionExecutionComposer.ts

@@ -65,7 +65,7 @@ export abstract class SessionExecutionComposer extends SessionComposer {
    * 构造 fallback assistant 消息。
    *
    * 关键点（中文）
- * - fallback 消息构造由 execution Composer 内部实现，LocalSessionCore 不直接依赖 history Composer。
+ * - fallback 消息构造由 execution Composer 内部实现，Runner 不直接依赖 history Composer。
    */
   abstract buildFallbackAssistantMessage(text: string): SessionMessageV1;
 }

package/src/session/composer/history/SessionHistoryComposer.ts

@@ -39,7 +39,7 @@ export type SessionHistoryPrepareInput = {
   model: LanguageModel;
 
   /**
-   * 当前重试次数（由 LocalSessionCore 递增）。
+   * 当前重试次数（由 Runner 递增）。
    */
   retryCount: number;
 };

package/src/session/composer/system/SessionSystemComposer.ts

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - 专职负责“会话上下文 -> system messages”解析。
- * - 与 tools / step 编排解耦，避免 LocalSessionCore 过载。
+ * - 与 tools / step 编排解耦，避免 Runner 过载。
  */
 
 import type { SystemModelMessage } from "ai";

package/src/session/executors/local/{LocalSessionCore.ts → Runner.ts}

@@ -1,5 +1,5 @@
 /**
- * LocalSessionCore：本地 Session 执行内核。
+ * Runner：本地 Session 执行内核。
  *
  * 关键点（中文）
  * - 这个类只做“流程编排”，不承载业务策略。
@@ -33,9 +33,9 @@ import { SessionToolLoopRunner } from "@session/executors/local/SessionToolLoopR
 const MAX_COMPACTION_RETRY_ATTEMPTS = 3;
 
 /**
- * LocalSessionCore 构造参数。
+ * Runner 构造参数。
  */
-type LocalSessionCoreOptions = {
+type RunnerOptions = {
   /** 当前模型实例。 */
   model: LanguageModel;
 
@@ -57,9 +57,9 @@ type LocalSessionCoreOptions = {
 };
 
 /**
- * LocalSessionCore 主类。
+ * Runner 主类。
  */
-export class LocalSessionCore {
+export class Runner {
   /** 模型实例：用于真正执行 streamText。 */
   private readonly model: LanguageModel;
 
@@ -78,7 +78,7 @@ export class LocalSessionCore {
   /** system 解析器：用于解析 system messages。 */
   private readonly systemComposer: SessionSystemComposer;
 
-  /** 运行互斥锁：防止同一个 LocalSessionCore 实例并发 run。 */
+  /** 运行互斥锁：防止同一个 Runner 实例并发 run。 */
   private isRunning = false;
 
   /** context-length 重试计数。 */
@@ -87,7 +87,7 @@ export class LocalSessionCore {
   /**
    * 构造函数。
    */
-  constructor(options: LocalSessionCoreOptions) {
+  constructor(options: RunnerOptions) {
     // 注入模型。
     this.model = options.model;
 
@@ -109,7 +109,7 @@ export class LocalSessionCore {
   }
 
   /**
-   * 执行一次 LocalSessionCore run。
+   * 执行一次 Runner run。
    *
    * 关键点（中文）
    * - 这里只做入口控制，不直接做模型调用。
@@ -118,7 +118,7 @@ export class LocalSessionCore {
   async run(input: SessionRunInput): Promise<SessionRunResult> {
     // 如果当前实例已经在运行，则直接拒绝并发调用。
     if (this.isRunning) {
-      throw new Error("LocalSessionCore.run does not support concurrent execution");
+      throw new Error("Runner.run does not support concurrent execution");
     }
 
     // 标记运行中。
@@ -140,7 +140,7 @@ export class LocalSessionCore {
   }
 
   /**
-   * 执行一次 LocalSessionCore run（带可压缩错误重试）。
+   * 执行一次 Runner run（带可压缩错误重试）。
    *
    * 关键点（中文）
    * - 正常：准备输入 -> 执行。
@@ -159,7 +159,7 @@ export class LocalSessionCore {
       // 执行组装好的运行输入。
       return await this.executePreparedRun(prepared);
     } catch (error) {
-      // 是否应压缩重试由 compaction Composer 决策，LocalSessionCore 只消费布尔结果。
+      // 是否应压缩重试由 compaction Composer 决策，Runner 只消费布尔结果。
       if (this.compactionComposer.shouldCompactOnError(error)) {
         // 记录压缩重试日志，便于观测问题频率。
         await this.logger.log("info", "[agent] compacting", {
@@ -187,7 +187,7 @@ export class LocalSessionCore {
       const errorMsg = String(error);
 
       // 记录错误日志。
-      await this.logger.log("error", "LocalSessionCore execution failed", {
+      await this.logger.log("error", "Runner execution failed", {
         error: errorMsg,
       });
 
@@ -213,7 +213,7 @@ export class LocalSessionCore {
   private async prepareExecuteInput(query: string): Promise<SessionExecuteInput> {
     // 基础安全检查：historyComposer 必须携带 sessionId。
     if (!String(this.historyComposer.sessionId || "").trim()) {
-      throw new Error("LocalSessionCore.run requires historyComposer.sessionId");
+      throw new Error("Runner.run requires historyComposer.sessionId");
     }
 
     // 让 execution Composer 组装运行上下文（例如 tools 与 request 作用域）。

package/src/session/executors/local/SessionExecutionError.ts

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - AI SDK 的最终错误有时只是兜底包装，底层 provider 错误会先从 stream `onError` 暴露。
- * - LocalSessionCore 只需要消费这里输出的日志字段与最终错误文本。
+ * - Runner 只需要消费这里输出的日志字段与最终错误文本。
  */
 
 import type { JsonObject } from "@/types/common/Json.js";

package/src/session/executors/local/SessionLoopDecision.ts

@@ -1,8 +1,8 @@
 /**
- * SessionLoopDecision：LocalSessionCore 执行循环的纯决策模块。
+ * SessionLoopDecision：Runner 执行循环的纯决策模块。
  *
  * 关键点（中文）
- * - 把 “是否继续下一轮” 的分支优先级从 LocalSessionCore 主流程中拆出。
+ * - 把 “是否继续下一轮” 的分支优先级从 Runner 主流程中拆出。
  * - 保持纯函数，不依赖模型、持久化或 logger，便于直接测试。
  */
 
@@ -13,7 +13,7 @@ import type {
 } from "@/session/types/SessionLoop.js";
 
 /**
- * 评估当前 step 完成后，LocalSessionCore 是否应继续下一轮。
+ * 评估当前 step 完成后，Runner 是否应继续下一轮。
  *
  * 优先级（中文）
  * 1. 不完整响应恢复

package/src/session/executors/local/SessionModelMessageState.ts

@@ -2,7 +2,7 @@
  * Session 模型消息运行态。
  *
  * 关键点（中文）
- * - LocalSessionCore 同时维护 session 语义消息与模型消息。
+ * - Runner 同时维护 session 语义消息与模型消息。
  * - 新增 user 消息可优先做增量转换，失败时再回退为全量重算。
  * - assistant UI 消息只需要进入 session 语义基线；模型侧使用 SDK 返回的 response messages。
  */
@@ -15,7 +15,7 @@ import {
 } from "@session/messages/SessionMessageCodec.js";
 
 /**
- * LocalSessionCore 单轮执行期间的消息基线。
+ * Runner 单轮执行期间的消息基线。
  */
 export class SessionModelMessageState {
   /**

package/src/session/executors/local/SessionSignals.ts

@@ -1,10 +1,10 @@
 /**
- * SessionLoopSignals：LocalSessionCore 执行循环的信号判断与调试摘要工具。
+ * SessionLoopSignals：Runner 执行循环的信号判断与调试摘要工具。
  *
  * 关键点（中文）
  * - 这里只放“如何判断继续执行 / 如何输出调试摘要”的纯函数。
- * - 不放 LocalSessionCore 主流程，避免执行内核被大量辅助细节淹没。
- * - 目标是让 LocalSessionCore 保持“只看主链路就能理解”的结构。
+ * - 不放 Runner 主流程，避免执行内核被大量辅助细节淹没。
+ * - 目标是让 Runner 保持“只看主链路就能理解”的结构。
  */
 
 import {

package/src/session/executors/local/SessionToolLoopRunner.ts

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - 这里只负责已准备好的 `SessionExecuteInput` 如何进入 `streamText` 循环。
- * - LocalSessionCore 保留入口、重试与输入准备职责，本模块负责 step 循环、续写、恢复和最终日志。
+ * - Runner 保留入口、重试与输入准备职责，本模块负责 step 循环、续写、恢复和最终日志。
  * - 运行过程中同时维护 UI assistant 消息、模型消息基线和 step 统计。
  */
 
@@ -334,7 +334,7 @@ export class SessionToolLoopRunner {
         streamError: lastObservedStreamError,
       });
 
-      await this.logger.log("error", "LocalSessionCore execution failed", {
+      await this.logger.log("error", "Runner execution failed", {
         error: errorMsg,
       });
 

package/src/session/types/SessionLoop.ts

@@ -1,5 +1,5 @@
 /**
- * LocalSessionCore tool-loop 决策相关类型。
+ * Runner tool-loop 决策相关类型。
  *
  * 关键点（中文）
  * - 这里只描述“是否继续下一轮”的纯决策输入/输出。

package/src/session/types/SessionRun.ts

@@ -3,7 +3,7 @@
  *
  * 关键点（中文）
  * - `SessionRunInput` 表示上层会话入口输入（例如 context query）。
- * - `SessionExecuteInput` 表示 LocalSessionCore 通过 Composer 装配后的中间运行态。
+ * - `SessionExecuteInput` 表示 Runner 通过 Composer 装配后的中间运行态。
  * - 输出仅暴露 assistantMessage（UIMessage）。
  */
 
@@ -107,7 +107,7 @@ export interface SessionRunInput {
 }
 
 /**
- * LocalSessionCore 通过 Composer 装配后的中间运行态。
+ * Runner 通过 Composer 装配后的中间运行态。
  */
 export interface SessionExecuteInput {
   /**