@downcity/agent 1.1.12 → 1.1.14

package/src/service/core/ServiceStateController.ts

@@ -7,14 +7,14 @@
  * - Manager.ts 只作为门面导出，真正逻辑在这里分层实现。
  */
 
-import type { AgentContext } from "@/runtime/AgentContextTypes.js";
+import type { AgentContext } from "@/core/AgentContextTypes.js";
+import type { AgentRuntime } from "@/core/AgentCoreTypes.js";
 import type {
   ServiceStateControlAction,
   ServiceStateControlResult,
   ServiceStateRecord,
   ServiceStateSnapshot,
 } from "@/service/types/ServiceState.js";
-import { getAgentRuntime } from "@/runtime/AgentRuntimeState.js";
 import {
   getRegisteredStaticServiceInstances,
   listRegisteredServices,
@@ -31,17 +31,27 @@ function nowMs(): number {
  * 列出当前进程内可见的 service 实例。
  *
  * 关键点（中文）
- * - 若 agent 已就绪，则返回 per-agent service instances。
- * - 若 agent 尚未初始化，则退回静态装配实例，方便测试与只读场景。
+ * - 优先读取显式传入的实例级 context/runtime。
+ * - 若调用方未传入实例上下文，则只退回静态装配实例，方便测试与只读场景。
  */
-export function listServiceInstances(): BaseService[] {
-  try {
-    const agent = getAgentRuntime();
-    if (agent.services.size > 0) {
-      return [...agent.services.values()];
-    }
-  } catch {
-    // ignore and fallback
+export function listServiceInstances(input?: {
+  context?: AgentContext;
+  runtime?: AgentRuntime;
+}): BaseService[] {
+  return listServiceInstancesFor(input);
+}
+
+function listServiceInstancesFor(input?: {
+  context?: AgentContext;
+  runtime?: AgentRuntime;
+}): BaseService[] {
+  const contextServices = input?.context?.agent?.services;
+  if (contextServices instanceof Map && contextServices.size > 0) {
+    return [...contextServices.values()];
+  }
+  const runtimeServices = input?.runtime?.services;
+  if (runtimeServices instanceof Map && runtimeServices.size > 0) {
+    return [...runtimeServices.values()];
   }
   return [...getRegisteredStaticServiceInstances().values()];
 }
@@ -51,10 +61,14 @@ export function listServiceInstances(): BaseService[] {
  */
 export function resolveServiceByName(
   name: string,
+  input?: {
+    context?: AgentContext;
+    runtime?: AgentRuntime;
+  },
 ): BaseService | null {
   const key = String(name || "").trim();
   if (!key) return null;
-  return listServiceInstances().find((service) => service.name === key) || null;
+  return listServiceInstancesFor(input).find((service) => service.name === key) || null;
 }
 
 /**
@@ -153,8 +167,11 @@ export function getServiceRootCommandNames(): string[] {
 /**
  * 列出全部 service 状态快照。
  */
-export function listServiceStates(): ServiceStateSnapshot[] {
-  return listServiceInstances()
+export function listServiceStates(input?: {
+  context?: AgentContext;
+  runtime?: AgentRuntime;
+}): ServiceStateSnapshot[] {
+  return listServiceInstancesFor(input)
     .map((service) =>
       toServiceStateSnapshot(ensureServiceStateRecord(service), service),
     )
@@ -164,8 +181,14 @@ export function listServiceStates(): ServiceStateSnapshot[] {
 /**
  * 判断指定 service 是否处于运行中。
  */
-export function isServiceRunning(serviceName: string): boolean {
-  const service = resolveServiceByName(serviceName);
+export function isServiceRunning(
+  serviceName: string,
+  input?: {
+    context?: AgentContext;
+    runtime?: AgentRuntime;
+  },
+): boolean {
+  const service = resolveServiceByName(serviceName, input);
   if (!service) return false;
   return ensureServiceStateRecord(service).state === "running";
 }
@@ -238,7 +261,9 @@ export async function controlServiceState(params: {
   action: ServiceStateControlAction;
   context: AgentContext;
 }): Promise<ServiceStateControlResult> {
-  const service = resolveServiceByName(params.serviceName);
+  const service = resolveServiceByName(params.serviceName, {
+    context: params.context,
+  });
   if (!service) {
     return {
       success: false,
@@ -277,7 +302,7 @@ export async function startAllServices(
   results: ServiceStateControlResult[];
 }> {
   const results: ServiceStateControlResult[] = [];
-  for (const service of listServiceInstances()) {
+  for (const service of listServiceInstancesFor({ context })) {
     results.push(
       await controlServiceState({
         serviceName: service.name,
@@ -300,7 +325,7 @@ export async function stopAllServices(context: AgentContext): Promise<{
   results: ServiceStateControlResult[];
 }> {
   const results: ServiceStateControlResult[] = [];
-  for (const service of listServiceInstances()) {
+  for (const service of listServiceInstancesFor({ context })) {
     results.push(
       await controlServiceState({
         serviceName: service.name,

package/src/service/core/ServiceSystemProviders.ts

@@ -7,7 +7,7 @@
  * - 这样也能避开 `task -> runner -> prompt system -> service class registry` 的循环依赖。
  */
 
-import type { AgentContext } from "@/runtime/AgentContextTypes.js";
+import type { AgentContext } from "@/core/AgentContextTypes.js";
 import { buildChatServiceSystem } from "@/service/builtins/chat/runtime/ChatServiceSystem.js";
 import { buildContactServiceSystemText } from "@/service/builtins/contact/runtime/SystemProvider.js";
 import { buildMemoryServiceSystemText } from "@/service/builtins/memory/runtime/SystemProvider.js";

package/src/service/core/Services.ts

@@ -6,13 +6,14 @@
  * - 这里只声明“有哪些 service class”，不承载运行态逻辑。
  */
 
-import type { AgentRuntime } from "@/runtime/AgentRuntimeTypes.js";
+import type { AgentRuntime } from "@/core/AgentCoreTypes.js";
 import type { BaseService } from "@/service/builtins/BaseService.js";
 import { ChatService } from "@/service/builtins/chat/ChatService.js";
 import { TaskService } from "@/service/builtins/task/TaskService.js";
 import { MemoryService } from "@/service/builtins/memory/MemoryService.js";
 import { ShellService } from "@/service/builtins/shell/ShellService.js";
 import { ContactService } from "@/service/builtins/contact/ContactService.js";
+import { ScheduleService } from "@/service/builtins/schedule/ScheduleService.js";
 
 /**
  * 单个 service class 构造器。
@@ -27,6 +28,7 @@ export type ServiceClass<T extends BaseService = BaseService> = new (
 export const SERVICE_CLASSES: ServiceClass[] = [
   ChatService,
   ContactService,
+  ScheduleService,
   TaskService,
   MemoryService,
   ShellService,

package/src/service/schedule/Executor.ts

@@ -6,7 +6,7 @@
  * - 不负责调度入口和轮询生命周期管理。
  */
 
-import type { AgentContext } from "@/runtime/AgentContextTypes.js";
+import type { AgentContext } from "@/core/AgentContextTypes.js";
 import type { ServiceScheduleStore } from "./Store.js";
 import { runServiceCommand } from "@/service/core/Manager.js";
 

package/src/service/types/Service.ts

@@ -8,8 +8,7 @@
  */
 
 import type { Command } from "commander";
-import type { Context as HonoContext } from "hono";
-import type { AgentContext } from "@/runtime/AgentContextTypes.js";
+import type { AgentContext } from "@/core/AgentContextTypes.js";
 import type { JsonValue } from "@/types/common/Json.js";
 
 /**
@@ -94,24 +93,6 @@ export type ServiceActionCommand<P extends JsonValue = JsonValue> = {
   mapInput: (input: ServiceActionCommandInput) => P | Promise<P>;
 };
 
-/**
- * Action HTTP 定义。
- */
-export type ServiceActionApi<P extends JsonValue = JsonValue> = {
-  /**
-   * HTTP 方法。
-   */
-  method?: "GET" | "POST" | "PUT" | "DELETE";
-  /**
-   * 自定义路由路径；省略时走默认 `/service/<service>/<action>`。
-   */
-  path?: string;
-  /**
-   * 把 HTTP 请求映射为结构化 payload。
-   */
-  mapInput?: (ctx: HonoContext) => P | Promise<P>;
-};
-
 /**
  * 单个 service action 定义。
  */
@@ -123,10 +104,6 @@ export type ServiceAction<
    * CLI 定义；省略则该 action 不暴露为 CLI 子命令。
    */
   command?: ServiceActionCommand<P>;
-  /**
-   * HTTP API 定义；省略则该 action 不注册 HTTP 路由。
-   */
-  api?: ServiceActionApi<P>;
   /**
    * action 的实际执行函数。
    */

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/composer/system/default/DefaultSessionSystemComposer.ts

@@ -10,7 +10,7 @@ import {
   SessionSystemComposer,
 } from "@session/composer/system/SessionSystemComposer.js";
 import { getSessionRunScope } from "@session/SessionRunScope.js";
-import type { AgentContext } from "@/runtime/AgentContextTypes.js";
+import type { AgentContext } from "@/core/AgentContextTypes.js";
 import {
   resolveSessionSystemMessages,
   type SystemProfile,

package/src/session/composer/system/default/SystemDomain.ts

@@ -11,7 +11,7 @@ import { transformPromptsIntoSystemMessages } from "@session/composer/system/def
 import { isPluginEnabled } from "@/plugin/core/Activation.js";
 import { PLUGINS } from "@/plugin/core/Plugins.js";
 import { SERVICE_SYSTEM_PROVIDERS } from "@/service/core/ServiceSystemProviders.js";
-import type { AgentContext } from "@/runtime/AgentContextTypes.js";
+import type { AgentContext } from "@/core/AgentContextTypes.js";
 import { buildRuntimeClockSystemPrompt } from "@session/composer/system/default/variables/VariableReplacer.js";
 import {
   CORE_SYSTEM_PROMPT,

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 {
   /**