@keyou007/agent-bot 0.1.13-alpha.1 → 0.1.13-alpha.3

package/skills/agent-bot/SKILL.md

@@ -31,6 +31,19 @@ running_in_agent_bot = os.environ.get("AGENT_BOT") == "1"
 
 Treat this environment marker as authoritative. Do not infer Agent Bot execution merely because the CLI is installed, `~/.agent-bot` exists, or an Agent Bot process is running elsewhere. Configured agent environment variables cannot override the marker. Child processes normally inherit it, so the marker identifies the Agent Bot-started process tree unless a child explicitly replaces its environment.
 
+Agent Bot preserves ordinary parent-process variables but removes inherited and Agent-configured `FEISHU_*` and `AGENT_BOT_*` variables before starting an Agent. It then exposes only this controlled, non-secret context when values are available:
+
+```text
+AGENT_BOT_HOME
+AGENT_BOT_CONFIG
+AGENT_BOT_AGENT_NAME
+AGENT_BOT_LARK_APP_ID
+AGENT_BOT_LARK_BOT_OPEN_ID
+AGENT_BOT_LARK_USER_OPEN_ID
+```
+
+`AGENT_BOT_HOME` is the active Profile root. Never expect `FEISHU_APP_SECRET`, Supervisor state, restart reasons, or restart notification routes in the Agent environment.
+
 ## Behave safely inside Agent Bot
 
 When `AGENT_BOT=1`:
@@ -88,7 +101,7 @@ agentbot server status
 agentbot task list
 ```
 
-Agent Bot CLI interface text follows the system locale: locales beginning with `zh` use Chinese, while English and unsupported locales use English. JSON output is not localized. `agentbot server status` also reports the running profile's Lark App ID; with `--json`, read it from `feishuAppId`.
+Agent Bot CLI interface text follows the system locale: locales beginning with `zh` use Chinese, while English and unsupported locales use English. JSON output is not localized. `agentbot server status` reports the running profile's Lark App ID and each configured Agent process's PID and initialized version. With `--json`, read them from `feishuAppId` and `agents`; an Agent that has not started has `null` process fields.
 
 Add `--json` to status and list commands when machine-readable output helps. If `agentbot` is unavailable, report that the CLI is not installed or linked instead of guessing process state.
 
@@ -132,6 +145,7 @@ List tasks before resolving a numeric reference because task numbers follow the
 
 ```powershell
 agentbot task list
+agentbot task current [--json]
 agentbot task chat <number-or-task-id> [--json]
 agentbot task status <number-or-task-id>
 agentbot task stop <number-or-task-id>
@@ -143,52 +157,69 @@ agentbot task forkgroup <number-or-task-id> [title] [--json]
 
 Task IDs may be supplied in full or as an unambiguous prefix. Use `task stop` to ask the running worker to send the App Server Interrupt signal; leave child-process lifecycle management to the selected Agent.
 
+Read all task identity fields from `task list`: every entry shows its Agent and `AgentBot task ID`; App Server tasks also show `App Server thread ID`, while ACP tasks show `ACP session ID`. The status, title, conversation context, and update time remain visible. The CLI reads `CODEX_THREAD_ID` for Codex and `TRAECLI_THREAD_ID` for TraeX; when the available native Thread IDs identify one task, it marks that entry as `Current`. Use `task current` to print that task's details directly. Use any displayed full ID or an unambiguous prefix as a task reference. With `--json`, read the local and native values from `localSessionId`, `remoteSessionId`, and `acpSessionId`.
+
 Use `task chat <number-or-task-id>` to read the Feishu chat ID associated with a task from local routing state. Plain output is only the chat ID for scripting. Add `--json` to include the stable task ID, complete context key, and the thread ID for a topic-bound task. This read-only command does not require the Agent Bot server to be running.
 
 Use `task prompt` to send input to a specific task without changing any chat's current task. The bot first posts the Prompt text to the task's existing Feishu chat, thread, or private-chat route, then submits it to the task. If posting fails, the task is not started or steered. The thinking card and final response continue to the same route; the command line only reports whether the Prompt was accepted.
 
-### Create a task group from the CLI
+### Create or fork a group from the CLI
+
+Choose by whether the new task needs the source conversation:
 
