@keyou007/agent-bot 0.1.11 → 0.1.13-alpha.0

package/src/proxy/ProxySessionController.ts

@@ -148,10 +148,23 @@ interface ResolvedThreadForkAnchor {
 }
 
 interface CreatedFeishuGroupContext {
+  chatId: string;
   contextKey: string;
   name: string;
 }
 
+interface CreatedFeishuTaskGroup {
+  group: CreatedFeishuGroupContext;
+  task: SessionRecord;
+}
+
+export interface ControlTaskGroupResult {
+  sourceLocalSessionId: string;
+  sourceTurnId?: string;
+  group: CreatedFeishuGroupContext;
+  task: SessionRecord;
+}
+
 export interface ProxyLifecycle {
   supervised?: boolean;
   restart(contextKey: string, force: boolean): Promise<void>;
@@ -551,7 +564,7 @@ export class ProxySessionController {
         try {
           remote = await runtime.readRemoteSession(record.remoteSessionId);
         } catch (error) {
-          this.logger.warn({ error, sessionId: record.localSessionId }, "Failed to inspect Codex task status for CLI.");
+          this.logger.warn({ error, sessionId: record.localSessionId }, "Failed to inspect App Server task status for CLI.");
         }
       }
     }
@@ -615,6 +628,7 @@ export class ProxySessionController {
         responseContextKey,
         scopedRecord.title,
         scopedRecord.cwd,
+        this.agentLabel(scopedRecord.agentName),
       );
       const promptMessageId = await this.outbound.withReplyTarget(
         responseContextKey,
@@ -641,6 +655,82 @@ export class ProxySessionController {
     return `The Prompt was posted to the original chat and submitted to the task: ${record.title ?? record.remoteSessionId ?? record.localSessionId}`;
   }
 
+  async controlCreateTaskGroup(
+    localSessionId: string,
+    requestedTitle: string | undefined,
+    userOpenId: string | undefined,
+    requestedProjectCwd?: string,
+    forceProjectless = false,
+    requestedAgentName?: string,
+  ): Promise<ControlTaskGroupResult> {
+    const source = this.store.getSession(localSessionId);
+    if (!source || source.status === "closed") throw new Error(`Task not found: ${localSessionId}`);
+    const agentName = requestedAgentName?.trim() || source.agentName;
+    const agent = this.ensureAgent(agentName);
+    if (forceProjectless && agent.kind !== "app-server") {
+      throw new Error("task newgroup --nodir is only available for App Server agents.");
+    }
+    const sourceContextKey = this.outbound.getSessionContextKey(localSessionId) ?? source.contextKey;
+    const replyTarget = this.outbound.getSessionReplyTarget(localSessionId);
+    const boundProjectCwd = forceProjectless
+      ? undefined
+      : requestedProjectCwd === undefined
+        ? detectProjectlessWorkspace(source.cwd) ? undefined : source.cwd
+        : resolveUserPath(requestedProjectCwd);
+    const created = await this.outbound.withReplyTarget(sourceContextKey, replyTarget, () =>
+      this.createFeishuGroupWithTask(
+        sourceContextKey,
+        agentName,
+        requestedTitle,
+        userOpenId,
+        boundProjectCwd,
+        source.agentName === agentName
+          ? {
+              modelProvider: source.modelProvider,
+              model: source.model,
+              reasoningEffort: source.reasoningEffort,
+              permissionMode: source.permissionMode,
+            }
+          : {},
+      ));
+    return {
+      sourceLocalSessionId: source.localSessionId,
+      group: created.group,
+      task: created.task,
+    };
+  }
+
+  async controlForkTaskGroup(
+    localSessionId: string,
+    requestedTitle: string | undefined,
+    userOpenId: string | undefined,
+  ): Promise<ControlTaskGroupResult> {
+    const source = this.store.getSession(localSessionId);
+    if (!source || source.status === "closed") throw new Error(`Task not found: ${localSessionId}`);
+    const sourceContextKey = this.outbound.getSessionContextKey(localSessionId) ?? source.contextKey;
+    const replyTarget = this.outbound.getSessionReplyTarget(localSessionId);
+    const plan = await this.prepareForkSession(sourceContextKey, localSessionId, requestedTitle);
+    const prepared: ForkGroupSessionPlan = {
+      plan,
+      sourceDescription: plan.forkedFromHistoricalTurn
+        ? "当前任务最近已完成轮次"
+        : "当前任务最新轮次",
+    };
+    const forked = await this.outbound.withReplyTarget(sourceContextKey, replyTarget, () =>
+      this.forkPreparedSessionToFeishuGroup(
+        sourceContextKey,
+        prepared,
+        userOpenId ?? "",
+        "当前任务",
+      ));
+    return {
+      sourceLocalSessionId: source.localSessionId,
+      sourceTurnId: plan.lastTurnId,
+      group: forked.group,
+      task: forked.task,
+    };
+  }
+
   private cardActionContextKey(action: CardAction): string {
     const explicit = typeof action.value.contextKey === "string" ? action.value.contextKey : undefined;
     if (explicit && baseChatContextKey(explicit) === baseChatContextKey(action.contextKey)) return explicit;
@@ -676,8 +766,8 @@ export class ProxySessionController {
         await this.runShellCommand(contextKey, command.command);
         return;
       case "new":
-        if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "codex") {
-          throw new Error("/new --nodir 仅支持 Codex Agent。");
+        if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "app-server") {
+          throw new Error("/new --nodir 仅支持 App Server Agent。");
         }
         await this.createSession(
           contextKey,
@@ -696,8 +786,8 @@ export class ProxySessionController {
         );
         return;
       case "newgroup":
-        if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "codex") {
-          throw new Error("/newgroup --nodir 仅支持 Codex Agent。");
+        if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "app-server") {
+          throw new Error("/newgroup --nodir 仅支持 App Server Agent。");
         }
         await this.createFeishuGroup(
           contextKey,
@@ -772,7 +862,13 @@ export class ProxySessionController {
       const turnContextKey = session.lastTurnId
         ? this.store.getTurnContextKey(session.lastTurnId) ?? context.contextKey
         : context.contextKey;
-      this.outbound.registerSession(session.localSessionId, turnContextKey, session.title, session.cwd);
+      this.outbound.registerSession(
+        session.localSessionId,
+        turnContextKey,
+        session.title,
+        session.cwd,
+        this.agentLabel(session.agentName),
+      );
       if (!session.lastTurnId) continue;
       void this.outbound.resumeDelivery(session.localSessionId, turnContextKey, session.lastTurnId).catch((error: unknown) => {
         this.logger.warn({ error, sessionId: session.localSessionId }, "Failed to restore persisted turn delivery.");
@@ -811,7 +907,7 @@ export class ProxySessionController {
     replyTarget?: MessageReplyTarget,
     localImagePaths?: string[],
   ): Promise<void> {
-    if (!text.trim()) throw new Error("请输入要交给 Codex 的内容。");
+    if (!text.trim()) throw new Error("请输入要交给 Agent 的内容。");
     let record = this.currentSession(contextKey);
     if (!record) {
       const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent!);
@@ -838,7 +934,13 @@ export class ProxySessionController {
   ): Promise<void> {
     const configuredRuntime = this.runtimes.forAgent(record.agentName);
     if (!configuredRuntime.getSession(record.localSessionId)) {
-      this.outbound.registerSession(record.localSessionId, contextKey, record.title, record.cwd);
+      this.outbound.registerSession(
+        record.localSessionId,
+        contextKey,
+        record.title,
+        record.cwd,
+        this.agentLabel(record.agentName),
+      );
       await this.outbound.startPendingTurn(record.localSessionId, contextKey, record.title, replyTarget, text);
     }
     let loaded: LoadedSession;
@@ -879,7 +981,7 @@ export class ProxySessionController {
         if (messageId) await this.bindMessageReactionToTurn(messageId, record.localSessionId, activeTurnId);
         return;
       } catch (error) {
-        this.logger.debug({ error, sessionId: record.localSessionId, activeTurnId }, "Steering failed; reconciling the Codex thread.");
+        this.logger.debug({ error, sessionId: record.localSessionId, activeTurnId }, "Steering failed; reconciling the App Server thread.");
         let current = loaded.runtime.getSession(record.localSessionId);
         try {
           current = await loaded.runtime.synchronizeSession(record.localSessionId);
@@ -904,7 +1006,7 @@ export class ProxySessionController {
           } catch (retryError) {
             this.logger.warn(
               { error: retryError, sessionId: record.localSessionId, activeTurnId: current.activeTurnId },
-              "Failed to steer the reconciled Codex turn; queueing prompt.",
+              "Failed to steer the reconciled App Server turn; queueing prompt.",
             );
           }
         }
@@ -1074,7 +1176,7 @@ export class ProxySessionController {
     const agent = this.ensureAgent(source.agentName);
     const runtime = this.runtimes.forAgent(source.agentName);
     if (runtime.kind !== "codex" || !runtime.forkSession) {
-      throw new Error("当前 Codex 运行时不支持 fork 任务。");
+      throw new Error("当前 App Server Agent 不支持 fork 任务。");
     }
 
     const context = this.store.getOrCreateUserContext(message.contextKey, source.agentName);
@@ -1098,7 +1200,13 @@ export class ProxySessionController {
       permissionMode: source.permissionMode ?? "auto",
     });
     this.store.setCurrentSession(message.contextKey, localSessionId);
-    this.outbound.registerSession(localSessionId, message.contextKey, forkTitle, source.cwd);
+    this.outbound.registerSession(
+      localSessionId,
+      message.contextKey,
+      forkTitle,
+      source.cwd,
+      this.agentLabel(source.agentName),
+    );
 
     try {
       const forked = await runtime.forkSession({
@@ -1145,14 +1253,14 @@ export class ProxySessionController {
       .map((messageId) => this.store.findTurnAnchorByMessageId(messageId))
       .find((candidate) => candidate !== undefined);
     if (!anchor) {
-      throw new Error("无法确定这个话题对应的 Codex 轮次，因此没有创建分支任务。请从该轮的用户消息、思考卡片或最终回答创建话题。");
+      throw new Error("无法确定这个话题对应的 App Server 轮次，因此没有创建分支任务。请从该轮的用户消息、思考卡片或最终回答创建话题。");
     }
 
     const source = anchor.contextKey
       ? this.store.getSessionForContext(anchor.localSessionId, anchor.contextKey)
       : this.store.getSession(anchor.localSessionId);
     if (!source || !source.remoteSessionId || !this.isCodexSession(source)) {
-      throw new Error("这个话题的来源不是可 fork 的 Codex 任务。");
+      throw new Error("这个话题的来源不是可 fork 的 App Server 任务。");
     }
     if (baseChatContextKey(anchor.contextKey ?? source.contextKey) !== `chat_id:${message.chatId}`) {
       throw new Error("话题来源任务不属于当前会话，已拒绝创建分支。");
@@ -1161,7 +1269,7 @@ export class ProxySessionController {
     const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(anchor.turnId));
     if (isTurnStillRunning(snapshot?.status)
       || (source.lastTurnId === anchor.turnId && source.lastTurnStatus === "running")) {
-      throw new Error("话题对应的轮次仍在执行，Codex 暂时不能从这一轮 fork。请等待该轮完成后再在话题中发送消息。");
+      throw new Error("话题对应的轮次仍在执行，App Server 暂时不能从这一轮 fork。请等待该轮完成后再在话题中发送消息。");
     }
 
     return { anchor, source, snapshot };
@@ -1203,7 +1311,7 @@ export class ProxySessionController {
     }
 
     if (source && (!source.remoteSessionId || !this.isCodexSession(source))) {
-      throw new Error(`${sourceLabel}不是可 fork 的 Codex 任务。`);
+      throw new Error(`${sourceLabel}不是可 fork 的 App Server 任务。`);
     }
 
     let runtime: AgentRuntime;
@@ -1213,20 +1321,20 @@ export class ProxySessionController {
       agentName = source.agentName;
       runtime = this.runtimes.forAgent(agentName);
     } else {
-      if (!taskId) throw new Error("缺少要 fork 的 Codex 任务 ID。");
+      if (!taskId) throw new Error("缺少要 fork 的 App Server 任务 ID。");
       const resolved = await this.resolveRemoteCodexSession(taskId);
       agentName = resolved.agentName;
       runtime = resolved.runtime;
       remote = resolved.remote;
     }
     if (runtime.kind !== "codex" || !runtime.forkSession) {
-      throw new Error("当前 Codex 运行时不支持 fork 任务。");
+      throw new Error("当前 App Server Agent 不支持 fork 任务。");
     }
 
     const remoteSessionId = source?.remoteSessionId ?? remote?.id ?? taskId;
-    if (!remoteSessionId) throw new Error("当前任务尚未创建 Codex 任务 ID，暂时不能 fork。");
+    if (!remoteSessionId) throw new Error("当前任务尚未创建 App Server 任务 ID，暂时不能 fork。");
     if (!runtime.readRemoteSession && !source) {
-      throw new Error("当前 Codex 运行时不支持读取指定任务。");
+      throw new Error("当前 App Server Agent 不支持读取指定任务。");
     }
     remote ??= runtime.readRemoteSession
       ? await runtime.readRemoteSession(remoteSessionId)
@@ -1251,7 +1359,7 @@ export class ProxySessionController {
     const forkedFromHistoricalTurn = isRunning && lastTurnId !== latestTurnId;
 
     const cwd = remote?.cwd || source?.cwd;
-    if (!cwd) throw new Error("指定的 Codex 任务没有可用的工作目录，暂时不能 fork。");
+    if (!cwd) throw new Error("指定的 App Server 任务没有可用的工作目录，暂时不能 fork。");
     const sourceTitle = remote?.title ?? source?.title ?? remote?.preview;
     const forkTitle = normalizeTaskTitle(requestedTitle) ?? this.store.nextForkTitle(sourceTitle);
     const modelProvider = remote?.modelProvider ?? source?.modelProvider;
@@ -1332,16 +1440,16 @@ export class ProxySessionController {
     sourceLabel: string,
   ): ForkSessionPlan {
     if (!source.remoteSessionId || !this.isCodexSession(source)) {
-      throw new Error(`${sourceLabel}不是可 fork 的 Codex 任务。`);
+      throw new Error(`${sourceLabel}不是可 fork 的 App Server 任务。`);
     }
     const runtime = this.runtimes.forAgent(source.agentName);
     if (runtime.kind !== "codex" || !runtime.forkSession) {
-      throw new Error("当前 Codex 运行时不支持 fork 任务。");
+      throw new Error("当前 App Server Agent 不支持 fork 任务。");
     }
 
     const snapshot = turnViewSnapshot(this.store.getTurnSnapshot(lastTurnId));
     if (isTurnStillRunning(snapshot?.status)) {
-      throw new Error(`${sourceLabel}仍在执行，Codex 暂时不能从这一轮 fork。`);
+      throw new Error(`${sourceLabel}仍在执行，App Server 暂时不能从这一轮 fork。`);
     }
     const sourceWasRunning = Boolean(
       runtime.getSession(source.localSessionId)?.activeTurnId
@@ -1411,7 +1519,13 @@ export class ProxySessionController {
         lastTurnStatus: plan.lastTurnStatus,
       });
       this.store.setCurrentSession(contextKey, localSessionId);
-      this.outbound.registerSession(localSessionId, contextKey, forked.title ?? plan.forkTitle, plan.cwd);
+      this.outbound.registerSession(
+        localSessionId,
+        contextKey,
+        forked.title ?? plan.forkTitle,
+        plan.cwd,
+        this.agentLabel(plan.agentName),
+      );
       this.store.audit(contextKey, "session_forked", {
         sourceLocalSessionId: plan.source?.localSessionId,
         sourceRemoteSessionId: plan.remoteSessionId,
@@ -1464,7 +1578,7 @@ export class ProxySessionController {
     }
     const source = direct ?? this.findStoredSessionByReference(taskId);
     if (source && !this.isCodexSession(source)) {
-      throw new Error("指定任务不是 Codex 任务，暂时不能按项目创建新任务。");
+      throw new Error("指定任务不是 App Server 任务，暂时不能按项目创建新任务。");
     }
 
     let agentName: string;
@@ -1495,7 +1609,7 @@ export class ProxySessionController {
 
     const cwd = remote?.cwd || source?.cwd;
     if (!cwd) {
-      throw new Error("指定的 Codex 任务没有可用的工作目录，暂时不能按项目创建新任务。");
+      throw new Error("指定的 App Server 任务没有可用的工作目录，暂时不能按项目创建新任务。");
     }
     const executionSettings: SessionExecutionSettings = {
       modelProvider: remote?.modelProvider ?? source?.modelProvider,
@@ -1566,7 +1680,7 @@ export class ProxySessionController {
     const agent = this.ensureAgent(agentName);
     const localSessionId = createId("sess");
     const initialTitle = normalizeTaskTitle(requestedTitle ?? prompt ?? "");
-    const sessionCwd = cwd === undefined && agent.kind === "codex"
+    const sessionCwd = cwd === undefined && agent.kind === "app-server"
       ? createProjectlessWorkspace({ prompt: initialTitle }).cwd
       : path.resolve(cwd ?? this.config.defaults.cwd);
     const record = this.store.createSession({ localSessionId, contextKey, agentName, cwd: sessionCwd, status: "starting" });
@@ -1580,7 +1694,13 @@ export class ProxySessionController {
       });
     }
     this.store.setCurrentSession(contextKey, localSessionId);
-    this.outbound.registerSession(localSessionId, contextKey, initialTitle, sessionCwd);
+    this.outbound.registerSession(
+      localSessionId,
+      contextKey,
+      initialTitle,
+      sessionCwd,
+      this.agentLabel(agentName),
+    );
     const runtime = this.runtimes.forAgent(agentName);
     try {
       if (prepareTurn) {
@@ -1666,9 +1786,9 @@ export class ProxySessionController {
     userId: string | undefined,
     boundProjectCwd: string | undefined,
     executionSettings: SessionExecutionSettings,
-  ): Promise<void> {
+  ): Promise<CreatedFeishuTaskGroup> {
     const explicitTitle = normalizeTaskTitle(requestedTitle);
-    const taskTitle = explicitTitle ?? "新任务";
+    const taskTitle = explicitTitle ?? `新任务 (${formatGroupDateSuffix(new Date())})`;
     const group = await this.createFeishuGroupContext(
       sourceContextKey,
       agentName,
@@ -1676,7 +1796,7 @@ export class ProxySessionController {
       userId,
       boundProjectCwd,
       "/newgroup",
-      !explicitTitle,
+      false,
     );
 
     let task: SessionRecord;
@@ -1709,7 +1829,7 @@ export class ProxySessionController {
         "群和新任务已创建。",
         `当前任务：${taskDescription}`,
         `当前 Project 目录：${boundProjectCwd ?? "未绑定（Projectless）"}`,
-        `当前 Provider：${task.modelProvider ?? "Codex 默认"}`,
+        `当前 Provider：${task.modelProvider ?? "Agent 默认"}`,
         `当前模型：${task.model ?? "默认"}`,
         `思考强度：${task.reasoningEffort ?? "自动"}`,
         `权限类型：${task.permissionMode === "confirm" ? "执行前确认" : "自动执行"}`,
@@ -1719,6 +1839,7 @@ export class ProxySessionController {
       sourceContextKey,
       `已创建飞书群：${group.name}，并创建新任务 ${taskDescription}。`,
     );
+    return { group, task };
   }
 
   private async forkCurrentSessionToFeishuGroup(
@@ -1766,7 +1887,7 @@ export class ProxySessionController {
     prepared: ForkGroupSessionPlan,
     userId: string,
     sourceSummary: string,
-  ): Promise<void> {
+  ): Promise<CreatedFeishuTaskGroup> {
     const { plan } = prepared;
     const boundProjectCwd = detectProjectlessWorkspace(plan.cwd) ? undefined : plan.cwd;
     const group = await this.createFeishuGroupContext(
@@ -1799,7 +1920,7 @@ export class ProxySessionController {
         `已从${prepared.sourceDescription}创建分支。`,
         `当前任务：${taskDescription}`,
         `当前 Project 目录：${boundProjectCwd ?? "未绑定（Projectless）"}`,
-        `当前 Provider：${forked.session.modelProvider ?? "Codex 默认"}`,
+        `当前 Provider：${forked.session.modelProvider ?? "Agent 默认"}`,
         `当前模型：${forked.session.model ?? "默认"}`,
         `思考强度：${forked.session.reasoningEffort ?? "自动"}`,
         `权限类型：${forked.session.permissionMode === "confirm" ? "执行前确认" : "自动执行"}`,
@@ -1809,6 +1930,7 @@ export class ProxySessionController {
       sourceContextKey,
       `已将${sourceSummary} Fork 到飞书群：${group.name}；新群当前任务为 ${taskDescription}。`,
     );
+    return { group, task: forked.record };
   }
 
   private async createFeishuGroupContext(
@@ -1836,7 +1958,7 @@ export class ProxySessionController {
     this.store.recordChatContext(groupContextKey, "group");
     this.store.getOrCreateUserContext(groupContextKey, agentName);
     if (boundProjectCwd) this.store.setBoundProjectCwd(groupContextKey, boundProjectCwd);
-    return { contextKey: groupContextKey, name: group.name };
+    return { chatId: group.chatId, contextKey: groupContextKey, name: group.name };
   }
 
   private async loadSession(record: SessionRecord): Promise<LoadedSession> {
@@ -1847,7 +1969,13 @@ export class ProxySessionController {
     const pending = this.sessionLoads.get(record.localSessionId);
     if (pending) return pending;
 
-    this.outbound.registerSession(record.localSessionId, record.contextKey, record.title, record.cwd);
+    this.outbound.registerSession(
+      record.localSessionId,
+      record.contextKey,
+      record.title,
+      record.cwd,
+      this.agentLabel(record.agentName),
+    );
     const loading = (async (): Promise<LoadedSession> => {
       if (record.lastTurnId) {
         try {
@@ -1874,15 +2002,15 @@ export class ProxySessionController {
             model: record.model,
             reasoningEffort: record.reasoningEffort,
             permissionMode,
-            activeTurnId: agent.kind === "codex" && record.status === "running" && record.lastTurnStatus === "running"
+            activeTurnId: agent.kind === "app-server" && record.status === "running" && record.lastTurnStatus === "running"
               ? record.lastTurnId
               : undefined,
             lastTurnId: record.lastTurnId,
             lastTurnStatus: record.lastTurnStatus,
           });
         } catch (error) {
-          if (!(agent.kind === "codex" && !record.lastTurnId && isMissingRolloutError(error))) throw error;
-          this.logger.warn({ error, sessionId: record.localSessionId }, "Codex task has no rollout; creating a replacement task.");
+          if (!(agent.kind === "app-server" && !record.lastTurnId && isMissingRolloutError(error))) throw error;
+          this.logger.warn({ error, sessionId: record.localSessionId }, "App Server task has no rollout; creating a replacement task.");
           session = await runtime.createSession({
             localSessionId: record.localSessionId,
             agentName: record.agentName,
@@ -2102,7 +2230,7 @@ export class ProxySessionController {
         } catch (error) {
           this.logger.warn(
             { error, sessionId: record.localSessionId },
-            "Failed to pause the active Codex goal before interrupting its turn.",
+            "Failed to pause the active Agent goal before interrupting its turn.",
           );
         }
       }
@@ -2116,7 +2244,7 @@ export class ProxySessionController {
         } catch (error) {
           this.logger.warn(
             { error, sessionId: record.localSessionId, remoteSessionId: record.remoteSessionId },
-            "Failed to inspect the current Codex turn before interrupting; using the locally tracked turn.",
+            "Failed to inspect the current App Server turn before interrupting; using the locally tracked turn.",
           );
         }
       }
@@ -2130,7 +2258,7 @@ export class ProxySessionController {
         remoteSessionId: record.remoteSessionId,
         turnId,
       });
-      await this.outbound.sendText(record.contextKey, `已向 Codex 发送 Interrupt 请求：${turnId}`);
+      await this.outbound.sendText(record.contextKey, `已向 Agent 发送 Interrupt 请求：${turnId}`);
       return;
     }
 
@@ -2480,7 +2608,7 @@ export class ProxySessionController {
       }
       const context = this.store.getOrCreateUserContext(contextKey, this.config.defaults.agent!);
       const agent = this.ensureAgent(context.defaultAgent);
-      if (agent.kind !== "codex") throw new Error("Goal 模式仅支持 Codex App Server 任务。");
+      if (agent.kind !== "app-server") throw new Error("Goal 模式仅支持 App Server 任务。");
       record = await this.createSession(
         contextKey,
         context.defaultAgent,
@@ -2493,7 +2621,7 @@ export class ProxySessionController {
 
     const loaded = await this.loadSession(record);
     if (loaded.runtime.kind !== "codex" || !loaded.runtime.getGoal || !loaded.runtime.setGoal || !loaded.runtime.clearGoal) {
-      throw new Error("当前任务不支持 Codex Goal 模式。");
+      throw new Error("当前 Agent 不支持 Goal 模式。");
     }
 
     if (command.action === "show") {
@@ -2520,7 +2648,7 @@ export class ProxySessionController {
         goal,
         command.action === "pause"
           ? "Goal 已暂停；当前轮次可以完成，但不会继续自动执行。"
-          : "Goal 已恢复，Codex 会继续自动执行。",
+          : "Goal 已恢复，Agent 会继续自动执行。",
         record,
       );
       return;
@@ -2541,7 +2669,7 @@ export class ProxySessionController {
     await this.sendGoalCard(
       contextKey,
       goal,
-      command.action === "edit" ? "Goal 已更新。" : "Goal 已启动，Codex 会持续执行直到完成、暂停或遇到阻塞。",
+      command.action === "edit" ? "Goal 已更新。" : "Goal 已启动，Agent 会持续执行直到完成、暂停或遇到阻塞。",
       record,
     );
   }
@@ -2562,7 +2690,7 @@ export class ProxySessionController {
         title: "任务",
         lines: [
           `**标题**：${cardText(record.title ?? "未命名任务")}`,
-          `**Codex 任务 ID**：${cardText(record.remoteSessionId ?? "尚未创建")}`,
+          `**App Server 任务 ID**：${cardText(record.remoteSessionId ?? "尚未创建")}`,
         ],
       });
     }
@@ -2573,7 +2701,7 @@ export class ProxySessionController {
         "**/goal edit &#60;新目标&#62;**　修改　　**/goal clear**　清除",
       ],
     });
-    await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderSectionsCard("Codex Goal", sections));
+    await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderSectionsCard("Agent Goal", sections));
   }
 
   private async runShellCommand(contextKey: string, command: string): Promise<void> {
@@ -2717,7 +2845,7 @@ export class ProxySessionController {
         remoteSessions.push(...page.sessions.map((session) => ({ agentName, session })));
         remoteHasMore ||= Boolean(page.nextCursor);
       } catch (error) {
-        this.logger.warn({ error, contextKey, agentName }, "Failed to list Codex sessions for an Agent.");
+        this.logger.warn({ error, contextKey, agentName }, "Failed to list App Server sessions for an Agent.");
         remoteErrors.push(`${agentName}: ${error instanceof Error ? error.message : String(error)}`);
       }
     }));
@@ -2809,7 +2937,7 @@ export class ProxySessionController {
       };
     });
     const card = this.cardRenderer.renderTaskListCard(
-      searchTerm ? `Codex 任务：${searchTerm}` : "Codex 任务",
+      searchTerm ? `App Server 任务：${searchTerm}` : "App Server 任务",
       activeCount > 0 ? `任务（${activeCount} 个活跃）` : "任务",
       cardEntries,
       [
@@ -2878,7 +3006,7 @@ export class ProxySessionController {
     const candidates = scoped
       ? [[scoped.agentName, this.runtimes.forAgent(scoped.agentName)] as const]
       : this.runtimes.entries("codex");
-    if (candidates.length === 0) throw new Error("未配置 Codex Agent。");
+    if (candidates.length === 0) throw new Error("未配置 App Server Agent。");
 
     const reads = await Promise.allSettled(candidates.map(async ([agentName, runtime]) => {
       if (runtime.kind !== "codex" || !runtime.readRemoteSession) {
@@ -2903,7 +3031,7 @@ export class ProxySessionController {
         : undefined)
       .filter((detail): detail is string => Boolean(detail))
       .join("；");
-    throw new Error(`找不到 Codex 任务：${scoped?.remoteSessionId ?? reference}${details ? `（${details}）` : ""}`);
+    throw new Error(`找不到 App Server 任务：${scoped?.remoteSessionId ?? reference}${details ? `（${details}）` : ""}`);
   }
 
   private async switchSession(contextKey: string, reference?: string): Promise<void> {
@@ -2919,16 +3047,22 @@ export class ProxySessionController {
       await this.assertSessionTurnOwnership(existing, runtime);
       this.store.attachSessionToContext(contextKey, existing.localSessionId);
       this.store.setCurrentSession(contextKey, existing.localSessionId);
-      this.outbound.registerSession(existing.localSessionId, contextKey, existing.title, existing.cwd);
+      this.outbound.registerSession(
+        existing.localSessionId,
+        contextKey,
+        existing.title,
+        existing.cwd,
+        this.agentLabel(existing.agentName),
+      );
       await this.outbound.sendText(contextKey, `已切换到任务：${existing.title ?? existing.remoteSessionId ?? taskId}`);
       return;
     }
 
     const { agentName, remote } = await this.resolveRemoteCodexSession(taskId);
     if (remote.status === "active" || remote.lastTurnStatus === "inProgress") {
-      throw new Error(`这个任务正在外部 Codex 中执行，当前不会切换。可使用 /status ${taskId} 查看进度。`);
+      throw new Error(`这个任务正在外部 Agent 中执行，当前不会切换。可使用 /status ${taskId} 查看进度。`);
     }
-    if (!remote.cwd) throw new Error("这个 Codex 任务没有可用的工作目录，暂时无法切换。");
+    if (!remote.cwd) throw new Error("这个 App Server 任务没有可用的工作目录，暂时无法切换。");
     const localSessionId = createId("sess");
     this.store.createSession({
       localSessionId,
@@ -2946,7 +3080,13 @@ export class ProxySessionController {
       lastTurnStatus: mapRemoteTurnStatus(remote.lastTurnStatus),
     });
     this.store.setCurrentSession(contextKey, localSessionId);
-    this.outbound.registerSession(localSessionId, contextKey, remote.title ?? remote.preview, remote.cwd);
+    this.outbound.registerSession(
+      localSessionId,
+      contextKey,
+      remote.title ?? remote.preview,
+      remote.cwd,
+      this.agentLabel(agentName),
+    );
     await this.outbound.sendText(
       contextKey,
       `已切换到任务：${remote.title ?? remote.preview ?? remote.id}。历史消息不会重新发送。`,
@@ -2969,7 +3109,7 @@ export class ProxySessionController {
 
     const { runtime, remote } = await this.resolveRemoteCodexSession(taskId);
     if (!runtime.readRemoteSession || !runtime.interruptRemoteTurn) {
-      throw new Error("当前 Codex 运行时不支持停止外部任务。");
+      throw new Error("当前 App Server Agent 不支持停止外部任务。");
     }
     const turnId = remote.status === "active" || remote.lastTurnStatus === "inProgress"
       ? remote.lastTurnId
@@ -2984,7 +3124,7 @@ export class ProxySessionController {
       turnId,
       source: "sessions_card",
     });
-    await this.outbound.sendText(contextKey, `已向 Codex 发送 Interrupt 请求：${turnId}`);
+    await this.outbound.sendText(contextKey, `已向 Agent 发送 Interrupt 请求：${turnId}`);
   }
 
   private resolveSessionReference(contextKey: string, reference?: string): string {
@@ -3025,7 +3165,7 @@ export class ProxySessionController {
         && activity.activeTurnId === record.lastTurnId;
       const botOwnsActiveTurn = runtimeOwnsActiveTurn || persistedTurnMatches;
       if (activity.active && !botOwnsActiveTurn) {
-        throw new Error("这个任务正在外部 Codex 中执行。Agent Bot 不会接管或追加消息，请等待外部执行完成。");
+        throw new Error("这个任务正在外部 Agent 中执行。Agent Bot 不会接管或追加消息，请等待外部执行完成。");
       }
       return activity;
     }
@@ -3033,14 +3173,14 @@ export class ProxySessionController {
     try {
       remote = await runtime.readRemoteSession(record.remoteSessionId);
     } catch (error) {
-      // Codex does not materialize a new thread until its first user message.
+      // App Server does not materialize a new thread until its first user message.
       // Such a thread has no turn to take over, so allow turn/start to create it.
       if (!record.lastTurnId && isUnmaterializedCodexThreadError(error)) return;
       throw error;
     }
     const botOwnsActiveTurn = isBotOwnedActiveTurn(record, remote);
     if ((remote.status === "active" || remote.lastTurnStatus === "inProgress") && !botOwnsActiveTurn) {
-      throw new Error("这个任务正在外部 Codex 中执行。Agent Bot 不会接管或追加消息，请等待外部执行完成。");
+      throw new Error("这个任务正在外部 Agent 中执行。Agent Bot 不会接管或追加消息，请等待外部执行完成。");
     }
     return undefined;
   }
@@ -3105,7 +3245,7 @@ export class ProxySessionController {
         try {
           remote = await runtime.readRemoteSession(current.remoteSessionId);
         } catch (error) {
-          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect Codex task status.");
+          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect App Server task status.");
         }
       }
       if (runtime.kind === "codex" && runtime.getGoal) {
@@ -3113,7 +3253,7 @@ export class ProxySessionController {
           const loaded = runtime.getSession(current.localSessionId) ?? (await this.loadSession(current)).session;
           goal = await runtime.getGoal(loaded.localSessionId);
         } catch (error) {
-          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect Codex goal status.");
+          this.logger.warn({ error, sessionId: current.localSessionId }, "Failed to inspect Agent goal status.");
         }
       }
     }
@@ -3125,7 +3265,7 @@ export class ProxySessionController {
     let activeTurnId: string | undefined;
     let queued = 0;
     if (!current) {
-      taskLines.push("无。直接发送消息即可创建一个未指定项目的 Codex 任务。");
+      taskLines.push("无。直接发送消息即可创建一个未指定项目的 Agent 任务。");
     } else {
       const agent = this.ensureAgent(current.agentName);
       const runtimeSession = this.runtimes.forAgent(current.agentName).getSession(current.localSessionId);
@@ -3143,11 +3283,11 @@ export class ProxySessionController {
       taskLines.push(
         `**标题**：${cardCode(current.title ?? "未命名任务")}`,
         `**工作目录**：${cardCode(current.cwd)}`,
-        `**Provider / 模型 / 思考强度**：${cardCode(current.modelProvider ?? "Codex 默认")} / ${cardCode(current.model ?? "默认")} / ${cardCode(current.reasoningEffort ?? "自动")}`,
+        `**Provider / 模型 / 思考强度**：${cardCode(current.modelProvider ?? "Agent 默认")} / ${cardCode(current.model ?? "默认")} / ${cardCode(current.reasoningEffort ?? "自动")}`,
         `**状态 / 最近结果**：${statusLabel} / ${resultLabel}`,
         `**Agent**：${cardCode(agent.title)}`,
         `**权限 / 任务范围**：${current.permissionMode === "confirm" ? "执行前确认" : "自动执行"} / ${detectProjectlessWorkspace(current.cwd) ? "未指定项目" : "指定项目"}`,
-        `**Codex 任务 ID**：${cardCode(current.remoteSessionId ?? "尚未创建")}`,
+        `**App Server 任务 ID**：${cardCode(current.remoteSessionId ?? "尚未创建")}`,
         `**当前执行 / 排队消息**：${activeTurnId ? cardCode(activeTurnId) : "无"} / ${queued} 条`,
         `**创建时间 / 最近活动**：${formatStatusTime(current.createdAt)} / ${formatStatusTime(current.updatedAt)}`,
       );
@@ -3178,8 +3318,8 @@ export class ProxySessionController {
       },
     ];
     const title = targetSessionId && current
-      ? `Codex 状态：${truncateText((current.title ?? current.remoteSessionId ?? current.localSessionId).replace(/\s+/g, " "), 40)}`
-      : "Codex 状态";
+      ? `Agent 状态：${truncateText((current.title ?? current.remoteSessionId ?? current.localSessionId).replace(/\s+/g, " "), 40)}`
+      : "Agent 状态";
     const taskId = current?.remoteSessionId
       ? remoteSessionReference(current.agentName, current.remoteSessionId)
       : current?.localSessionId;
@@ -3223,7 +3363,7 @@ export class ProxySessionController {
           `**工作目录**：${cardCode(remote.cwd || "目录未知")}`,
           `**状态 / 当前任务**：${remoteSessionDetailStatus(remote)} / 未切换`,
           `**Agent**：${cardCode(agentName)}`,
-          `**Codex 任务 ID**：${cardCode(remote.id)}`,
+          `**App Server 任务 ID**：${cardCode(remote.id)}`,
           `**最近回合**：${cardCode(remote.lastTurnId ?? "无")}　${remoteTurnStatusLabel(remote.lastTurnStatus)}`,
           `**创建时间 / 最近活动**：${formatRemoteTime(remote.createdAt)} / ${formatRemoteTime(latestRemoteTimestamp(remote.recencyAt, remote.updatedAt))}`,
         ],
@@ -3234,14 +3374,14 @@ export class ProxySessionController {
         lines: [
           `**当前 / 最后步骤**：${statusExcerpt(remote.lastActivity ?? remoteStatusStep(remote), 500)}`,
           isRemoteSessionActive(remote)
-            ? "外部 Codex 正在执行；Agent Bot 只读取状态，不会接管。"
+            ? "外部 Agent 正在执行；Agent Bot 只读取状态，不会接管。"
             : `发送 **/switch ${cardText(remote.id)}** 切换到此任务。`,
         ],
         collapsible: true,
         elementId: "status_execution_details",
       },
     ];
-    const title = `Codex 状态：${truncateText((remote.title ?? remote.preview ?? remote.id).replace(/\s+/g, " "), 40)}`;
+    const title = `Agent 状态：${truncateText((remote.title ?? remote.preview ?? remote.id).replace(/\s+/g, " "), 40)}`;
     const showStop = isRemoteSessionActive(remote)
       && options.forceSwitchTaskId !== actionReference
       && options.forceSwitchTaskId !== remote.id;
@@ -3320,9 +3460,13 @@ export class ProxySessionController {
     return agent;
   }
 
+  private agentLabel(agentName: string): string {
+    return this.ensureAgent(agentName).title;
+  }
+
   private isCodexSession(session: SessionRecord): boolean {
     if (session.runtimeKind) return session.runtimeKind === "codex";
-    return this.config.agents[session.agentName]?.kind === "codex";
+    return this.config.agents[session.agentName]?.kind === "app-server";
   }
 
   private currentSession(contextKey: string): SessionRecord | undefined {