@keyou007/agent-bot 0.1.15-alpha.4 → 0.1.15-alpha.6

package/src/proxy/ProxySessionController.ts

@@ -5,7 +5,7 @@ import path from "node:path";
 import type { Logger } from "pino";
 import { createProjectlessWorkspace, detectProjectlessWorkspace } from "../codex/ProjectlessWorkspace.js";
 import { resolveUserPath } from "../config/paths.js";
-import type { AppConfig } from "../config/schema.js";
+import { DEFAULT_GROUP_NAME_FORMAT, type AppConfig } from "../config/schema.js";
 import { CommandRouter } from "../commands/CommandRouter.js";
 import type { Command } from "../commands/commandTypes.js";
 import { baseChatContextKey, isThreadContextKey } from "../feishu/contextKey.js";
@@ -30,6 +30,11 @@ import {
 } from "../feishu/CardRenderer.js";
 import { CardUpdateScheduler } from "../feishu/CardUpdateScheduler.js";
 import { generateGroupAvatarPng, resolveGroupAvatarProjectName } from "../feishu/GroupAvatarGenerator.js";
+import {
+  formatGroupNameDate,
+  formatNewGroupName,
+  parseTaskNameFromGroupName,
+} from "../feishu/GroupNameFormatter.js";
 import { normalizeFeishuPostText } from "../feishu/InboundText.js";
 import { allowsFeishuUser } from "../feishu/ownerAccess.js";
 import type { OutboundRouter } from "../presentation/OutboundRouter.js";
@@ -47,6 +52,12 @@ import type {
   RuntimePrompt,
   RuntimeSession,
 } from "../runtime/types.js";