-Use `task newgroup` to create a Lark group and bind a new task from outside Feishu. List tasks first and pass the intended source task explicitly; `<number-or-task-id>` defines the source context, so never substitute the shell's current working directory for the task's project directory.
+- Use **New Group** for a fresh task in a separate private Lark group. Inherit the project and execution settings, but do not carry over prior turns. Use it for a separate assignment in the same codebase or for a different project or Agent.
+- Use **Fork Group** to continue or parallelize work with the source task's conversation through a completed turn. Preserve that context in a separate private Lark group.
+
+Both operations create and bind the destination task immediately. Neither interrupts the source task nor changes the source chat's current task.
+
+When creating or forking from the task that is currently running this Skill, run `agentbot task current --json` first and pass its `localSessionId` as `<number-or-task-id>`. The command resolves Codex through `CODEX_THREAD_ID` and TraeX through `TRAECLI_THREAD_ID`, while preferring the only running match when another Agent's variable was inherited from a parent process. If the command cannot identify one task, ask for an explicit AgentBot task ID instead of guessing from list order, title, or project directory.
+
+List tasks first, identify the intended source explicitly, then run one of these commands:
 
 ```powershell
-# Inherit the source task's Agent, project, and execution settings.
+agentbot task list
+
+# Fresh task: inherit the source Agent, project, and execution settings.
 agentbot task newgroup <number-or-task-id> "Review"
 
-# Override the project directory. Prefer an absolute path or a ~-based path.
+# Fresh task: override the inherited project directory.
 agentbot task newgroup <number-or-task-id> "Review" --dir ~/dev/project
 
-# Create a fresh Projectless App Server task instead of inheriting a project.
+# Fresh task: use a Projectless App Server workspace.
 agentbot task newgroup <number-or-task-id> "Question" --nodir
 
-# Use another configured Agent with the inherited project shape.
+# Fresh task: use another configured Agent and that Agent's defaults.
 agentbot task newgroup <number-or-task-id> "Review" --agent traex
+
+# Context-preserving branch from the source task.
+agentbot task forkgroup <number-or-task-id> "Parallel review"
 ```
 
-Apply these rules:
+Apply these New Group rules:
 
-- With neither `--dir` nor `--nodir`, inherit the source task's project directory. If the source is Projectless, create a fresh Projectless workspace rather than reusing its generated directory.
-- `--dir <cwd>` overrides the inherited project and resolves `~`, `~/...`, and `~\...` from the user's home directory.
-- `--nodir` forces a Projectless task and is valid only for an App Server Agent. Reject combining it with `--dir`.
-- With no `--agent`, inherit the source task's Agent, Provider, model, reasoning effort, and permission mode. When `--agent <standard-name>` selects a different Agent, retain the chosen or inherited project shape but use that Agent runtime's own execution defaults.
-- The Server must be running. The Profile must contain `FEISHU_USER_OPEN_ID`; the Server invites that saved authorizing user because the CLI has no Lark operator identity.
-- Creating the group must not interrupt the source task or switch the source chat's current task. Add `--json` when the caller needs `group.chatId`, `group.contextKey`, or the created task IDs.
+- Treat `<number-or-task-id>` as the source context; never substitute the shell's current working directory for its project directory.
+- With neither `--dir` nor `--nodir`, inherit the source project. If it is Projectless, create a fresh Projectless workspace rather than reusing its generated directory.
+- Resolve `~`, `~/...`, and `~\...` in `--dir <cwd>` from the user's home directory. Reject combining `--dir` with `--nodir`.
+- Allow `--nodir` only for an App Server Agent.
+- With no `--agent`, inherit the source Agent, Provider, model, reasoning effort, and permission mode. With `--agent <standard-name>`, preserve the selected project shape but use the selected Agent's runtime defaults. `--agent` is a CLI-only New Group option.
 
-Use `task forkgroup` to Fork the selected task's latest available completed turn into a new group. It does not interrupt a newer active source turn and does not switch the source chat. Both group commands accept an optional title and `--json`; use the structured result to read the new `group.chatId`, `group.contextKey`, and task IDs.
+Apply these Fork Group rules:
 
-Use `/queue <prompt>` in Feishu to persist a separate follow-up Prompt instead of steering the active turn. Queued Prompts run in FIFO order after the current turn completes and survive Agent Bot restarts. `/nosteer <prompt>` is an equivalent compatibility spelling.
+- Fork the latest available completed turn and preserve its conversation context. Never include or interrupt a newer active turn. Reject the request when no completed turn is available.
+- Keep the source Agent, project, Provider, model, reasoning effort, and permission mode. Fork Group does not accept Agent or project overrides; use New Group when those must change.
+- Use the optional title as the destination task title and group suffix.
 
