@keyou007/agent-bot 0.1.11 → 0.1.12

package/src/cli.ts

@@ -7,6 +7,7 @@ import { sendControlRequest, isServerReachable } from "./cli/LocalControlClient.
 import {
   controlEndpoint,
   type ControlResponse,
+  type TaskGroupControlData,
   type TaskStatusControlData,
 } from "./cli/controlProtocol.js";
 import {
@@ -49,6 +50,10 @@ import {
   type ServerStartResult,
 } from "./cli/ServerStarter.js";
 import { taskChatRoute } from "./cli/taskChatRoute.js";
+import {
+  parseTaskForkGroupOptions,
+  parseTaskNewGroupOptions,
+} from "./cli/taskGroupOptions.js";
 import { StateStore, type SessionRecord } from "./state/StateStore.js";
 import {
   nodeDiagnosticReportArguments,
@@ -99,8 +104,8 @@ async function main(input: string[]): Promise<void> {
     return;
   }
   throw new Error(cliText(
-    `Unknown command: ${command}. Run agent-bot --help for usage.`,
-    `未知命令：${command}。运行 agent-bot --help 查看用法。`,
+    `Unknown command: ${command}. Run agentbot --help for usage.`,
+    `未知命令：${command}。运行 agentbot --help 查看用法。`,
   ));
 }
 
@@ -246,8 +251,8 @@ async function assertResetProfileServerStopped(configPath?: string): Promise<voi
     if (await isServerReachable(endpoint)) {
       throw new Error(
         cliText(
-          "Cannot reset a running profile. Stop it with agent-bot --profile <directory> server stop, then try again.",
-          "无法重置正在运行的 Profile。请先执行 agent-bot --profile <目录> server stop，然后重试。",
+          "Cannot reset a running profile. Stop it with agentbot --profile <directory> server stop, then try again.",
+          "无法重置正在运行的 Profile。请先执行 agentbot --profile <目录> server stop，然后重试。",
         ),
       );
     }
@@ -410,6 +415,51 @@ async function taskCommand(input: string[]): Promise<void> {
       process.stdout.write(cliText("Prompt submitted.\n", "提示词已提交。\n"));
       return;
     }
+    if (action === "newgroup") {
+      const options = parseTaskNewGroupOptions(rest);
+      const session = resolveTask(allSessions, options.reference);
+      const targetAgentName = options.agentName ?? session.agentName;
+      const targetAgent = config.agents[targetAgentName];
+      if (!targetAgent) {
+        throw new Error(cliText(
+          `Unknown Agent standard name: ${targetAgentName}.`,
+          `未知的 Agent 标准名：${targetAgentName}。`,
+        ));
+      }
+      if (options.projectless && targetAgent.kind !== "app-server") {
+        throw new Error(cliText(
+          "task newgroup --nodir is only available for App Server agents.",
+          "task newgroup --nodir 仅适用于 App Server Agent。",
+        ));
+      }
+      requireCliGroupUser(config.feishu.userOpenId);
+      const response = await sendControlRequest(controlEndpoint(config.storage.sqlitePath), {
+        action: "task_new_group",
+        localSessionId: session.localSessionId,
+        ...(options.title ? { title: options.title } : {}),
+        ...(options.cwd ? { cwd: options.cwd } : {}),
+        ...(options.agentName ? { agentName: options.agentName } : {}),
+        ...(options.projectless ? { projectless: true } : {}),
+      }, 120_000);
+      const result = taskGroupControlData(response);
+      if (options.json) printJson(result);
+      else printTaskGroupResult(result, "newgroup");
+      return;
+    }
+    if (action === "forkgroup") {
+      const options = parseTaskForkGroupOptions(rest);
+      const session = resolveTask(allSessions, options.reference);
+      requireCliGroupUser(config.feishu.userOpenId);
+      const response = await sendControlRequest(controlEndpoint(config.storage.sqlitePath), {
+        action: "task_fork_group",
+        localSessionId: session.localSessionId,
+        ...(options.title ? { title: options.title } : {}),
+      }, 120_000);
+      const result = taskGroupControlData(response);
+      if (options.json) printJson(result);
+      else printTaskGroupResult(result, "forkgroup");
+      return;
+    }
     const sessions = filterSessions(allSessions, rest);
     if (action === "list") {
       if (rest.includes("--json")) printJson(sessions);
@@ -840,6 +890,50 @@ function ensureOk(response: ControlResponse): void {
       ));
 }
 