+import {
+  isActiveShellCommandJob,
+  ShellCommandJobManager,
+  type ShellCommandJobManagerLike,
+  type ShellCommandJobSnapshot,
+} from "../shell/ShellCommandJobManager.js";
 import {
   StateStore,
   type CardActionBinding,
@@ -63,7 +74,6 @@ import { normalizeTaskTitle } from "../utils/taskTitle.js";
 import {
   executeShellCommand,
   type ShellCommandOptions,
-  type ShellCommandOutputSnapshot,
   type ShellCommandResult,
 } from "../utils/executeShellCommand.js";
 
@@ -94,6 +104,12 @@ interface ForwardAttachmentReservation {
   registry: Map<string, PendingForwardAttachment>;
 }
 
+interface ShellCommandJobMonitor {
+  scheduler: CardUpdateScheduler<ShellCommandCardView>;
+  timer: NodeJS.Timeout;
+  refreshing: boolean;
+}
+
 const MESSAGE_RECEIVED_REACTION = "OnIt";
 const MESSAGE_COMPLETED_REACTION = "DONE";
 const MESSAGE_FAILED_REACTION = "ERROR";
@@ -105,7 +121,8 @@ const RESET_HISTORY_PAGE_SIZE = 10;
 const MAX_LLM_TURN_RETRIES = 3;
 const RECOVERY_ACTIVITY_WINDOW_MS = 5 * 60 * 1_000;
 const RECOVERY_HEARTBEAT_INTERVAL_MS = 60 * 1_000;
-const SHELL_COMMAND_ELAPSED_UPDATE_INTERVAL_MS = 3_000;
+const SHELL_COMMAND_JOB_POLL_INTERVAL_MS = 1_000;
+const SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS = 5_000;
 const FORWARD_ATTACHMENT_WINDOW_MS = 800;
 const DEFAULT_MERGED_FORWARD_INSTRUCTION = "请参考以下内容回复用户";
 const DEFAULT_REFERENCED_MESSAGE_INSTRUCTION = "请参考引用消息回复用户";
@@ -150,6 +167,12 @@ const HELP_COMMAND_SECTIONS: Array<{
         usage: "[目录]",
         description: "浏览、发送文件，并从选定目录创建任务或群",
       },
+      {
+        command: "/file",
+        usage: "&#60;文件路径&#62;",
+        description: "将指定文件发送到当前飞书会话",
+        requiresArgument: true,
+      },
       {
         command: "/forkgroup",
         usage: "[title]",
@@ -404,6 +427,7 @@ export class ProxySessionController {
   private readonly pendingMergedForwards = new Map<string, PendingForwardAttachment>();
   private readonly pendingResourceForwards = new Map<string, PendingForwardAttachment>();
   private readonly relatedReactionMessageIds = new Map<string, string[]>();
+  private readonly shellCommandJobMonitors = new Map<string, ShellCommandJobMonitor>();
   private readonly unsubscribe: Array<() => void> = [];
   private readonly recoveryActivityHeartbeat: NodeJS.Timeout;
   private startupRecovery?: Promise<void>;
@@ -418,6 +442,9 @@ export class ProxySessionController {
     private readonly lifecycle?: ProxyLifecycle,
     private readonly shellCommandExecutor: ShellCommandExecutor = executeShellCommand,
     private readonly windowsDriveLister: WindowsDriveLister = listWindowsDriveRoots,
+    private readonly shellCommandJobs: ShellCommandJobManagerLike = new ShellCommandJobManager(
+      path.join(path.dirname(config.storage.sqlitePath), "command-jobs"),
+    ),
   ) {
     for (const [, runtime] of this.runtimes.entries()) {
       this.unsubscribe.push(
@@ -708,7 +735,9 @@ export class ProxySessionController {
             message.userId,
             message,
           );
-          if (!isPromptCommand(command)) await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+          if (!commandDefersReactionFinalization(command)) {
+            await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+          }
         } catch (error) {
           await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
           await this.sendError(message.contextKey, error);
@@ -731,7 +760,9 @@ export class ProxySessionController {
             message.userId,
             message,
           );
-          if (!isPromptCommand(command)) await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+          if (!commandDefersReactionFinalization(command)) {
+            await this.finalizeStandaloneMessageReaction(message.messageId, "completed");
+          }
         } catch (error) {
           await this.finalizeStandaloneMessageReaction(message.messageId, "failed");
           await this.sendError(message.contextKey, error);
@@ -786,6 +817,11 @@ export class ProxySessionController {
         } else if (kind === "turn_cancel") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.cancelSession(this.requireSession(contextKey, sessionId));
+        } else if (kind === "shell_command_cancel") {
+          await this.cancelShellCommandJob(
+            contextKey,
+            String(scopedAction.value.jobId ?? ""),
+          );
         } else if (kind === "turn_reset") {
           const sessionId = String(scopedAction.value.sessionId ?? "");
           await this.resetCurrentSessionToTurn(
@@ -1057,6 +1093,7 @@ export class ProxySessionController {
     this.relatedReactionMessageIds.clear();
     for (const timer of this.recoveryRetryTimers.values()) clearTimeout(timer);
     this.recoveryRetryTimers.clear();
+    for (const [jobId] of this.shellCommandJobMonitors) this.stopShellCommandJobMonitor(jobId);
     clearInterval(this.recoveryActivityHeartbeat);
   }
 
@@ -1700,11 +1737,14 @@ export class ProxySessionController {
     }
     switch (command.type) {
       case "shell":
-        await this.runShellCommand(contextKey, command.command);
+        await this.runShellCommand(contextKey, command.command, messageId);
         return;
       case "dir":
         await this.openDirectoryBrowser(contextKey, command.directory);
         return;
+      case "file":
+        await this.sendCurrentTaskFile(contextKey, command.filePath);
+        return;
       case "new":
         if (command.projectless && this.ensureAgent(context.defaultAgent).kind !== "app-server") {
           throw new Error("/new --nodir 仅支持 App Server Agent。");
@@ -1872,6 +1912,7 @@ export class ProxySessionController {
   }
 
   private async runStartupRecovery(): Promise<void> {
+    await this.recoverShellCommandJobs();
     this.backfillTurnAttemptsForUpgrade();
     const attempts = this.store.listIncompleteTurnAttempts();
     const recoveryCutoff = Date.now() - RECOVERY_ACTIVITY_WINDOW_MS;
@@ -3186,7 +3227,10 @@ export class ProxySessionController {
     executionSettings: SessionExecutionSettings,
   ): Promise<CreatedFeishuTaskGroup> {
     const explicitTitle = normalizeTaskTitle(requestedTitle);
-    const taskTitle = explicitTitle ?? `新任务 (${formatGroupDateSuffix(new Date())})`;
+    const taskTitle = explicitTitle ?? `新任务 (${formatGroupNameDate(
+      new Date(),
+      this.config.feishu?.groupNameFormat?.dateFormat ?? DEFAULT_GROUP_NAME_FORMAT.dateFormat,
+    )})`;
     const group = await this.createFeishuGroupContext(
       sourceContextKey,
       agentName,
@@ -3194,7 +3238,6 @@ export class ProxySessionController {
       userId,
       boundProjectCwd,
       "/newgroup",
-      false,
     );
 
     let task: SessionRecord;
@@ -3295,7 +3338,6 @@ export class ProxySessionController {
       userId,
       boundProjectCwd,
       "/forkgroup",
-      false,
     );
 
     let forked: ForkSessionResult;
@@ -3338,12 +3380,17 @@ export class ProxySessionController {
     userId: string | undefined,
     boundProjectCwd: string | undefined,
     commandName: "/newgroup" | "/forkgroup",
-    includeTimestamp: boolean,
   ): Promise<CreatedFeishuGroupContext> {
     if (!userId?.startsWith("ou_")) {
       throw new Error(`${commandName} 只能由具有 open_id 的飞书用户消息触发。`);
     }
-    const groupName = formatNewGroupName(agentName, boundProjectCwd, taskTitle, new Date(), includeTimestamp);
+    const groupName = formatNewGroupName({
+      agentName,
+      projectCwd: boundProjectCwd,
+      taskName: taskTitle,
+      date: new Date(),
+      format: this.config.feishu?.groupNameFormat,
+    });
     const group = await this.outbound.createGroup(sourceContextKey, {
       name: groupName,
       userOpenId: userId,
@@ -4510,106 +4557,155 @@ export class ProxySessionController {
     }
   }
 
-  private async runShellCommand(contextKey: string, command: string): Promise<void> {
+  private async runShellCommand(
+    contextKey: string,
+    command: string,
+    sourceMessageId?: string,
+  ): Promise<void> {
     const cwd = this.currentSession(contextKey)?.cwd ?? this.config.defaults.cwd;
-    const startedAt = Date.now();
-    let latestOutput: ShellCommandOutputSnapshot = {
-      stdout: "",
-      stderr: "",
-      outputTruncated: false,
-    };
-    let runningState: ShellCommandCardView = {
+    const created = await this.shellCommandJobs.createJob({ contextKey, sourceMessageId, command, cwd });
+    let cardMessageId: string | undefined;
+    const initialState: ShellCommandCardView = {
+      jobId: created.id,
+      contextKey,
       command,
       cwd,
-      ...latestOutput,
+      output: "",
+      outputTruncated: false,
       status: "running",
       elapsedMs: 0,
     };
-    const cardMessageId = await this.outbound.sendInteractiveCard(
-      contextKey,
-      this.cardRenderer.renderShellCommandCard(runningState),
-    );
-    const scheduler = cardMessageId
-      ? new CardUpdateScheduler<ShellCommandCardView>({
-          render: (state) => this.cardRenderer.renderShellCommandCard(state),
-          write: (card) => this.outbound.updateInteractiveCard(contextKey, cardMessageId, card),
-          onError: (error) => this.logger.warn(
-            { error, contextKey, messageId: cardMessageId },
-            "Failed to update a shell command card.",
-          ),
-        })
-      : undefined;
-    scheduler?.seed(runningState);
-    const elapsedTimer = scheduler ? setInterval(() => {
-      runningState = { ...runningState, elapsedMs: Date.now() - startedAt };
-      scheduler.update(runningState);
-    }, SHELL_COMMAND_ELAPSED_UPDATE_INTERVAL_MS) : undefined;
-    elapsedTimer?.unref?.();
-
-    const updateRunningOutput = (snapshot: ShellCommandOutputSnapshot): void => {
-      latestOutput = snapshot;
-      runningState = {
-        ...runningState,
-        ...snapshot,
-        elapsedMs: Date.now() - startedAt,
-      };
-      scheduler?.update(runningState);
-    };
-
-    let result: ShellCommandResult;
     try {
-      result = await this.shellCommandExecutor(command, cwd, { onOutput: updateRunningOutput });
+      cardMessageId = await this.outbound.sendInteractiveCard(
+        contextKey,
+        this.cardRenderer.renderShellCommandCard(initialState),
+      );
+      if (!cardMessageId) throw new Error("Failed to create the shell command card.");
+      const bound = await this.shellCommandJobs.bindCard(created.id, cardMessageId);
+      await this.shellCommandJobs.startJob(created.id);
+      this.monitorShellCommandJob(bound, initialState);
     } catch (error) {
-      if (elapsedTimer) clearInterval(elapsedTimer);
-      const failedCard = this.cardRenderer.renderShellCommandCard({
-        command,
-        cwd,
-        ...latestOutput,
-        stderr: [latestOutput.stderr.trimEnd(), runtimeErrorMessage(error)].filter(Boolean).join("\n"),
-        status: "failed",
-        elapsedMs: Date.now() - startedAt,
-      });
-      if (scheduler) {
+      await this.shellCommandJobs.failJob(created.id, runtimeErrorMessage(error)).catch(() => undefined);
+      if (cardMessageId) {
         try {
-          await scheduler.flush({
-            ...runningState,
-            stderr: [latestOutput.stderr.trimEnd(), runtimeErrorMessage(error)].filter(Boolean).join("\n"),
-            status: "failed",
-            elapsedMs: Date.now() - startedAt,
-          });
+          const failed = await this.shellCommandJobs.readJob(created.id);
+          await this.outbound.updateInteractiveCard(
+            contextKey,
+            cardMessageId,
+            this.cardRenderer.renderShellCommandCard(shellCommandJobCardView(failed)),
+          );
+          await this.shellCommandJobs.markPresented(created.id);
         } catch (cardError) {
           this.logger.warn(
-            { error: cardError, contextKey, messageId: cardMessageId },
-            "Failed to finalize a shell command card.",
+            { error: cardError, jobId: created.id, contextKey, messageId: cardMessageId },
+            "Failed to finalize a shell command card after the runner failed to start.",
           );
-        } finally {
-          scheduler.dispose();
         }
       } else {
-        await this.outbound.sendInteractiveCard(contextKey, failedCard);
+        await this.shellCommandJobs.markPresented(created.id).catch(() => undefined);
       }
       throw error;
     }
+  }
 
-    if (elapsedTimer) clearInterval(elapsedTimer);
-    const finalState: ShellCommandCardView = {
-      command,
-      cwd,
-      stdout: result.stdout,
-      stderr: result.stderr,
-      status: result.timedOut ? "timed_out" : result.exitCode === 0 ? "completed" : "failed",
-      exitCode: result.exitCode,
-      elapsedMs: Date.now() - startedAt,
-      outputTruncated: result.outputTruncated,
+  private monitorShellCommandJob(
+    job: ShellCommandJobSnapshot,
+    seededState?: ShellCommandCardView,
+  ): void {
+    if (!job.cardMessageId || this.shellCommandJobMonitors.has(job.id)) return;
+    const scheduler = new CardUpdateScheduler<ShellCommandCardView>({
+      render: (state) => this.cardRenderer.renderShellCommandCard(state),
+      write: (card) => this.outbound.updateInteractiveCard(job.contextKey, job.cardMessageId!, card),
+      onError: (error) => this.logger.warn(
+        { error, jobId: job.id, contextKey: job.contextKey, messageId: job.cardMessageId },
+        "Failed to update a background shell command card.",
+      ),
+    });
+    if (seededState) scheduler.seed(seededState);
+    const monitor: ShellCommandJobMonitor = {
+      scheduler,
+      refreshing: false,
+      timer: setInterval(() => {
+        void this.refreshShellCommandJob(job.id);
+      }, SHELL_COMMAND_JOB_POLL_INTERVAL_MS),
     };
-    if (scheduler) {
-      try {
-        await scheduler.flush(finalState);
-      } finally {
-        scheduler.dispose();
+    monitor.timer.unref?.();
+    this.shellCommandJobMonitors.set(job.id, monitor);
+    void this.refreshShellCommandJob(job.id, seededState === undefined);
+  }
+
+  private async refreshShellCommandJob(jobId: string, critical = false): Promise<void> {
+    const monitor = this.shellCommandJobMonitors.get(jobId);
+    if (!monitor || monitor.refreshing) return;
+    monitor.refreshing = true;
+    try {
+      const job = await this.shellCommandJobs.readJob(jobId);
+      const view = shellCommandJobCardView(job);
+      if (isActiveShellCommandJob(job.status)) {
+        monitor.scheduler.update(view, critical ? "critical" : "normal");
+        return;
       }
-    } else {
-      await this.outbound.sendInteractiveCard(contextKey, this.cardRenderer.renderShellCommandCard(finalState));
+      await monitor.scheduler.flush(view);
+      if (job.sourceMessageId) {
+        await this.finalizeStandaloneMessageReaction(
+          job.sourceMessageId,
+          job.status === "completed" ? "completed" : job.status === "cancelled" ? "cancelled" : "failed",
+        );
+      }
+      await this.shellCommandJobs.markPresented(jobId);
+      this.stopShellCommandJobMonitor(jobId);
+    } catch (error) {
+      this.logger.warn({ error, jobId }, "Failed to refresh a background shell command job.");
+    } finally {
+      const current = this.shellCommandJobMonitors.get(jobId);
+      if (current) current.refreshing = false;
+    }
+  }
+
+  private stopShellCommandJobMonitor(jobId: string): void {
+    const monitor = this.shellCommandJobMonitors.get(jobId);
+    if (!monitor) return;
+    clearInterval(monitor.timer);
+    monitor.scheduler.dispose();
+    this.shellCommandJobMonitors.delete(jobId);
+  }
+
+  private async cancelShellCommandJob(contextKey: string, jobId: string): Promise<void> {
+    if (!jobId) throw new Error("命令任务无效，请使用最新的命令卡片。");
+    const job = await this.shellCommandJobs.readJob(jobId);
+    if (job.contextKey !== contextKey) throw new Error("该命令不属于当前会话。");
+    const requested = await this.shellCommandJobs.requestCancellation(jobId);
+    if (!requested) {
+      await this.outbound.sendText(contextKey, "该命令已经结束。");
+      return;
+    }
+    if (!this.shellCommandJobMonitors.has(jobId)) this.monitorShellCommandJob(job);
+    await this.refreshShellCommandJob(jobId, true);
+  }
+
+  private async recoverShellCommandJobs(): Promise<void> {
+    const jobs = await this.shellCommandJobs.listRecoverableJobs();
+    if (jobs.length > 0) {
+      this.logger.warn(
+        { jobIds: jobs.map((job) => job.id) },
+        "Recovering background shell command jobs after startup.",
+      );
+    }
+    for (const job of jobs) {
+      if (!job.cardMessageId || !this.outbound.canRoute(job.contextKey)) continue;
+      if (
+        job.status === "starting"
+        && job.runnerPid === undefined
+        && Date.now() - job.updatedAt >= SHELL_COMMAND_JOB_RELAUNCH_DELAY_MS
+      ) {
+        try {
+          await this.shellCommandJobs.startJob(job.id);
+        } catch (error) {
+          await this.shellCommandJobs.failJob(job.id, runtimeErrorMessage(error)).catch(() => undefined);
+        }
+      }
+      const refreshed = await this.shellCommandJobs.readJob(job.id);
+      this.monitorShellCommandJob(refreshed);
     }
   }
 
@@ -4628,14 +4724,26 @@ export class ProxySessionController {
     contextKey: string,
     event: ChatUpdatedEvent,
   ): Promise<void> {
-    const parsed = parseAgentGroupName(event.afterName);
-    if (!parsed) return;
     const context = this.store.getUserContext(contextKey);
     if (!context?.currentSessionId) return;
     const record = this.store.getSessionForContext(context.currentSessionId, contextKey);
     if (!record || record.status === "closed") return;
-    if (record.agentName.toLowerCase() !== parsed.agentName.toLowerCase()) return;
-    const title = normalizeTaskTitle(parsed.title);
+    const nameFormat = this.config.feishu?.groupNameFormat ?? DEFAULT_GROUP_NAME_FORMAT;
+    const projectCwd = detectProjectlessWorkspace(record.cwd) ? undefined : record.cwd;
+    const templateTitle = parseTaskNameFromGroupName({
+      agentName: record.agentName,
+      groupName: event.afterName,
+      projectCwd,
+      format: nameFormat,
+    });
+    const legacy = parseAgentGroupName(event.afterName);
+    const legacyTitle = legacy && record.agentName.toLowerCase() === legacy.agentName.toLowerCase()
+      ? legacy.title
+      : undefined;
+    if (isDefaultGroupNameFormat(nameFormat) && isLegacyGroupPrefixOnly(event.afterName)) return;
+    const title = normalizeTaskTitle(isDefaultGroupNameFormat(nameFormat)
+      ? legacyTitle ?? templateTitle
+      : templateTitle ?? legacyTitle);
     if (!title || title === record.title) return;
 
     const loaded = await this.loadSession(record);
@@ -4990,6 +5098,13 @@ export class ProxySessionController {
     if (!stats.isFile()) throw new Error(`这不是普通文件：${filePath}`);
   }
 
+  private async sendCurrentTaskFile(contextKey: string, requestedFilePath: string): Promise<void> {
+    const record = this.requireCurrentSession(contextKey);
+    const filePath = resolveUserPath(requestedFilePath, record.cwd);
+    await this.assertSendableFile(filePath);
+    await this.outbound.sendFile(contextKey, filePath);
+  }
+
   private async listSessions(
     contextKey: string,
     searchTerm?: string,
@@ -6505,14 +6620,29 @@ function isBotOwnedActiveTurn(record: SessionRecord, remote: RemoteSessionSummar
 }
 
 function isQueueIndependentCommand(command: Command): boolean {
-  if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "goal", "nosteer"].includes(command.type)) return true;
+  if (["archive", "dismiss", "stop", "status", "restart", "mute", "help", "sessions", "dir", "file", "goal", "nosteer", "shell"].includes(command.type)) return true;
   if (command.type === "agent") return command.agent === undefined;
   if (["model", "provider", "thinking", "permissions"].includes(command.type)) return true;
   return false;
 }
 
+function shellCommandJobCardView(job: ShellCommandJobSnapshot): ShellCommandCardView {
+  const status = job.status === "starting" ? "running" : job.status;
+  return {
+    jobId: job.id,
+    contextKey: job.contextKey,
+    command: job.command,
+    cwd: job.cwd,
+    output: [job.output.trimEnd(), job.error].filter(Boolean).join("\n"),
+    status,
+    exitCode: job.exitCode,
+    elapsedMs: Math.max(0, (job.completedAt ?? Date.now()) - job.startedAt),
+    outputTruncated: job.outputTruncated,
+  };
+}
+
 function commandRequiresCurrentSession(command: Command): boolean {
-  if (["dismiss", "stop", "title", "turns", "model", "provider", "thinking", "permissions", "nosteer"].includes(command.type)) {
+  if (["dismiss", "stop", "title", "turns", "file", "model", "provider", "thinking", "permissions", "nosteer"].includes(command.type)) {
     return true;
   }
   if (command.type === "archive" || command.type === "fork") return command.sessionId === undefined;
@@ -6696,8 +6826,8 @@ async function listWindowsDriveRoots(): Promise<WindowsDriveInfo[]> {
   return drives;
 }
 
-function isPromptCommand(command: Command): boolean {
-  return command.type === "prompt" || command.type === "nosteer";
+function commandDefersReactionFinalization(command: Command): boolean {
+  return command.type === "prompt" || command.type === "nosteer" || command.type === "shell";
 }
 
 function runtimePrompt(text: string, localImagePaths?: string[]): RuntimePrompt {
@@ -6871,44 +7001,6 @@ function isRecoveryAttemptRecent(attempt: TurnAttemptRecord, cutoff: number): bo
   return Number.isFinite(updatedAt) && updatedAt >= cutoff;
 }
 
-function formatGroupDateSuffix(date: Date): string {
-  const month = String(date.getMonth() + 1).padStart(2, "0");
-  const day = String(date.getDate()).padStart(2, "0");
-  return `${month}-${day}`;
-}
-
-function formatNewGroupName(
-  agentName: string,
-  projectCwd: string | undefined,
-  taskTitle: string,
-  date: Date,
-  includeTimestamp: boolean,
-): string {
-  const prefix = `[${agentName}] `;
-  const projectPrefix = projectCwd ? `${formatGroupProjectDirectory(projectCwd)} ` : "";
-  const titlePrefix = `${prefix}${projectPrefix}`;
-  const timestampSuffix = includeTimestamp ? ` (${formatGroupDateSuffix(date)})` : "";
-  const availableTitleLength = FEISHU_GROUP_NAME_MAX_LENGTH
-    - Array.from(titlePrefix).length
-    - Array.from(timestampSuffix).length;
-  const title = truncateTail(taskTitle, availableTitleLength);
-  return truncateTail(`${titlePrefix}${title}${timestampSuffix}`, FEISHU_GROUP_NAME_MAX_LENGTH);
-}
-
-const FEISHU_GROUP_NAME_MAX_LENGTH = 60;
-const GROUP_PROJECT_DIRECTORY_MAX_LENGTH = 15;
-
-function formatGroupProjectDirectory(projectCwd: string): string {
-  const value = abbreviateHomeDirectory(projectCwd);
-  const levels = value
-    .replace(/[\\/]+$/, "")
-    .split(/[\\/]+/)
-    .filter(Boolean)
-    .slice(-2);
-  const separator = value.includes("\\") ? path.win32.sep : path.posix.sep;
-  return `[${fitTrailingPathLevels(levels, GROUP_PROJECT_DIRECTORY_MAX_LENGTH, separator)}]`;
-}
-
 function abbreviateHomeDirectory(value: string): string {
   const homeDirectory = os.homedir();
   const valueIsWindows = isWindowsAbsolutePath(value);
@@ -6925,29 +7017,6 @@ function isWindowsAbsolutePath(value: string): boolean {
   return /^[a-z]:[\\/]|^\\\\/iu.test(value);
 }
 
-function fitTrailingPathLevels(levels: string[], maxLength: number, separator: string): string {
-  if (levels.length === 0) return "";
-  if (levels.length === 1) return truncatePathLevel(levels[0]!, maxLength);
-  const parent = levels[0]!;
-  const leaf = levels[1]!;
-  const joined = `${parent}${separator}${leaf}`;
-  if (Array.from(joined).length <= maxLength) return joined;
-  if (Array.from(leaf).length <= maxLength) return leaf;
-  return truncatePathLevel(leaf, maxLength);
-}
-
-function truncatePathLevel(value: string, maxLength: number): string {
-  return truncateTail(value, maxLength);
-}
-
-function truncateTail(value: string, maxLength: number): string {
-  const characters = Array.from(value);
-  if (characters.length <= maxLength) return value;
-  if (maxLength <= 0) return "";
-  if (maxLength <= 3) return ".".repeat(maxLength);
-  return `${characters.slice(0, maxLength - 3).join("")}...`;
-}
-
 function parseAgentGroupName(value: string): { agentName: string; title: string } | undefined {
   const match = /^\[([^[\]]+)\]\s+(.+)$/.exec(value.trim());
   const agentName = match?.[1]?.trim();
@@ -6958,6 +7027,15 @@ function parseAgentGroupName(value: string): { agentName: string; title: string
   return agentName && title ? { agentName, title } : undefined;
 }
 
+function isDefaultGroupNameFormat(format: AppConfig["feishu"]["groupNameFormat"]): boolean {
+  return format.project === DEFAULT_GROUP_NAME_FORMAT.project
+    && format.projectless === DEFAULT_GROUP_NAME_FORMAT.projectless;
+}
+
+function isLegacyGroupPrefixOnly(value: string): boolean {
+  return /^\[[^[\]]+\]\s+\[[^[\]]+\]\s*$/u.test(value.trim());
+}
+
 function validateGoalObjective(objective: string): void {
   const length = Array.from(objective.trim()).length;
   if (length === 0) throw new Error("Goal 不能为空。");