-For a long-running objective in the active Feishu task, use `/goal <objective>`. Use `/goal` to inspect it, `/goal pause` or `/goal resume` to control automatic continuation, `/goal edit <objective>` to revise it, and `/goal clear` to remove it. Stopping a Goal turn through Agent Bot also pauses the Goal before sending Interrupt so it does not immediately continue.
+Require a running Server for either CLI command. Require `FEISHU_USER_OPEN_ID` so the Server can invite the saved authorizing user; the CLI has no Lark operator identity of its own. Add `--json` when the caller needs `group.chatId`, `group.contextKey`, or the created task IDs.
 
-Use `/agent` in Feishu to open the unified execution-settings card on its Agent tab and `/agent <name>` to directly select the default agent. The Agent tab is present only when multiple agents are configured and remains usable before the chat has a current task. When only one Agent is configured, `/agent` reports that current Agent directly instead of sending a card. Agent selection affects future tasks and does not replace the Agent of an existing task; use `/new` after selecting when a new task is needed.
+Name a New Group without an explicit title as `[agent] [project directory] 新任务 (mm-dd)`, or `[agent] 新任务 (mm-dd)` when Projectless. Name an untitled Fork Group with the source task's persistent `source title（分支 N）` sequence, without a date suffix. Cap the displayed Lark group name at 60 characters by truncating only the group title portion; preserve the complete Agent Bot task title. Do not automatically send a Sessions or Status card to the destination group. Send a welcome message that reports Provider, model, reasoning effort, and permission mode.
 
-Use `/newgroup [title] [--dir <cwd> | --nodir]` in Feishu to create a private group named `[agent] [project directory] <title>`, invite the command sender, and immediately create and bind a new task in that group. `/new` and `/newgroup` share the same project options: an explicit `--dir` overrides the inherited project directory, while `--nodir` forces a Projectless App Server task; reject using both together. Resolve `~`, `~/...`, and `~\...` from the current user's home directory for both commands. Projectless groups omit the project segment and use `[agent] <title>`. The new task inherits the source chat's current task project directory when neither option is present, plus its model, reasoning effort, and permission mode without interrupting or switching the source task. When the source chat has no current task, use the selected agent and its runtime defaults. An explicit title becomes both the group suffix and the task title. When the title is omitted, use task title `新任务` and group name `[agent] [project directory] 新任务 (mm-dd)`, or `[agent] 新任务 (mm-dd)` for Projectless; an explicit title never gets a date suffix. Every new group gets a deterministic scheme-C Identicon avatar: Latin project names display their first word, Chinese names display up to their first four characters, and the normalized full project path hashes into the palette and symmetric node pattern. Projectless groups use the title as the stable seed. Replace the user's home-directory prefix with `~`. The bracketed project-directory value is limited to 15 characters. Longer paths keep the final two directories when they fit, otherwise keep the final directory, truncating the tail only when the final directory itself is overlong. Use `\` on Windows and `/` on macOS/Linux. Do not automatically send a Sessions or Status card to the new group. A later `/new --dir <cwd>` or `/new --nodir` in the group may explicitly replace the inherited project shape.
+Give every created group a deterministic scheme-C Identicon avatar. Display the first word for Latin project names or up to four characters for Chinese names, and hash the normalized full project path into the palette and symmetric node pattern. Use the title as the stable seed for Projectless groups. Replace the user's home prefix with `~` in the group-name project segment. Limit that segment to 15 characters, preferring the final two directories, then the final directory, and only then tail truncation. Use `\` on Windows and `/` on macOS/Linux.
 
-Provider is part of the same inherited execution-settings group as model, reasoning effort, and permission mode. Preserve all four across `/new`, `/newgroup`, `/fork`, `/forkgroup`, and the matching `/sessions` actions. New tasks with no inherited Provider must leave it unset so the selected App Server Agent uses its own default configuration. New-group welcome messages report all four settings.
+Use `/queue <prompt>` in Feishu to persist a separate follow-up Prompt instead of steering the active turn. Queued Prompts run in FIFO order after the current turn completes and survive Agent Bot restarts. `/nosteer <prompt>` is an equivalent compatibility spelling.
 
