@downcity/agent 1.1.446 → 1.5.0

package/scripts/session-turn-context.test.mjs

@@ -17,7 +17,7 @@ test("SessionTurnContext 在检查点消费输入并封装输出缓冲", async (
   const internal_messages = [];
   const context = create_session_turn_context({
     session_id: "session-context-test",
-    session_origin: { type: "chat" },
+    session_origin: { type: "work" },
     turn_id: "turn-context-test",
     project_root: "/workspace",
     commit_step_input: async () => {
@@ -53,7 +53,7 @@ test("SessionTurnContext 在检查点消费输入并封装输出缓冲", async (
 test("SessionTurnContext 只按顺序收集当前 Turn 的 Tool effects", () => {
   const context = create_session_turn_context({
     session_id: "session-context-test",
-    session_origin: { type: "chat" },
+    session_origin: { type: "work" },
     turn_id: "turn-context-test",
   });
   context.effects.append([{
@@ -109,7 +109,7 @@ test("SessionTurnContext 把 Workspace env 与 Agent systems 固化为只读快
 test("SessionTurnContext 不再承担 Power hook 装配", () => {
   const context = create_session_turn_context({
     session_id: "session-context-test",
-    session_origin: { type: "chat" },
+    session_origin: { type: "work" },
     turn_id: "turn-context-test",
   });
   for (const removed of ["replace_hooks", "hook_context", "release_extensions", "hooks"]) {
@@ -120,7 +120,7 @@ test("SessionTurnContext 不再承担 Power hook 装配", () => {
 test("SessionTurnContext 在整个 Turn 中只解析一次 Power Context", async () => {
   const context = create_session_turn_context({
     session_id: "session-context-test",
-    session_origin: { type: "chat" },
+    session_origin: { type: "work" },
     turn_id: "turn-context-test",
   });
   let resolve_count = 0;

package/src/agent/Agent.ts

@@ -2,9 +2,10 @@
  * Agent：身份、模型、指令与 Session 的主体对象。
  *
  * 职责说明（中文）
- * - Agent 不绑定 Workspace；调用方通过 `agent.sessions.create({ workspace })` 选择本次执行环境。
+ * - Agent 不绑定 Workspace；`workspace` 只是创建 Session 时的默认目录，可在会话中切换。
  * - 能力与 Transport 由容器持有，Agent 只收下容器在绑定时推送的能力，不持有容器引用。
- * - Session 由 AgentSessions 统一持有；Workspace 只在单个 Session 创建时提供执行资源。
+ * - Session 由 AgentSessions 统一持有；Workspace 只在单个 Session 创建或恢复时提供。
+ * - Agent 自己那条会话由 `session()` 暴露；它是一条普通 Session。
  */
 
 import type {
@@ -16,6 +17,7 @@ import type {
   ToolHookSet,
   WorkspaceRuntime,
 } from "@downcity/type";
+
 import {
   create_instruction_system_blocks,
   normalize_instruction_input,
@@ -41,6 +43,11 @@ import {
 } from "@/session/input/SessionSystem.js";
 import type { AgentSessionSystemBlock } from "@/types/agent/SessionTypes.js";
 import { resolve_system_timezone } from "@/session/storage/Metadata.js";
+import { SessionWork } from "@/agent/SessionWork.js";
+import { is_agent_session_origin, SESSION_ORIGIN_TYPE_WORK } from "@downcity/type";
+import { create_session_tools } from "@/tools/session/SessionTools.js";
+import type { AgentSessionInput } from "@/types/agent/AgentSessionInput.js";
+import type { AgentSession } from "@/types/agent/SessionActor.js";
 
 /** SDK Agent 主体。 */
 export class Agent {
@@ -56,6 +63,15 @@ export class Agent {
   /** Agent 默认模型；Session 可以显式覆盖。 */
   readonly model?: ModelClient;
 
+  /**
+   * 新建 Session 时注入的默认目录。
+   *
+   * 关键点（中文）
+   * - 它是宿主在构造 Agent 时声明的默认值，不是绑定；单个 Session 可用 `set({ workspace })` 换掉。
+   * - 省略时新建的 Session 没有项目上下文：没有文件工具与 Shell，纯模型对话仍可用。
+   */
+  readonly workspace?: WorkspaceRuntime;
+
   /** Agent 面向用户的 Session 创建入口。 */
   readonly sessions: AgentSessionCollection;
 
@@ -77,6 +93,14 @@ export class Agent {
   /** Agent 自有检查点处理器；与容器提供的 Power hooks 合并使用。 */
   private readonly custom_hooks: ToolHookSet;
 
+  /**
+   * Agent 会话可用的会话工具；延迟创建并复用。
+   *
+   * 关键点（中文）：工具闭包住 AgentSessions，因此不需要从 ToolCallContext 回查主体；
+   * 它们只在 `origin.type === "agent"` 的会话上下文里注册。
+   */
+  private session_tools?: Record<string, Tool>;
+
   /** Agent 释放状态。 */
   private dispose_promise?: Promise<void>;
 
@@ -98,6 +122,7 @@ export class Agent {
     this.name = String(options.name || "").trim() || this.id;
     this.description = String(options.description || "").trim();
     this.model = options.model;
+    this.workspace = options.workspace;
     this.instruction = normalize_instruction_input(options.instruction);
     this.session_class = options.session_class;
     this.session_composer = options.session_composer;
@@ -114,26 +139,29 @@ export class Agent {
       get_agent_model: () => this.model,
       session_class: this.session_class,
       session_composer: this.session_composer,
-      resolve_session_context: (workspace) => {
+      resolve_session_context: (input) => {
         const storage = this.resolve_storage();
+        // 默认目录只用于新建会话；恢复时目录由宿主在 get() 时注入，
+        // 用默认值顶替会变成一次静默换目录。
+        const workspace = input?.workspace
+          ?? (input?.creating ? this.workspace : undefined);
+        const is_agent_session = is_agent_session_origin(input?.origin);
         if (!workspace) return {
           workspace_path: ".",
           logger: this.logger,
-          get_tools: () => this.resolve_tools(),
-          get_workspace_env: () => ({}),
+          get_tools: () => this.resolve_tools(undefined, is_agent_session),
           get_workspace: () => undefined,
           get_hooks: () => this.resolve_hooks(),
           store: storage.sessions,
         };
         // 静态 Workspace Tool 与 Agent Tool 的命名冲突属于 Session 创建不变量，
         // 在装配时立即失败；执行时仍通过 getter 读取最新宿主扩展。
-        this.resolve_tools(workspace);
+        this.resolve_tools(workspace, is_agent_session);
         return {
           workspace_path: workspace.path,
           workspace_id: workspace.id,
           logger: this.logger,
-          get_tools: () => this.resolve_tools(workspace),
-          get_workspace_env: () => workspace.get_env(),
+          get_tools: () => this.resolve_tools(workspace, is_agent_session),
           get_workspace: () => workspace,
           get_hooks: () => this.resolve_hooks(),
           store: storage.sessions,
@@ -154,6 +182,18 @@ export class Agent {
     return [...this.instruction];
   }
 
+  /**
+   * 取用 Agent 自己那条会话，不存在时先建立。
+   *
+   * 关键点（中文）
+   * - 它就是一条普通 Session：工作区能力、set/get、消息、审批与其他会话完全一致。
+   * - 不接收 Workspace：目录在创建时注入，之后用 `session.set({ workspace })` 切换。
+   */  async session(input?: AgentSessionInput): Promise<AgentSession> {
+    return await this.session_manager.self(
+      input?.workspace ? { workspace: input.workspace } : undefined,
+    );
+  }
+
   /** 返回 Agent 级日志器。 */
   get_logger(): Logger {
     return this.logger;
@@ -256,7 +296,7 @@ export class Agent {
         input.instruction_system_blocks.map((block) => block.content),
       ),
       session_id: input.session_id,
-      session_origin: { type: "chat" },
+      session_origin: { type: SESSION_ORIGIN_TYPE_WORK },
       workspace: input.workspace,
       messages: Object.freeze([]),
       workspace_env: Object.freeze({ ...input.workspace.get_env() }),
@@ -318,14 +358,28 @@ export class Agent {
    * - 容器 Power 工具从环境句柄实时读取，不缓存；容器增删 Power 后下一次求值即生效。
    * - 静态 Workspace Tool 与 Agent Tool 的命名冲突属于 Session 创建不变量，装配时立即失败。
    */
-  private resolve_tools(workspace?: WorkspaceRuntime): Record<string, Tool> {
+  private resolve_tools(workspace?: WorkspaceRuntime, is_agent_session = false): Record<string, Tool> {
     const tools: Record<string, Tool> = {};
     if (workspace) register_tools(tools, workspace.tools, "WorkspaceTools");
     register_tools(tools, this.host?.power_tools ?? {}, "Power");
     register_tools(tools, this.custom_tools, "AgentOptions.tools");
+    if (is_agent_session) register_tools(tools, this.resolve_session_tools(), "AgentSessionTools");
     return tools;
   }
 
+  /** 返回 Agent 会话的会话工具集合；首次调用时创建。 */
+  private resolve_session_tools(): Record<string, Tool> {
+    if (this.session_tools) return this.session_tools;
+    const work = new SessionWork({
+      list_sessions: async (input) => await this.session_manager.list(input),
+      get_session: async (session_id, origin_type) =>
+        await this.session_manager.get(session_id, origin_type),
+      create_session: async (input) => await this.session_manager.create(input),
+    });
+    this.session_tools = create_session_tools(work);
+    return this.session_tools;
+  }
+
   /** 合并容器 Power hooks 与 Agent 自有 hooks。 */
   private resolve_hooks(): ToolHookSet {
     const power_hooks = this.host?.power_hooks;

package/src/agent/AgentSessionIdentity.ts

@@ -0,0 +1,30 @@
+/**
+ * Agent 自己那条会话的存取规则。
+ *
+ * 职责说明（中文）
+ * - Agent 自己就是一条 Session，与 work / task / group 会话是同一种东西。
+ * - 它没有专属字段、专属索引或专属存储：角色由 `origin.type = "agent"` 表达，
+ *   分区沿用 `sessions/<origin_type>/<session_id>/`，能力与其他会话完全一致。
+ * - 因此这里只有存取所需的两个小函数，不引入新概念。
+ *
+ * 关键点（中文）
+ * - 它的 `session_id` 等于 Agent 的 `id`：会话由它属于谁来标识，不需要人造常量。
+ * - 一个 Agent 至多一条，惰性创建；被归档或删除后下一次取用自然重建。
+ */
+
+import {
+  SESSION_ORIGIN_TYPE_AGENT,
+  type SessionOrigin,
+} from "@downcity/type";
+
+/** Agent 自己那条会话的来源；不携带额外业务字段。 */
+export function create_agent_session_origin(): SessionOrigin {
+  return Object.freeze({ type: SESSION_ORIGIN_TYPE_AGENT });
+}
+
+/** Agent 自己那条会话的稳定标识：就是 Agent 的 id。 */
+export function resolve_agent_session_id(agent_id: string): string {
+  const resolved = String(agent_id || "").trim();
+  if (!resolved) throw new Error("Agent session requires a non-empty agent id");
+  return resolved;
+}

package/src/agent/AgentSessions.ts

@@ -37,7 +37,9 @@ import type { SessionStore } from "@/types/store/SessionStore.js";
 import type { SessionStorage } from "@/types/store/SessionStorage.js";
 import type { WorkspaceRuntime } from "@downcity/type";
 import type { SessionOrigin } from "@downcity/type";
-import { normalize_session_origin, normalize_session_origin_type } from "@downcity/type";
+import { normalize_session_origin, normalize_session_origin_type, SESSION_ORIGIN_TYPE_WORK } from "@downcity/type";
+import type { SessionContextResolution } from "@/types/agent/SessionContext.js";
+import { create_agent_session_origin, resolve_agent_session_id } from "@/agent/AgentSessionIdentity.js";
 
 type AgentSessionsOptions = {
   /**
@@ -58,15 +60,14 @@ type AgentSessionsOptions = {
   /**
    * 按 Session 解析执行上下文。
    *
-   * AgentSessions 是 Agent 唯一的 Session 集合；Workspace 相关能力不能
-   * 固定在集合实例上，而应在创建或恢复单个 Session 时解析。
+   * AgentSessions 是 Agent 唯一的 Session 集合；Workspace 与工具集合不能
+   * 固定在集合实例上，而应在创建或恢复单个 Session 时按会话身份解析。
    */
-  resolve_session_context: (workspace?: WorkspaceRuntime) => {
+  resolve_session_context: (input?: SessionContextResolution) => {
     workspace_path: string;
     workspace_id?: string;
     logger: Logger;
     get_tools: () => Record<string, Tool>;
-    get_workspace_env: () => Record<string, string>;
     get_workspace: () => WorkspaceRuntime | undefined;
     get_hooks: () => ToolHookSet;
     store: SessionStore;
@@ -108,6 +109,8 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
   private readonly session_composer: SessionComposer;
   private readonly get_agent_model: AgentSessionsOptions["get_agent_model"];
   private readonly sessions_by_id = new Map<string, AgentManagedSession>();
+  /** Agent 会话创建链；并发调用共享同一创建过程，避免产生第二条。 */
+  private agent_session_creation_chain: Promise<void> = Promise.resolve();
 
   constructor(options: AgentSessionsOptions) {
     this.agent_id = options.agent_id;
@@ -170,7 +173,7 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
    * runtime 是执行层的内部投影，不负责创建 Session。需要创建时必须
    * 通过 `create()` 获取内部生成的 ID；需要恢复时必须先调用 `get()`。
    */
-  runtime(session_id: string, origin_type = "chat"): SessionPort {
+  runtime(session_id: string, origin_type = SESSION_ORIGIN_TYPE_WORK): SessionPort {
     const resolved_session_id = String(session_id || "").trim();
     const resolved_origin_type = normalize_session_origin_type(origin_type);
     const session = this.sessions_by_id.get(
@@ -184,6 +187,72 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
     return session.get_runtime_port();
   }
 
+  /**
+   * 取用 Agent 自己那条会话；不存在时创建。
+   *
+   * 关键点（中文）
+   * - 身份就是 `origin.type = "agent"`，`session_id` 就是 Agent 的 `id`：
+   *   因此不新增索引，也不维护额外状态。
+   * - 同一进程内并发调用会收敛到同一个创建过程，不会产生第二条。
+   * - 被归档或删除后，下一次调用自然重建一条。
+   */
+  async self(input?: { workspace?: WorkspaceRuntime }): Promise<AgentSession> {
+    const existing = await this.find_agent_session();
+    if (existing) return existing;
+    return await this.run_agent_session_creation(async () => {
+      const cached = await this.find_agent_session();
+      if (cached) return cached;
+      const origin = create_agent_session_origin();
+      const context = this.resolve_session_context({
+        origin,
+        creating: true,
+        ...(input?.workspace ? { workspace: input.workspace } : {}),
+      });
+      const session_id = resolve_agent_session_id(this.agent_id);
+      const session = this.get_or_create_session({
+        session_id,
+        origin,
+        ...(input?.workspace ? { workspace: input.workspace } : {}),
+        storage: context.store.create_session(session_id, origin, context.workspace_id),
+      });
+      await session.initialize();
+      return session;
+    });
+  }
+
+  /**
+   * 尝试恢复已存在的 Agent 会话；不存在或已失效时返回空。
+   *
+   * 关键点（中文）：查找不传 Workspace；传 Workspace 只在创建时生效，
+   * 否则「已存在时忽略该参数」会退化成一次静默切目录。
+   */
+  private async find_agent_session(): Promise<AgentSession | undefined> {
+    const origin = create_agent_session_origin();
+    const context = this.resolve_session_context({ origin });
+    const session_id = resolve_agent_session_id(this.agent_id);
+    try {
+      if (!(await context.store.has_session(session_id, origin.type))) {
+        return undefined;
+      }
+    } catch {
+      return undefined;
+    }
+    return await this.get(session_id, origin.type);
+  }
+
+  /** 串行化 Agent 会话创建；失败时释放链，使下一次调用可以重试。 */
+  private async run_agent_session_creation(
+    create: () => Promise<AgentSession>,
+  ): Promise<AgentSession> {
+    const previous = this.agent_session_creation_chain;
+    const operation = previous.then(create, create);
+    this.agent_session_creation_chain = operation.then(
+      () => undefined,
+      () => undefined,
+    );
+    return await operation;
+  }
+
   /**
    * 新建一个 session。
    */
@@ -192,7 +261,11 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
   ): Promise<AgentSession> {
     const origin = normalize_session_origin(input?.origin);
     const session_id = `session-${Date.now()}-${nanoid(8)}`;
-    const context = this.resolve_session_context(input?.workspace);
+    const context = this.resolve_session_context({
+      origin,
+      creating: true,
+      ...(input?.workspace ? { workspace: input.workspace } : {}),
+    });
     const session = this.get_or_create_session({
       session_id,
       workspace: input?.workspace,
@@ -209,10 +282,15 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
 
   /**
    * 获取一个已存在的 session。
+   *
+   * 关键点（中文）
+   * - 当前目录不是 Session 身份：传入的 Workspace 与持久化值不一致时不再报错，
+   *   而是以传入值为准成为该 Session 的新当前目录。
+   * - 省略 Workspace 时沿用持久化值；两者都为空时该 Session 没有项目上下文。
    */
   async get(
     session_id: string,
-    origin_type = "chat",
+    origin_type = SESSION_ORIGIN_TYPE_WORK,
     input?: { workspace?: WorkspaceRuntime },
   ): Promise<AgentSession> {
     const resolved_session_id = String(session_id || "").trim();
@@ -221,7 +299,10 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
     }
     const resolved_origin_type = normalize_session_origin_type(origin_type);
     const cache_key = this.session_cache_key(resolved_session_id, resolved_origin_type);
-    const context = this.resolve_session_context(input?.workspace);
+    const context = this.resolve_session_context({
+      origin: { type: resolved_origin_type },
+      ...(input?.workspace ? { workspace: input.workspace } : {}),
+    });
     const store = context.store;
     if (
       !this.sessions_by_id.has(cache_key) &&
@@ -234,28 +315,21 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
     const storage = await store.open_session(resolved_session_id, resolved_origin_type);
     const persisted_metadata = await storage.read_metadata();
     const persisted_workspace_id = String(persisted_metadata.workspace_id || "").trim() || undefined;
-    const persisted_origin = persisted_metadata.origin;
-    const cached = this.sessions_by_id.get(cache_key);
     const requested_workspace_id = String(input?.workspace?.id || "").trim() || undefined;
-    if (persisted_workspace_id !== requested_workspace_id) {
-      throw new Error(
-        persisted_workspace_id
-          ? `Session "${resolved_session_id}" requires Workspace "${persisted_workspace_id}"`
-          : `Session "${resolved_session_id}" is not bound to a Workspace`,
-      );
-    }
-    if (cached && cached.workspace_id !== requested_workspace_id) {
-      throw new Error(
-        `Session "${resolved_session_id}" is already bound to Workspace "${cached.workspace_id || ""}"`,
-      );
-    }
+    // 目录不是身份，也不在 Session 侧还原：
+    // - 宿主传了实例 → 用它；
+    // - 本进程有缓存 → 沿用内存实例；
+    // - 都没有 → 该会话没有项目上下文，但仍可正常读历史与对话。
     const session = this.get_or_create_session({
       session_id: resolved_session_id,
-      workspace: input?.workspace,
-      origin: persisted_origin,
+      ...(input?.workspace ? { workspace: input.workspace } : {}),
+      origin: persisted_metadata.origin,
       storage,
     });
     await session.initialize();
+    if (requested_workspace_id && requested_workspace_id !== persisted_workspace_id) {
+      await session.set({ workspace: input?.workspace ?? null });
+    }
     return session;
   }
 
@@ -266,7 +340,7 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
    * - 正在执行的 Session 会先停止，避免删除后继续写入。
    * - 该方法不处理任何 Power 自有数据。
    */
-  async remove(session_id: string, origin_type = "chat"): Promise<boolean> {
+  async remove(session_id: string, origin_type = SESSION_ORIGIN_TYPE_WORK): Promise<boolean> {
     const resolved_session_id = String(session_id || "").trim();
     if (!resolved_session_id) {
       throw new Error("sessions.remove requires a non-empty session_id");
@@ -289,7 +363,7 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
   /**
    * 清空一个 Session 的消息目录。
    */
-  async clear_messages(session_id: string, origin_type = "chat"): Promise<boolean> {
+  async clear_messages(session_id: string, origin_type = SESSION_ORIGIN_TYPE_WORK): Promise<boolean> {
     const resolved_session_id = String(session_id || "").trim();
     if (!resolved_session_id) {
       throw new Error("sessions.clear_messages requires a non-empty session_id");
@@ -315,8 +389,8 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
   async list(
     input?: AgentListSessionsInput,
   ): Promise<AgentSessionSummaryPage> {
-    const origin_type = normalize_session_origin_type(input?.origin_type ?? "chat");
-    return await this.resolve_session_context().store.list_sessions(
+    const origin_type = normalize_session_origin_type(input?.origin_type ?? SESSION_ORIGIN_TYPE_WORK);
+    return await this.resolve_session_context({ origin: { type: origin_type } }).store.list_sessions(
       { ...(input || {}), origin_type },
       new Set(this.list_executing_session_ids(undefined, origin_type)),
     );
@@ -332,7 +406,7 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
     if (!session_id) {
       throw new Error("sessions.archive requires a non-empty id");
     }
-    const origin_type = normalize_session_origin_type(input.origin_type ?? "chat");
+    const origin_type = normalize_session_origin_type(input.origin_type ?? SESSION_ORIGIN_TYPE_WORK);
     const cache_key = this.session_cache_key(session_id, origin_type);
 
     const cached = this.sessions_by_id.get(cache_key);
@@ -363,46 +437,11 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
   }
 
   /**
-   * 把 Session 重新绑定到另一个 Workspace。
+   * 删除：把 Session 重新绑定到另一个 Workspace。
    *
-   * 关键点（中文）
-   * - 只改写 session_state 中的 workspace_id 并清掉运行时缓存；
-   * - 之后用新 Workspace 恢复时不再触发严格的 workspace 归属校验。
+   * 删除理由：它表达的是「Workspace 是 Session 绑定」这个旧模型。目录切换改由
+   * `session.set({ workspace })` 承担，恢复时不再校验归属，因此不需要第二条路径。
    */
-  async workspace(
-    session_id: string,
-    workspace: WorkspaceRuntime,
-  ): Promise<AgentSession> {
-    const resolved_session_id = String(session_id || "").trim();
-    if (!resolved_session_id) {
-      throw new Error("sessions.workspace requires a non-empty session_id");
-    }
-    const resolved_origin_type = normalize_session_origin_type("chat");
-    const cache_key = this.session_cache_key(resolved_session_id, resolved_origin_type);
-    const cached = this.sessions_by_id.get(cache_key);
-    if (cached?.is_executing()) {
-      throw new Error(`Session "${resolved_session_id}" is currently executing`);
-    }
-    const context = this.resolve_session_context(workspace);
-    if (!(await context.store.has_session(resolved_session_id, resolved_origin_type))) {
-      throw new Error(`Session "${resolved_session_id}" not found`);
-    }
-    const store = await context.store.open_session(
-      resolved_session_id,
-      resolved_origin_type,
-    );
-    const metadata = await store.read_metadata();
-    if (metadata.agent_id !== this.agent_id) {
-      throw new Error(`Session "${resolved_session_id}" belongs to another Agent`);
-    }
-    await store.write_metadata({
-      ...metadata,
-      workspace_id: context.workspace_id,
-    });
-    this.sessions_by_id.delete(cache_key);
-    cached?.dispose_title_generation?.();
-    return await this.get(resolved_session_id, resolved_origin_type, { workspace });
-  }
 
   private get_or_create_session(input?: {
     /**
@@ -419,28 +458,31 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
     const resolved_session_id = String(
       input?.session_id || input?.storage?.session_id || "",
     ).trim() || `session-${Date.now()}-${nanoid(8)}`;
-    const origin = normalize_session_origin(input?.origin);
-    const cache_key = this.session_cache_key(resolved_session_id, origin.type);
+    const resolved_origin = normalize_session_origin(input?.origin);
+    const cache_key = this.session_cache_key(resolved_session_id, resolved_origin.type);
     const cached = this.sessions_by_id.get(cache_key);
     if (cached) return cached;
 
-    const context = this.resolve_session_context(input?.workspace);
+    const context = this.resolve_session_context({
+      ...(input?.origin ? { origin: input.origin } : {}),
+      creating: true,
+      ...(input?.workspace ? { workspace: input.workspace } : {}),
+    });
     const created = new this.session_class({
       agent_id: this.agent_id,
       agent_name: this.agent_name,
       agent_description: this.agent_description,
       workspace_path: context.workspace_path,
-      ...(context.workspace_id ? { workspace_id: context.workspace_id } : {}),
-      origin,
-      store: input?.storage || context.store.create_session(resolved_session_id, origin, context.workspace_id),
-      create_session_store: (session_id) => context.store.create_session(session_id, origin, context.workspace_id),
+      ...(context.get_workspace() ? { workspace: context.get_workspace() } : {}),
+      origin: resolved_origin,
+      store: input?.storage || context.store.create_session(resolved_session_id, resolved_origin, context.workspace_id),
+      create_session_store: (session_id) => context.store.create_session(session_id, resolved_origin, context.workspace_id),
       register_forked_session: (session) => this.register_forked_session(session),
       session_id: resolved_session_id,
       get_tools: () => context.get_tools(),
       logger: context.logger,
       instruction_system_blocks: this.load_instruction_system_blocks(),
       get_instruction_system_blocks: () => this.load_instruction_system_blocks(),
-      get_workspace_env: () => context.get_workspace_env(),
       get_workspace: () => context.get_workspace(),
       get_agent_model: () => this.get_agent_model(),
       get_hooks: () => context.get_hooks(),
@@ -459,7 +501,7 @@ export class AgentSessions implements AgentSessionsContract<AgentSession> {
    * - 返回是否真的释放。调用方必须先自行解除对该实例的订阅，否则重新 `get()` 会拿到新实例
    *   而旧订阅仍然挂在被丢弃的实例上。
    */
-  release(session_id: string, origin_type = "chat"): boolean {
+  release(session_id: string, origin_type = SESSION_ORIGIN_TYPE_WORK): boolean {
     const resolved_session_id = String(session_id || "").trim();
     if (!resolved_session_id) return false;
     const cache_key = this.session_cache_key(