+function requireCliGroupUser(userOpenId: string | undefined): asserts userOpenId is string {
+  if (userOpenId?.startsWith("ou_")) return;
+  throw new Error(cliText(
+    "The profile has no authorizing Lark user to invite. Run agentbot init again or configure FEISHU_USER_OPEN_ID.",
+    "当前 Profile 没有可邀请的飞书授权用户。请重新运行 agentbot init，或配置 FEISHU_USER_OPEN_ID。",
+  ));
+}
+
+function taskGroupControlData(response: ControlResponse): TaskGroupControlData {
+  ensureOk(response);
+  const data = response.data as Partial<TaskGroupControlData> | undefined;
+  if (
+    !data
+    || typeof data.sourceLocalSessionId !== "string"
+    || !data.group
+    || typeof data.group.chatId !== "string"
+    || typeof data.group.contextKey !== "string"
+    || typeof data.group.name !== "string"
+    || !data.task
+    || typeof data.task.localSessionId !== "string"
+  ) {
+    throw new Error(cliText(
+      "Agent Bot returned an invalid task-group result.",
+      "Agent Bot 返回了无效的任务群结果。",
+    ));
+  }
+  return data as TaskGroupControlData;
+}
+
+function printTaskGroupResult(
+  result: TaskGroupControlData,
+  action: "newgroup" | "forkgroup",
+): void {
+  process.stdout.write(cliText(
+    `${action === "forkgroup" ? "Fork group" : "Lark group"} created: ${result.group.name}\n`,
+    `${action === "forkgroup" ? "Fork 群" : "飞书群"}已创建：${result.group.name}\n`,
+  ));
+  process.stdout.write(`${cliText("Chat ID: ", "群 ID：")}${result.group.chatId}\n`);
+  process.stdout.write(`${cliText("Task ID: ", "任务 ID：")}${result.task.localSessionId}\n`);
+  if (result.task.remoteSessionId) {
+    process.stdout.write(`${cliText("Agent task ID: ", "Agent 任务 ID：")}${result.task.remoteSessionId}\n`);
+  }
+}
+
 function optionValue(args: string[], name: string): string | undefined {
   const index = args.indexOf(name);
   return index >= 0 ? args[index + 1] : undefined;

package/src/codex/CodexRuntime.ts

@@ -35,12 +35,13 @@ const WINDOWS_SCREENSHOT_DEVELOPER_INSTRUCTIONS = [
   "Call Graphics.CopyFromScreen with those physical coordinates and validate that the saved bitmap dimensions exactly equal the selected physical capture bounds.",
 ].join(" ");
 
-const SESSION_REQUEST_TIMEOUT_MS = 30_000;
+const SESSION_REQUEST_TIMEOUT_MS = 60_000;
 const CONTROL_REQUEST_TIMEOUT_MS = 10_000;
 const SYNC_REQUEST_TIMEOUT_MS = 5_000;
 // A timed-out fork keeps running in App Server and can create an orphan thread.
 // Wait for its response; connection closure still rejects the request.
 const FORK_REQUEST_TIMEOUT_MS = 0;
+type ThreadListSortKey = "recency_at" | "updated_at";
 
 export interface AppServerClient {
   request<T = unknown>(method: string, params?: unknown, timeoutMs?: number): Promise<T>;
@@ -84,6 +85,7 @@ export class CodexRuntime implements AgentRuntime {
   private readonly unsubscribeDisconnect?: () => void;
   private readonly sessionSyncs = new Map<string, Promise<RuntimeSession>>();
   private readonly localActivityDetector?: CodexLocalActivityDetector;
+  private threadListSortKey: ThreadListSortKey = "recency_at";
 
   constructor(
     private readonly provider: AppServerClientProvider,
@@ -215,18 +217,18 @@ export class CodexRuntime implements AgentRuntime {
     limit?: number;
   } = {}): Promise<RemoteSessionPage> {
     const client = await this.client();
-    const response = await client.request<ThreadListResponse>(
-      "thread/list",
-      {
-        cursor: input.cursor,
-        limit: input.limit ?? 20,
-        sortKey: "recency_at",
-        sortDirection: "desc",
-        archived: false,
-        searchTerm: input.searchTerm,
-      },
-      CONTROL_REQUEST_TIMEOUT_MS,
-    );
+    let response: ThreadListResponse;
+    try {
+      response = await this.requestThreadList(client, input, this.threadListSortKey);
+    } catch (error) {
+      if (this.threadListSortKey !== "recency_at" || !isUnsupportedRecencySortError(error)) throw error;
+      this.threadListSortKey = "updated_at";
+      this.logger.warn(
+        { error },
+        "App Server does not support thread/list recency_at sorting; retrying with updated_at.",
+      );
+      response = await this.requestThreadList(client, input, this.threadListSortKey);
+    }
     const sessions = await Promise.all(response.data.map(async (thread) => {
       const listed = remoteSessionSummary(thread);
       if (listed.status === "active" || listed.lastTurnStatus === "inProgress") return listed;
@@ -250,6 +252,25 @@ export class CodexRuntime implements AgentRuntime {
     };
   }
 
+  private requestThreadList(
+    client: AppServerClient,
+    input: { searchTerm?: string; cursor?: string; limit?: number },
+    sortKey: ThreadListSortKey,
+  ): Promise<ThreadListResponse> {
+    return client.request<ThreadListResponse>(
+      "thread/list",
+      {
+        cursor: input.cursor,
+        limit: input.limit ?? 20,
+        sortKey,
+        sortDirection: "desc",
+        archived: false,
+        searchTerm: input.searchTerm,
+      },
+      CONTROL_REQUEST_TIMEOUT_MS,
+    );
+  }
+
   async readRemoteSession(remoteSessionId: string): Promise<RemoteSessionSummary> {
     const response = await (await this.client()).request<ThreadReadResponse>(
       "thread/read",
@@ -1021,6 +1042,18 @@ function isUnsupportedExcludeTurnsError(error: unknown): boolean {
     || /unknown|unrecognized|unexpected|unsupported|not supported|experimental/i.test(details);
 }
 
+function isUnsupportedRecencySortError(error: unknown): boolean {
+  if (!(error instanceof AppServerRequestError) || error.method !== "thread/list") return false;
+  const data = typeof error.data === "string"
+    ? error.data
+    : error.data === undefined
+      ? ""
+      : JSON.stringify(error.data);
+  const details = `${error.serverMessage} ${data}`;
+  return /recency_at/i.test(details)
+    && /unknown|unrecognized|unexpected|unsupported|not supported|invalid/i.test(details);
+}
+
 function remoteSessionSummary(thread: CodexThreadSnapshot): RemoteSessionSummary {
   const lastTurn = thread.turns?.at(-1);
   const lastCompletedTurn = [...(thread.turns ?? [])]

package/src/config/loadConfig.ts

@@ -22,7 +22,7 @@ console:
 
 agents:
   codex:
-    kind: "codex"
+    kind: "app-server"
     title: "Codex"
     command: "codex"
     args:
@@ -33,6 +33,16 @@ agents:
       - "stdio://"
     env: {}
 
+  traex:
+    kind: "app-server"
+    title: "TraeX"
+    command: "traex"
+    args:
+      - "app-server"
+      - "--listen"
+      - "stdio://"
+    env: {}
+
   coco:
     title: "Coco"
     command: "coco"

package/src/config/schema.ts

@@ -3,8 +3,14 @@ import { DEFAULT_LOG_PATH, DEFAULT_SQLITE_PATH } from "./paths.js";
 
 const envRecordSchema = z.record(z.string(), z.string()).default({});
 
+const agentKindSchema = z.union([
+  z.literal("acp"),
+  z.literal("app-server"),
+  z.literal("codex").transform(() => "app-server" as const),
+]).default("acp");
+
 export const agentConfigSchema = z.object({
-  kind: z.enum(["acp", "codex"]).default("acp"),
+  kind: agentKindSchema,
   title: z.string().min(1),
   command: z.string().min(1),
   args: z.array(z.string()).default([]),

package/src/console/ConsoleConnector.ts

@@ -14,7 +14,7 @@ export class ConsoleConnector {
     if (this.reader) return;
     this.logger.info("Starting local Codex test console.");
     console.log("Codex console ready. Type /help or enter a prompt.");
-    const reader = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "agent-bot> " });
+    const reader = readline.createInterface({ input: process.stdin, output: process.stdout, prompt: "agentbot> " });
     this.reader = reader;
     reader.prompt();
     reader.on("line", (line) => {

package/src/console/ConsoleTurnPresenter.ts

@@ -4,27 +4,36 @@ import type { TurnPresenter } from "../presentation/OutboundRouter.js";
 
 export class ConsoleTurnPresenter implements TurnPresenter {
   private readonly contexts = new Map<string, string>();
+  private readonly agentLabels = new Map<string, string>();
   private readonly delivered = new Set<string>();
 
   constructor(private readonly outbound: FeishuOutbound) {}
 
-  registerSession(sessionId: string, contextKey: string): void {
+  registerSession(
+    sessionId: string,
+    contextKey: string,
+    _taskTitle?: string,
+    _projectCwd?: string,
+    agentLabel?: string,
+  ): void {
     this.contexts.set(sessionId, contextKey);
+    if (agentLabel) this.agentLabels.set(sessionId, agentLabel);
   }
 
   updateSessionTitle(): void {}
 
   unregisterSession(sessionId: string): void {
     this.contexts.delete(sessionId);
+    this.agentLabels.delete(sessionId);
   }
 
-  async startPendingTurn(_sessionId: string, contextKey: string): Promise<void> {
-    await this.outbound.sendText(contextKey, "Connecting to Codex...");
+  async startPendingTurn(sessionId: string, contextKey: string): Promise<void> {
+    await this.outbound.sendText(contextKey, `Connecting to ${this.agentLabel(sessionId)}...`);
   }
 
   async failPendingTurn(sessionId: string, message: string): Promise<void> {
     const contextKey = this.contexts.get(sessionId);
-    if (contextKey) await this.outbound.sendText(contextKey, `Codex failed to start: ${message}`);
+    if (contextKey) await this.outbound.sendText(contextKey, `${this.agentLabel(sessionId)} failed to start: ${message}`);
   }
 
   async appendSteerMessage(): Promise<void> {}
@@ -33,7 +42,7 @@ export class ConsoleTurnPresenter implements TurnPresenter {
     const contextKey = this.contexts.get(event.sessionId);
     if (!contextKey) return;
     if (event.type === "turn_started") {
-      await this.outbound.sendText(contextKey, `Codex started (${event.turnId})`);
+      await this.outbound.sendText(contextKey, `${this.agentLabel(event.sessionId)} started (${event.turnId})`);
     } else if (event.type === "progress") {
       await this.outbound.sendText(contextKey, event.text);
     } else if (event.type === "tool_started") {
@@ -44,9 +53,9 @@ export class ConsoleTurnPresenter implements TurnPresenter {
       this.delivered.add(event.turnId);
       await this.outbound.sendMarkdown(contextKey, event.finalResponse || "(completed without text)");
     } else if (event.type === "turn_failed") {
-      await this.outbound.sendText(contextKey, `Codex failed: ${event.message}`);
+      await this.outbound.sendText(contextKey, `${this.agentLabel(event.sessionId)} failed: ${event.message}`);
     } else if (event.type === "turn_cancelled") {
-      await this.outbound.sendText(contextKey, "Codex stopped.");
+      await this.outbound.sendText(contextKey, `${this.agentLabel(event.sessionId)} stopped.`);
     }
   }
 
@@ -61,4 +70,8 @@ export class ConsoleTurnPresenter implements TurnPresenter {
   async resumeDelivery(): Promise<void> {}
 
   async flushAll(): Promise<void> {}
+
+  private agentLabel(sessionId: string): string {
+    return this.agentLabels.get(sessionId) ?? "Agent";
+  }
 }

package/src/deprecated-cli.ts

@@ -0,0 +1,9 @@
+#!/usr/bin/env node
+import { cliText } from "./cli/i18n.js";
+
+process.stderr.write(`${cliText(
+  "Warning: `agent-bot` is deprecated and will be removed in a future release. Use `agentbot` instead.",
+  "警告：`agent-bot` 已弃用，并将在后续版本中移除。请改用 `agentbot`。",
+)}\n`);
+
+await import("./cli.js");

package/src/feishu/CardRenderer.ts

@@ -928,15 +928,16 @@ function renderTurnElements(
     const heading = state.status === "completed" ? "回答" : "回答生成中";
     elements.push(markdown(`**${heading}**\n${truncateText(state.assistantText, 3_000)}`));
   }
-  if (elements.length === 0) elements.push(markdown(emptyTurnText(state.status)));
+  if (elements.length === 0) elements.push(markdown(emptyTurnText(state.status, state.agentLabel)));
   return elements;
 }
 
-function emptyTurnText(status: TurnViewStatus): string {
-  if (status === "starting") return "正在连接 Codex…";
+function emptyTurnText(status: TurnViewStatus, agentLabel?: string): string {
+  const label = agentLabel?.trim().replace(/[\r\n]+/g, " ") || "Agent";
+  if (status === "starting") return `正在连接 ${label}…`;
   if (status === "completed") return "本轮已完成。";
   if (status === "cancelled") return "本轮已停止。";
-  return "正在等待 Codex 返回进度…";
+  return `正在等待 ${label} 返回进度…`;
 }
 
 function planPanel(plan: TurnViewState["plan"]): Record<string, unknown> {

package/src/feishu/FeishuTurnPresenter.ts

@@ -64,6 +64,7 @@ export class FeishuTurnPresenter {
   private readonly sessionContexts = new Map<string, string>();
   private readonly sessionTitles = new Map<string, string>();
   private readonly sessionCwds = new Map<string, string>();
+  private readonly sessionAgentLabels = new Map<string, string>();
   private readonly entries = new Map<string, TurnEntry>();
   private readonly pendingEntries = new Map<string, TurnEntry>();
   private readonly renderer: CardRenderer;
@@ -77,10 +78,17 @@ export class FeishuTurnPresenter {
     this.renderer = renderer ?? new CardRenderer();
   }
 
-  registerSession(sessionId: string, contextKey: string, taskTitle?: string, projectCwd?: string): void {
+  registerSession(
+    sessionId: string,
+    contextKey: string,
+    taskTitle?: string,
+    projectCwd?: string,
+    agentLabel?: string,
+  ): void {
     this.sessionContexts.set(sessionId, contextKey);
     if (taskTitle) this.sessionTitles.set(sessionId, taskTitle);
     if (projectCwd) this.sessionCwds.set(sessionId, projectCwd);
+    if (agentLabel) this.sessionAgentLabels.set(sessionId, agentLabel);
   }
 
   updateSessionTitle(sessionId: string, taskTitle: string): void {
@@ -97,6 +105,7 @@ export class FeishuTurnPresenter {
     this.sessionContexts.delete(sessionId);
     this.sessionTitles.delete(sessionId);
     this.sessionCwds.delete(sessionId);
+    this.sessionAgentLabels.delete(sessionId);
   }
 
   async startPendingTurn(
@@ -126,6 +135,7 @@ export class FeishuTurnPresenter {
       replyTarget,
       this.sessionCwds.get(sessionId),
       prompt,
+      this.sessionAgentLabels.get(sessionId),
     );
     const entry = { contextKey, state, initializing: Promise.resolve() } as TurnEntry;
     this.entries.set(state.turnId, entry);
@@ -179,6 +189,8 @@ export class FeishuTurnPresenter {
               this.sessionTitles.get(sessionId),
               undefined,
               this.sessionCwds.get(sessionId),
+              undefined,
+              this.sessionAgentLabels.get(sessionId),
             ),
             status: "running" as const,
           };
@@ -213,6 +225,7 @@ export class FeishuTurnPresenter {
             pending.state.replyTarget,
             pending.state.projectCwd,
             pending.state.prompt,
+            pending.state.agentLabel,
           ),
           event,
         );
@@ -347,6 +360,7 @@ export class FeishuTurnPresenter {
           undefined,
           this.sessionCwds.get(event.sessionId),
           undefined,
+          this.sessionAgentLabels.get(event.sessionId),
         );
     const state = reduceTurnEvent(
       initial,

package/src/feishu/transport.ts

@@ -8,7 +8,7 @@ type FeishuTransportConfig = Pick<
 export function requireServerFeishuTransport(config: FeishuTransportConfig): "sdk" {
   if (!config.appId || !config.appSecret) {
     throw new Error(
-      "The Lark bot is not configured. Run agent-bot init first, or use agent-bot console for local-only testing.",
+      "The Lark bot is not configured. Run agentbot init first, or use agentbot console for local-only testing.",
     );
   }
   return "sdk";

package/src/index.ts

@@ -30,6 +30,7 @@ import {
   prepareCrashReportDirectory,
   resolveSupervisorDiagnosticsPaths,
 } from "./supervision/SupervisorDiagnostics.js";
+import { refreshedSystemEnvironment } from "./supervision/systemEnvironment.js";
 
 const processStartedAt = new Date();
 const agentBotVersion = readPackageVersion();
@@ -69,7 +70,7 @@ if (feishuOutbound) {
     defaultAgentName,
     defaultAgentTitle: defaultAgent?.title ?? defaultAgentName,
     cwd: path.resolve(config.defaults.cwd),
-    workspaceKind: defaultAgent?.kind === "codex" ? "projectless" : "project",
+    workspaceKind: defaultAgent?.kind === "app-server" ? "projectless" : "project",
     defaultUserOpenId: config.feishu.userOpenId,
   }, metadataHydrator);
   safeRestartNotifier = new SafeRestartNotifier(store, feishuOutbound, renderer, logger);
@@ -210,6 +211,27 @@ async function handleControlRequest(request: ControlRequest): Promise<ControlRes
       return { ok: true, message: await controller.controlSetTaskTitle(request.localSessionId, request.title) };
     case "task_prompt":
       return { ok: true, message: await controller.controlSendTaskPrompt(request.localSessionId, request.text) };
+    case "task_new_group":
+      return {
+        ok: true,
+        data: await controller.controlCreateTaskGroup(
+          request.localSessionId,
+          request.title,
+          config.feishu.userOpenId,
+          request.cwd,
+          request.projectless === true,
+          request.agentName,
+        ),
+      };
+    case "task_fork_group":
+      return {
+        ok: true,
+        data: await controller.controlForkTaskGroup(
+          request.localSessionId,
+          request.title,
+          config.feishu.userOpenId,
+        ),
+      };
   }
 }
 
@@ -236,6 +258,15 @@ function startReplacementSupervisor(restartReason: string): void {
   const supervisorEntry = fileURLToPath(new URL("./supervisor.js", import.meta.url));
   const reportDirectory = resolveSupervisorDiagnosticsPaths(config).crashReportDirectory;
   prepareCrashReportDirectory(reportDirectory);
+  const environmentRefresh = refreshedSystemEnvironment();
+  if (environmentRefresh.error) {
+    logger.warn({ error: environmentRefresh.error }, "Failed to refresh the Windows environment for the replacement Supervisor.");
+  } else if (environmentRefresh.refreshed) {
+    logger.info(
+      { pathChanged: environmentRefresh.pathChanged },
+      "Refreshed the Windows environment for the replacement Supervisor.",
+    );
+  }
   const supervisor = spawn(process.execPath, [
     ...nodeDiagnosticReportArguments(reportDirectory),
     supervisorEntry,
@@ -244,7 +275,7 @@ function startReplacementSupervisor(restartReason: string): void {
     detached: true,
     windowsHide: true,
     stdio: "ignore",
-    env: replacementSupervisorEnvironment(restartReason),
+    env: replacementSupervisorEnvironment(restartReason, environmentRefresh.environment),
   });
   supervisor.unref();
 }

package/src/presentation/OutboundRouter.ts

@@ -8,7 +8,13 @@ import type {
 } from "../feishu/types.js";
 
 export interface TurnPresenter {
-  registerSession(sessionId: string, contextKey: string, taskTitle?: string, projectCwd?: string): void;
+  registerSession(
+    sessionId: string,
+    contextKey: string,
+    taskTitle?: string,
+    projectCwd?: string,
+    agentLabel?: string,
+  ): void;
   updateSessionTitle(sessionId: string, taskTitle: string): void;
   unregisterSession(sessionId: string): void;
   startPendingTurn(
@@ -48,11 +54,17 @@ export class OutboundRouter {
     if (routes.length === 0) throw new Error("At least one outbound route is required.");
   }
 
-  registerSession(sessionId: string, contextKey: string, taskTitle?: string, projectCwd?: string): void {
+  registerSession(
+    sessionId: string,
+    contextKey: string,
+    taskTitle?: string,
+    projectCwd?: string,
+    agentLabel?: string,
+  ): void {
     const route = this.route(contextKey);
     this.sessionRoutes.set(sessionId, route);
     this.sessionContextKeys.set(sessionId, contextKey);
-    route.presenter.registerSession(sessionId, contextKey, taskTitle, projectCwd);
+    route.presenter.registerSession(sessionId, contextKey, taskTitle, projectCwd, agentLabel);
   }
 
   getSessionContextKey(sessionId: string): string | undefined {

package/src/presentation/TurnStateReducer.ts

@@ -16,10 +16,12 @@ export function createTurnViewState(
   replyTarget?: MessageReplyTarget,
   projectCwd?: string,
   prompt?: string,
+  agentLabel?: string,
 ): TurnViewState {
   return {
     sessionId,
     turnId,
+    agentLabel,
     taskTitle,
     prompt,
     projectCwd,

package/src/presentation/turnViewTypes.ts

@@ -25,6 +25,7 @@ export type TurnActivity =
 export interface TurnViewState {
   sessionId: string;
   turnId: string;
+  agentLabel?: string;
   taskTitle?: string;
   prompt?: string;
   projectCwd?: string;