-Group names created by `/newgroup` and `/forkgroup` are capped at 60 displayed characters. When the generated name would exceed that limit, truncate only the title portion in the Feishu group name; preserve the underlying Agent Bot task title.
+For a long-running objective in the active Feishu task, use `/goal <objective>`. Use `/goal` to inspect it, `/goal pause` or `/goal resume` to control automatic continuation, `/goal edit <objective>` to revise it, and `/goal clear` to remove it. Stopping a Goal turn through Agent Bot also pauses the Goal before sending Interrupt so it does not immediately continue.
 
-Use `/forkgroup [title]` in Feishu to fork the current position into a newly created private group. In a Feishu thread, use the thread's original anchor turn when the thread has no bound task or its bound task has not completed a turn of its own. Once the bound thread task has completed a turn, use its latest locally persisted completed turn; exclude any newer active turn without interrupting it. Resolve this source before generic thread initialization so an unbound thread does not create an intermediate task. Outside a thread, fork the current App Server task's latest available completed turn. Agent Bot invites the command sender and binds the fork as the new group's current task, but does not automatically send a Sessions or Status card there. The new-group welcome message reports the forked task's model, reasoning effort, and permission type. An explicit title is used directly. Without an explicit title, both the forked task and group name use the same persistent `source title（分支 N）` sequence as `/fork`. `/forkgroup` does not add a date suffix.
+Use `/agent` in Feishu to open the unified execution-settings card on its Agent tab and `/agent <name>` to directly select the default agent. The Agent tab is present only when multiple agents are configured and remains usable before the chat has a current task. When only one Agent is configured, `/agent` reports that current Agent directly instead of sending a card. Agent selection affects future tasks and does not replace the Agent of an existing task; use `/new` after selecting when a new task is needed.
 
 Use `/new [title] --nodir` to force a new App Server Projectless task even when the current task belongs to a project. `--nodir` and `--dir <cwd>` are mutually exclusive; omitting both preserves the normal project-shape inheritance behavior.
 

package/src/acp/AcpProcessManager.ts

@@ -3,7 +3,10 @@ import readline from "node:readline";
 import type { Logger } from "pino";
 import type { AgentConfig } from "../config/schema.js";
 import { AcpJsonRpcConnection } from "./AcpJsonRpcConnection.js";
-import { agentBotEnvironment } from "../runtime/agentEnvironment.js";
+import {
+  agentBotEnvironment,
+  type AgentEnvironmentContext,
+} from "../runtime/agentEnvironment.js";
 import { spawnStdioCommand } from "../utils/spawnCommand.js";
 
 export interface ManagedAcpProcess {
@@ -16,14 +19,24 @@ export interface ManagedAcpProcess {
 export class AcpProcessManager {
   private readonly processes = new Map<string, ManagedAcpProcess>();
 
-  constructor(private readonly logger: Logger) {}
+  constructor(
+    private readonly logger: Logger,
+    private readonly environmentContext: () => AgentEnvironmentContext = () => ({}),
+  ) {}
 
   start(processKey: string, agentName: string, agent: AgentConfig): ManagedAcpProcess {
     if (this.processes.has(processKey)) {
       throw new Error(`ACP process already exists: ${processKey}`);
     }
 
-    const child = spawnStdioCommand(agent.command, agent.args, agentBotEnvironment(process.env, agent.env));
+    const child = spawnStdioCommand(
+      agent.command,
+      agent.args,
+      agentBotEnvironment(process.env, agent.env, {
+        ...this.environmentContext(),
+        agentName,
+      }),
+    );
 
     const childLogger = this.logger.child({ processKey, agentName });
     const connection = new AcpJsonRpcConnection(child, childLogger);

package/src/acp/AcpSessionManager.ts

@@ -40,6 +40,7 @@ export class AcpSessionManager {
   private readonly sessions = new Map<string, RuntimeSession>();
   private readonly sessionsByAcpId = new Map<string, RuntimeSession>();
   private processStart?: Promise<ManagedAcpProcess>;
+  private processVersion?: string;
 
   constructor(
     private readonly agentName: string,
@@ -52,6 +53,15 @@ export class AcpSessionManager {
     return this.sessions.get(localSessionId);
   }
 
+  getProcessInfo(): { pid?: number; version?: string } {
+    const pid = this.processManager.get(this.agentName)?.child.pid;
+    if (!pid) return {};
+    return {
+      pid,
+      ...(this.processVersion ? { version: this.processVersion } : {}),
+    };
+  }
+
   async create(input: CreateRuntimeSessionInput): Promise<RuntimeSession> {
     if (input.agentName !== this.agentName) throw new Error(`Unexpected agent: ${input.agentName}`);
 
@@ -133,6 +143,7 @@ export class AcpSessionManager {
     this.sessions.clear();
     this.sessionsByAcpId.clear();
     this.processStart = undefined;
+    this.processVersion = undefined;
     this.processManager.stopAll();
   }
 
@@ -181,6 +192,7 @@ export class AcpSessionManager {
   }
 
   private async startProcess(): Promise<ManagedAcpProcess> {
+    this.processVersion = undefined;
     const managed = this.processManager.start(this.agentName, this.agentName, this.agent);
     try {
       const connection = managed.connection;
@@ -210,6 +222,8 @@ export class AcpSessionManager {
           version: "0.1.0",
         },
       });
+      const version = initializeResult.agentInfo?.version?.trim();
+      if (version) this.processVersion = version;
       if (initializeResult.authMethods?.length) {
         const method = initializeResult.authMethods[0];
         this.logger.info({ methodId: method.id }, "Authenticating ACP agent with first advertised method.");

package/src/cli/InitializationWelcome.ts

@@ -0,0 +1,160 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import pino from "pino";
+import { loadConfig } from "../config/loadConfig.js";
+import type { AppConfig } from "../config/schema.js";
+import {
+  CardRenderer,
+  type InitializationWelcomeFeature,
+  type InitializationWelcomeKind,
+} from "../feishu/CardRenderer.js";
+import { FeishuMessageClient } from "../feishu/FeishuMessageClient.js";
+import type { CliLanguage } from "./i18n.js";
+
+export interface InitializationReceipt {
+  version: string;
+  initializedAt: string;
+}
+
+export type InitializationWelcomeResult =
+  | { status: "sent"; kind: InitializationWelcomeKind }
+  | { status: "skipped"; kind: InitializationWelcomeKind; reason: "feishu-skipped" | "missing-user-open-id" }
+  | { status: "failed"; kind: InitializationWelcomeKind; message: string };
+
+export interface SendInitializationWelcomeInput {
+  configPath?: string;
+  language: CliLanguage;
+  version: string;
+  previousVersion?: string;
+  kind: InitializationWelcomeKind;
+  activationPending?: boolean;
+}
+
+export interface InitializationWelcomeDependencies {
+  loadConfig(configPath?: string): AppConfig;
+  sendCard(config: AppConfig, contextKey: string, card: Record<string, unknown>): Promise<void>;
+  logoPath: string;
+}
+
+const INITIALIZATION_RECEIPT_FILE = "initialization.json";
+const DEFAULT_LOGO_PATH = fileURLToPath(new URL("../../assets/agent-bot-logo.png", import.meta.url));
+
+export function resolveInitializationWelcomeKind(input: {
+  firstInitialization: boolean;
+  previousVersion?: string;
+  currentVersion: string;
+}): InitializationWelcomeKind {
+  if (input.firstInitialization) return "first";
+  return input.previousVersion === input.currentVersion ? "refresh" : "upgrade";
+}
+
+export function readInitializationReceipt(homePath: string): InitializationReceipt | undefined {
+  try {
+    const value = JSON.parse(fs.readFileSync(initializationReceiptPath(homePath), "utf8")) as Partial<InitializationReceipt>;
+    if (typeof value.version !== "string" || !value.version.trim()) return undefined;
+    if (typeof value.initializedAt !== "string" || !value.initializedAt.trim()) return undefined;
+    return { version: value.version.trim(), initializedAt: value.initializedAt.trim() };
+  } catch {
+    return undefined;
+  }
+}
+
+export function writeInitializationReceipt(homePath: string, version: string, initializedAt = new Date()): void {
+  const filePath = initializationReceiptPath(homePath);
+  fs.mkdirSync(path.dirname(filePath), { recursive: true });
+  fs.writeFileSync(filePath, `${JSON.stringify({
+    version,
+    initializedAt: initializedAt.toISOString(),
+  }, null, 2)}\n`, { mode: 0o600 });
+}
+
+export async function sendInitializationWelcome(
+  input: SendInitializationWelcomeInput,
+  dependencies: InitializationWelcomeDependencies = defaultDependencies,
+): Promise<Exclude<InitializationWelcomeResult, { status: "failed" }>> {
+  const config = dependencies.loadConfig(input.configPath);
+  const userOpenId = config.feishu.userOpenId?.trim();
+  if (!userOpenId) {
+    return { status: "skipped", kind: input.kind, reason: "missing-user-open-id" };
+  }
+  const defaultAgentName = config.defaults.agent!;
+  const defaultAgent = config.agents[defaultAgentName]!;
+  const renderer = new CardRenderer();
+  const card = renderer.renderInitializationWelcome({
+    kind: input.kind,
+    language: input.language,
+    version: input.version,
+    previousVersion: input.previousVersion,
+    activationPending: input.activationPending,
+    defaultAgentName,
+    defaultAgentTitle: defaultAgent.title,
+    availableAgents: Object.values(config.agents).map((agent) => agent.title),
+    logoPath: dependencies.logoPath,
+    features: welcomeFeatures(input.kind, input.language),
+  });
+  await dependencies.sendCard(config, `open_id:${userOpenId}`, card);
+  return { status: "sent", kind: input.kind };
+}
+
+function initializationReceiptPath(homePath: string): string {
+  return path.join(homePath, "data", INITIALIZATION_RECEIPT_FILE);
+}
+
+function welcomeFeatures(
+  kind: InitializationWelcomeKind,
+  language: CliLanguage,
+): InitializationWelcomeFeature[] {
+  if (kind === "upgrade") {
+    return language === "zh"
+      ? [
+          { icon: "⚙️", title: "Agent 状态更透明", description: "Server 状态会显示每个 Agent 的 PID 与版本。" },
+          { icon: "🧭", title: "快速定位当前任务", description: "CLI 可识别正在调用它的 Codex 或 TraeX 任务。" },
+          { icon: "🗂️", title: "卡片操作更顺手", description: "Help 命令可点击，Sessions 翻页与操作更清晰。" },
+          { icon: "🛡️", title: "Crash 恢复更完整", description: "服务重启后会修复历史 Turn 的父子连接。" },
+        ]
+      : [
+          { icon: "⚙️", title: "Clearer Agent status", description: "Server status now shows each Agent's PID and version." },
+          { icon: "🧭", title: "Find the current task", description: "The CLI can identify its invoking Codex or TraeX task." },
+          { icon: "🗂️", title: "Better card actions", description: "Clickable Help commands and clearer Sessions pagination." },
+          { icon: "🛡️", title: "Stronger crash recovery", description: "Turn graph links are repaired after service recovery." },
+        ];
+  }
+  if (kind === "refresh") {
+    return language === "zh"
+      ? [
+          { icon: "💬", title: "随时开始对话", description: "私聊或群聊发送消息，即可继续当前任务。" },
+          { icon: "🧠", title: "统一运行设置", description: "在同一张卡片中切换 Agent、模型、思考和权限。" },
+          { icon: "🌿", title: "任务分支", description: "使用 New Group 或 Fork Group 并行处理工作。" },
+          { icon: "🔄", title: "安全恢复", description: "任务、进度与服务状态会持久保存并恢复。" },
+        ]
+      : [
+          { icon: "💬", title: "Start anywhere", description: "Continue work from a private chat or group conversation." },
+          { icon: "🧠", title: "Unified settings", description: "Switch Agent, model, thinking, and permissions in one card." },
+          { icon: "🌿", title: "Branch tasks", description: "Use New Group or Fork Group for parallel work." },
+          { icon: "🔄", title: "Safe recovery", description: "Tasks, progress, and service state persist across restarts." },
+        ];
+  }
+  return language === "zh"
+    ? [
+        { icon: "💬", title: "飞书直接对话", description: "私聊、群聊和话题分别维护自己的任务上下文。" },
+        { icon: "🤖", title: "连接本地 Agent", description: "目前支持 Codex、TraeX 和兼容的编程 Agent。" },
+        { icon: "🌿", title: "新建与分支", description: "把新任务或对话分支放进独立群聊并行推进。" },
+        { icon: "📍", title: "进度始终可见", description: "通过思考卡片查看工具调用、文件变更和最终结果。" },
+      ]
+    : [
+        { icon: "💬", title: "Work from Lark", description: "Private chats, groups, and topics keep separate task context." },
+        { icon: "🤖", title: "Connect local Agents", description: "Use Codex, TraeX, and compatible coding Agents." },
+        { icon: "🌿", title: "Create and branch", description: "Move fresh tasks or conversation branches into new groups." },
+        { icon: "📍", title: "See every step", description: "Follow tools, file changes, and final results in progress cards." },
+      ];
+}
+
+const defaultDependencies: InitializationWelcomeDependencies = {
+  loadConfig,
+  logoPath: DEFAULT_LOGO_PATH,
+  sendCard: async (config, contextKey, card) => {
+    const logger = pino({ level: "silent" });
+    await new FeishuMessageClient(config, logger).sendInteractiveCard(contextKey, card);
+  },
+};

package/src/cli/help.ts

@@ -13,10 +13,11 @@ export function renderCliHelp(version: string, language: CliLanguage = cliLangua
   init --reset                      重置并重新配置显式指定的 Profile
   console                           打开本地控制台
   server start                      在后台启动 Agent Bot
-  server status                     显示服务、飞书 App ID 和安全重启状态
+  server status                     显示服务、飞书 App ID、Agent 进程和安全重启状态
   server restart [--task <任务>]    安排安全重启并将状态发回指定任务会话
   server stop                       停止 Agent Bot
   task list                         列出任务
+  task current [--json]             显示当前调用任务的详情
   task status <任务>                显示任务状态
   task chat <任务>                  显示任务绑定的飞书会话
   task prompt <任务> <提示词>       向任务发送提示词
@@ -66,10 +67,11 @@ Common commands:
   init --reset                      Reset and reconfigure an explicit profile
   console                           Open the local console
   server start                      Start Agent Bot in the background
-  server status                     Show the server, Lark App ID, and safe-restart status
+  server status                     Show the server, Lark App ID, Agent processes, and safe-restart status
   server restart [--task <task>]    Schedule a safe restart and return status to the task's conversation
   server stop                       Stop Agent Bot
   task list                         List tasks
+  task current [--json]             Show details for the task invoking the CLI
   task status <task>                Show task status
   task chat <task>                  Show the task's Lark chat binding
   task prompt <task> <prompt>       Send a Prompt to a task

package/src/cli/serverStatus.ts

@@ -29,16 +29,44 @@ export function formatServerStatus(data: unknown, language: CliLanguage = cliLan
         language,
       )
     : cliText("not scheduled", "未计划", language);
+  const agents = formatAgentProcesses(value.agents, language);
   return [
     `${cliText("Agent Bot server: ", "Agent Bot 服务：", language)}${state}`,
     `${cliText("Lark App ID: ", "飞书 App ID：", language)}${value.feishuAppId ?? cliText("not configured", "未配置", language)}`,
     `${cliText("PID: ", "PID：", language)}${value.pid ?? "-"}`,
     `${cliText("Started at: ", "启动时间：", language)}${value.startedAt ?? "-"}`,
     `${cliText("Supervisor: ", "Supervisor：", language)}${value.supervised ? cliText("enabled", "已启用", language) : cliText("disabled", "未启用", language)}`,
+    ...agents,
     `${cliText("Running tasks: ", "运行中任务：", language)}${activity.runningSessions ?? 0}`,
     `${cliText("Pending final deliveries: ", "待发送最终结果：", language)}${activity.pendingFinalDeliveries ?? 0}`,
     `${cliText("Safe restart: ", "安全重启：", language)}${safeRestart}`,
     "",
   ].join("\n");
 }
+
+function formatAgentProcesses(value: unknown, language: CliLanguage): string[] {
+  const agents = Array.isArray(value)
+    ? value.filter((item): item is Record<string, unknown> => Boolean(item) && typeof item === "object")
+    : [];
+  if (agents.length === 0) {
+    return [`${cliText("Agents: ", "Agent 进程：", language)}-`];
+  }
+  return [
+    cliText("Agents:", "Agent 进程：", language),
+    ...agents.map((agent) => {
+      const name = typeof agent.name === "string" && agent.name.trim() ? agent.name.trim() : "-";
+      const title = typeof agent.title === "string" && agent.title.trim() ? agent.title.trim() : undefined;
+      const label = title && title !== name ? `${name} (${title})` : name;
+      const pid = typeof agent.pid === "number" && Number.isInteger(agent.pid) && agent.pid > 0
+        ? String(agent.pid)
+        : "-";
+      const version = typeof agent.version === "string" && agent.version.trim()
+        ? agent.version.trim()
+        : "-";
+      return language === "zh"
+        ? `  ${label}：PID ${pid}，版本 ${version}`
+        : `  ${label}: PID ${pid}, version ${version}`;
+    }),
+  ];
+}
 import { cliLanguage, cliText, type CliLanguage } from "./i18n.js";

package/src/cli/taskListOutput.ts

@@ -0,0 +1,91 @@
+import type { SessionRecord } from "../state/StateStore.js";
+import { cliLanguage, cliText, type CliLanguage } from "./i18n.js";
+
+export type CurrentTaskResolution =
+  | { status: "found"; session: SessionRecord }
+  | { status: "missing-thread-id" }
+  | { status: "not-found"; threadIds: string[] }
+  | { status: "ambiguous"; sessions: SessionRecord[]; threadIds: string[] };
+
+export function formatTaskList(
+  sessions: SessionRecord[],
+  language: CliLanguage = cliLanguage,
+  currentThreadIds: readonly string[] = [],
+): string {
+  if (sessions.length === 0) return cliText("No tasks.\n", "没有任务。\n", language);
+
+  const current = resolveCurrentTask(sessions, currentThreadIds);
+  const currentLocalSessionId = current.status === "found" ? current.session.localSessionId : undefined;
+  return sessions.map((session, index) => {
+    const title = session.title ?? cliText("Untitled task", "未命名任务", language);
+    const current = session.localSessionId === currentLocalSessionId
+      ? ` [${cliText("Current", "当前任务", language)}]`
+      : "";
+    const nativeId = nativeTaskIdLabel(session, language);
+    return [
+      `${index + 1}.${current} [${taskStateLabel(session.status, language)}/${taskStateLabel(session.lastTurnStatus, language)}] ${title}`,
+      `   ${cliText("Agent: ", "Agent：", language)}${session.agentName} · ${cliText("AgentBot task ID: ", "AgentBot 任务 ID：", language)}${session.localSessionId}`,
+      `   ${nativeId ? `${nativeId} · ` : ""}${session.contextKey} · ${session.updatedAt}`,
+    ].join("\n");
+  }).join("\n") + "\n";
+}
+
+export function currentAppServerThreadIds(env: NodeJS.ProcessEnv): string[] {
+  return [...new Set([
+    env.CODEX_THREAD_ID?.trim(),
+    env.TRAECLI_THREAD_ID?.trim(),
+  ].filter((value): value is string => Boolean(value)))];
+}
+
+export function resolveCurrentTask(
+  sessions: SessionRecord[],
+  currentThreadIds: readonly string[],
+): CurrentTaskResolution {
+  const threadIds = [...new Set(currentThreadIds.map((value) => value.trim()).filter(Boolean))];
+  if (threadIds.length === 0) return { status: "missing-thread-id" };
+
+  const candidates = new Set(threadIds);
+  const matches = sessions.filter((session) => session.remoteSessionId && candidates.has(session.remoteSessionId));
+  if (matches.length === 0) return { status: "not-found", threadIds };
+  if (matches.length === 1) return { status: "found", session: matches[0]! };
+
+  const running = matches.filter((session) =>
+    session.status === "running" || session.lastTurnStatus === "running");
+  if (running.length === 1) return { status: "found", session: running[0]! };
+  return { status: "ambiguous", sessions: matches, threadIds };
+}
+
+export function taskStateLabel(
+  status: string | undefined,
+  language: CliLanguage = cliLanguage,
+): string {
+  if (!status) return "-";
+  const chinese: Record<string, string> = {
+    starting: "启动中",
+    ready: "就绪",
+    running: "运行中",
+    closed: "已关闭",
+    failed: "失败",
+    completed: "已完成",
+    cancelled: "已取消",
+    interrupted: "已中断",
+    inProgress: "进行中",
+    active: "活动中",
+    idle: "空闲",
+    not_loaded: "未加载",
+    error: "错误",
+  };
+  return language === "zh" ? chinese[status] ?? status : status;
+}
+
+function nativeTaskIdLabel(session: SessionRecord, language: CliLanguage): string | undefined {
+  if (session.runtimeKind === "acp" || session.acpSessionId) {
+    const sessionId = session.acpSessionId ?? session.remoteSessionId;
+    return sessionId
+      ? `${cliText("ACP session ID: ", "ACP Session ID：", language)}${sessionId}`
+      : undefined;
+  }
+  return session.remoteSessionId
+    ? `${cliText("App Server thread ID: ", "App Server 原生任务 ID（Thread ID）：", language)}${session.remoteSessionId}`
+    : undefined;
+}