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

package/src/codex/CodexRuntime.ts

@@ -355,12 +355,18 @@ export class CodexRuntime implements AgentRuntime {
 
   async closeSession(sessionId: string): Promise<void> {
     const session = this.requireSession(sessionId);
+    await this.archiveRemoteSession(session.remoteSessionId);
+  }
+
+  async archiveRemoteSession(remoteSessionId: string): Promise<void> {
     await (await this.client()).request(
       "thread/archive",
-      { threadId: session.remoteSessionId },
+      { threadId: remoteSessionId },
       CONTROL_REQUEST_TIMEOUT_MS,
     );
-    this.sessions.delete(sessionId);
+    for (const [localSessionId, session] of this.sessions) {
+      if (session.remoteSessionId === remoteSessionId) this.sessions.delete(localSessionId);
+    }
   }
 
   async setTitle(sessionId: string, title: string): Promise<void> {

package/src/commands/CommandRouter.ts

@@ -1,8 +1,10 @@
 import type { Command } from "./commandTypes.js";
 
-const COMMAND_NAMES = [
+export const COMMAND_NAMES = [
   "agent",
+  "archive",
   "dir",
+  "dismiss",
   "fork",
   "forkgroup",
   "goal",
@@ -28,6 +30,7 @@ const COMMAND_NAMES = [
 type CommandName = (typeof COMMAND_NAMES)[number];
 
 const COMMAND_INITIALISMS: Partial<Record<CommandName, string>> = {
+  dir: "di",
   forkgroup: "fg",
   newgroup: "ng",
   nosteer: "ns",
@@ -76,6 +79,13 @@ export class CommandRouter {
         return args[0] ? { type: "switch", sessionId: args[0] } : { type: "switch" };
       case "agent":
         return args[0] ? { type: "agent", agent: args[0] } : { type: "agent" };
+      case "archive":
+        rejectOptions("/archive", args);
+        if (args.length > 1) throw new Error("/archive 只接受一个可选的任务序号或任务 ID。");
+        return args[0] ? { type: "archive", sessionId: args[0] } : { type: "archive" };
+      case "dismiss":
+        if (args.length > 0) throw new Error("/dismiss 不接受参数，请在确认卡片中完成操作。");
+        return { type: "dismiss" };
       case "stop":
         return { type: "stop" };
       case "status":
@@ -132,6 +142,9 @@ function resolveCommandName(rawCommand: string): CommandName {
   const exact = COMMAND_NAMES.find((command) => command === input);
   if (exact) return exact;
 
+  const initialism = COMMAND_NAMES.find((command) => COMMAND_INITIALISMS[command] === input);
+  if (initialism) return initialism;
+
   const matches = COMMAND_NAMES.filter(
     (command) => command.startsWith(input) || COMMAND_INITIALISMS[command] === input,
   );

package/src/commands/commandTypes.ts

@@ -10,6 +10,8 @@ export type Command =
   | { type: "sessions"; searchTerm?: string }
   | { type: "switch"; sessionId?: string }
   | { type: "agent"; agent?: string }
+  | { type: "archive"; sessionId?: string }
+  | { type: "dismiss" }
   | { type: "stop" }
   | { type: "status"; sessionId?: string }
   | { type: "goal"; action: "show" }

package/src/feishu/CardRenderer.ts

@@ -11,7 +11,7 @@ import type {
   ToolState,
 } from "../runtime/types.js";
 import type { TurnActivity, TurnViewState, TurnViewStatus } from "../presentation/turnViewTypes.js";
-import { truncateMiddle, truncateText } from "../utils/markdown.js";
+import { truncateText } from "../utils/markdown.js";
 import { localCardImage } from "./LocalCardImage.js";
 
 export interface StartupStatusView {
@@ -226,6 +226,13 @@ export interface ResetHistoryCardView {
   pageActions: TaskListCardAction[];
 }
 
+export interface DismissGroupCardView {
+  contextKey: string;
+  sessionId: string;
+  taskTitle: string;
+  requestedBy: string;
+}
+
 export class CardRenderer {
   private readonly thinkingCardLayout: ThinkingCardLayout;
 
@@ -853,19 +860,29 @@ export class CardRenderer {
     const elements = this.thinkingCardLayout === "timeline"
       ? renderTurnElements(state, "hidden")
       : renderGroupedTurnElements(state, "hidden");
+    const footerActions: TaskListCardAction[] = [];
     if (isTurnStoppable(state.status)) {
-      elements.push({ tag: "hr" }, taskActionRow([{
+      footerActions.push({
         text: "Stop",
         type: "danger",
         value: { action: "turn_cancel", sessionId: state.sessionId, turnId: state.turnId },
-      }]));
+      });
+      elements.push(
+        { tag: "hr" },
+        taskActionRow(footerActions),
+      );
     } else if (state.status === "completed") {
+      footerActions.push({
+        text: "Reset",
+        value: { action: "turn_reset", sessionId: state.sessionId, turnId: state.turnId },
+      });
       elements.push(
         { tag: "hr" },
-        taskActionRow([{
-          text: "Reset",
-          value: { action: "turn_reset", sessionId: state.sessionId, turnId: state.turnId },
-        }]),
+        taskActionRow(footerActions),
+      );
+    }
+    if (state.status === "completed") {
+      elements.push(
         {
           ...markdown("<font color='grey'>Reset 会将当前任务的对话上下文恢复到本轮完成时；不会回退本地文件。</font>"),
           text_size: "notation",
@@ -889,15 +906,26 @@ export class CardRenderer {
 
   renderActivityHistory(state: TurnViewState, requestedPage: number): Record<string, unknown> {
     const grouped = this.thinkingCardLayout === "grouped";
+    const activities = turnActivities(state);
+    const allGroups = grouped ? groupTurnActivities(activities).flatMap(splitGroupedExecutionActivity) : [];
+    const historyGroups = grouped
+      ? groupedLiveActivityPage(groupedActivityPagesFromGroups(allGroups, state.projectCwd), state.projectCwd).historyGroups
+      : [];
+    const usesHistoricalPrefixPages = historyGroups.length > 0;
     const pages = grouped
-      ? groupedActivityPages(turnActivities(state), state.projectCwd, {
+      ? groupedActivityPagesFromGroups(
+        usesHistoricalPrefixPages ? historyGroups : allGroups,
+        state.projectCwd,
+        {
         fullActivityText: true,
         includeReasoningHistory: true,
-      })
-      : activityPages(turnActivities(state));
+        },
+      )
+      : activityPages(activities);
     if (pages.length === 0) {
       return this.renderSectionsCard("思考活动历史", [{ lines: ["没有保存到活动记录。"] }]);
     }
+    const totalPages = usesHistoricalPrefixPages ? pages.length + 1 : pages.length;
     const page = Math.max(0, Math.min(Math.trunc(requestedPage), pages.length - 1));
     const actions: TaskListCardAction[] = [
       ...(pages.length > 1 ? [{
@@ -908,7 +936,7 @@ export class CardRenderer {
         text: "上一页",
         value: { action: "activity_history", turnId: state.turnId, page: String(page - 1) },
       }] : []),
-      ...(page < pages.length - 2 ? [{
+      ...(page < pages.length - (usesHistoricalPrefixPages ? 1 : 2) ? [{
         text: "下一页",
         value: { action: "activity_history", turnId: state.turnId, page: String(page + 1) },
       }] : []),
@@ -921,7 +949,7 @@ export class CardRenderer {
         includeReasoningHistory: true,
       })
       : renderActivities(pages[page] as TurnActivity[] | undefined ?? [], state.projectCwd, true)));
-    return sectionCard(`思考活动历史 · ${page + 1}/${pages.length}`, elements.length > 0 ? elements : [markdown("无")]);
+    return sectionCard(`思考活动历史 · ${page + 1}/${totalPages}`, elements.length > 0 ? elements : [markdown("无")]);
   }
 
   renderSessionStarted(session: RuntimeSession): Record<string, unknown> {
@@ -969,6 +997,57 @@ export class CardRenderer {
     return this.baseCard("Agent Bot 状态", "blue", [markdown(status)]);
   }
 
+  renderDismissGroupConfirmation(view: DismissGroupCardView): Record<string, unknown> {
+    const actionValue = {
+      contextKey: view.contextKey,
+      sessionId: view.sessionId,
+      requestedBy: view.requestedBy,
+    };
+    const button = (
+      content: string,
+      type: "default" | "danger",
+      action: "group_dismiss_confirm" | "group_dismiss_keep",
+    ): Record<string, unknown> => ({
+      tag: "button",
+      width: "fill",
+      text: { tag: "plain_text", content },
+      type,
+      behaviors: [{
+        type: "callback",
+        value: { action, ...actionValue },
+      }],
+    });
+    return compactCard("解散当前群聊", "blue", [
+      markdown([
+        "确定要解散当前群聊吗？",
+        `当前任务「${escapeCardHtml(view.taskTitle)}」将同时归档。此操作无法撤销。`,
+      ].join("\n")),
+      {
+        tag: "column_set",
+        flex_mode: "none",
+        horizontal_spacing: "8px",
+        columns: [
+          {
+            tag: "column",
+            width: "weighted",
+            weight: 1,
+            elements: [button("Dismiss", "danger", "group_dismiss_confirm")],
+          },
+          {
+            tag: "column",
+            width: "weighted",
+            weight: 1,
+            elements: [button("Keep", "default", "group_dismiss_keep")],
+          },
+        ],
+      },
+    ]);
+  }
+
+  renderDismissGroupKept(): Record<string, unknown> {
+    return compactCard("已保留当前群聊", "grey", [markdown("已取消解散群聊。")]);
+  }
+
   renderSectionsCard(
     title: string,
     sections: CardSection[],
@@ -1160,17 +1239,21 @@ export class CardRenderer {
 }
 
 function renderTurnSubtitle(state: TurnViewState): string {
-  const elapsed = state.durationMs ?? Math.max(0, Date.now() - state.startedAt);
   const activityTools = turnActivities(state).filter((activity) => activity.kind === "tool").length;
   const totalTools = state.totalToolCount ?? activityTools;
   return [
-    `耗时 ${formatTurnDuration(elapsed)}`,
+    `耗时 ${renderTurnDuration(state)}`,
     state.totalTokens !== undefined ? `${formatTokenCount(state.totalTokens)} tokens` : undefined,
     totalTools > 0 ? `${totalTools} 个工具` : undefined,
     state.fileSummary.length > 0 ? `${state.fileSummary.length} 个文件` : undefined,
   ].filter(Boolean).join(" · ");
 }
 
+function renderTurnDuration(state: TurnViewState): string {
+  const endedAt = state.completedAt ?? Date.now();
+  return formatTurnDuration(state.durationMs ?? Math.max(0, endedAt - state.startedAt));
+}
+
 function isTurnStoppable(status: TurnViewStatus): boolean {
   return status === "running" || status === "tool_running" || status === "waiting_for_approval";
 }
@@ -1249,24 +1332,24 @@ function renderGroupedTurnElements(
   const elements: Record<string, unknown>[] = [];
   const allActivities = turnActivities(state);
   const livePages = groupedActivityPages(allActivities, state.projectCwd);
-  const historyPages = groupedActivityPages(allActivities, state.projectCwd, {
+  const visible = groupedLiveActivityPage(livePages, state.projectCwd);
+  const historyPages = groupedActivityPagesFromGroups(visible.historyGroups, state.projectCwd, {
     fullActivityText: true,
     includeReasoningHistory: true,
   });
-  const visibleGroups = livePages.at(-1) ?? [];
   if (state.plan.length > 0) elements.push(planPanel(state.plan));
-  if (historyPages.length > 1) {
+  if (historyPages.length > 0) {
     elements.push(taskActionRow([{
-      text: `查看历史思考（共 ${historyPages.length} 页）`,
+      text: `查看历史思考（共 ${historyPages.length + 1} 页）`,
       value: {
         action: "activity_history",
         turnId: state.turnId,
-        page: String(historyPages.length - 2),
+        page: String(historyPages.length - 1),
       },
     }]));
   }
-  if (state.activitiesTruncated || livePages.length > 1 || historyPages.length > 1) elements.push(markdown("…"));
-  elements.push(...renderGroupedActivityGroups(visibleGroups, state.projectCwd));
+  if (state.activitiesTruncated && visible.groups[0]?.kind !== "gap") elements.push(markdown("…"));
+  elements.push(...renderGroupedActivityGroups(visible.groups, state.projectCwd));
   if (state.fileSummary.length > 0) elements.push(fileSummaryPanel(state));
 
   if (state.approval) {
@@ -1407,6 +1490,7 @@ function renderActivities(
 
 type GroupedTurnActivity =
   | { kind: "activity"; activity: TurnActivity }
+  | { kind: "gap"; id: string }
   | {
       kind: "execution";
       id: string;
@@ -1424,6 +1508,7 @@ function renderGroupedActivityGroups(
   } = {},
 ): Record<string, unknown>[] {
   return groups.flatMap((group) => {
+    if (group.kind === "gap") return [markdown("…")];
     if (group.kind === "activity") {
       return renderActivity(group.activity, projectCwd, options.fullActivityText === true);
     }
@@ -1500,7 +1585,7 @@ function executionActivityPanel(
     {
       elementId: executionActivityPanelElementId(group.id),
       expanded: false,
-      borderColor: status === "failed" ? "red" : status === "running" ? "blue" : "grey",
+      borderColor: status === "running" ? "blue" : "grey",
       compact: true,
     },
   );
@@ -1508,7 +1593,6 @@ function executionActivityPanel(
 
 function executionActivityStatus(tools: ToolState[]): ToolState["status"] {
   if (tools.some((tool) => tool.status === "running")) return "running";
-  if (tools.some((tool) => tool.status === "failed")) return "failed";
   return "completed";
 }
 
@@ -1516,7 +1600,7 @@ function executionActivityTitle(
   group: Extract<GroupedTurnActivity, { kind: "execution" }>,
   status: ToolState["status"],
 ): string {
-  const icon = status === "running" ? "⏳" : status === "failed" ? "❌" : "💭";
+  const icon = status === "running" ? "⏳" : "💭";
   const latestReasoning = group.latestReasoning?.text
     ? removeMarkdownBold(group.latestReasoning.text).replace(/\s+/g, " ").trim()
     : "";
@@ -1524,9 +1608,7 @@ function executionActivityTitle(
     ? truncateText(latestReasoning, 90)
     : status === "running"
       ? "正在执行工具"
-      : status === "failed"
-        ? "工具执行失败"
-        : "已执行工具";
+      : "已执行工具";
   return `${icon} ${summary} · ${group.tools.length} 个工具`;
 }
 
@@ -1559,6 +1641,7 @@ const ACTIVITIES_PER_PAGE = 40;
 const GROUPED_TOOLS_PER_PANEL = 8;
 const GROUPED_PAGE_ACTIVITY_BYTES = 24 * 1024;
 const GROUPED_PAGE_ACTIVITY_COMPONENTS = 160;
+const PINNED_LIVE_COMMENTARIES = 3;
 const MAX_LIVE_ASSISTANT_TEXT = 2_000;
 const ACTIVITY_TEXT_CHUNK = 2_500;
 
@@ -1583,6 +1666,17 @@ function groupedActivityPages(
   } = {},
 ): GroupedTurnActivity[][] {
   const groups = groupTurnActivities(activities).flatMap(splitGroupedExecutionActivity);
+  return groupedActivityPagesFromGroups(groups, projectCwd, renderOptions);
+}
+
+function groupedActivityPagesFromGroups(
+  groups: GroupedTurnActivity[],
+  projectCwd?: string,
+  renderOptions: {
+    fullActivityText?: boolean;
+    includeReasoningHistory?: boolean;
+  } = {},
+): GroupedTurnActivity[][] {
   if (groups.length === 0) return [];
 
   const newestFirst: GroupedTurnActivity[][] = [];
@@ -1613,6 +1707,82 @@ function groupedActivityPageFits(
     && countCardComponents(elements) <= GROUPED_PAGE_ACTIVITY_COMPONENTS;
 }
 
+interface LiveGroupedActivityPage {
+  groups: GroupedTurnActivity[];
+  historyGroups: GroupedTurnActivity[];
+}
+
+function groupedLiveActivityPage(
+  pages: GroupedTurnActivity[][],
+  projectCwd?: string,
+): LiveGroupedActivityPage {
+  const latest = pages.at(-1) ?? [];
+  if (pages.length <= 1) return { groups: latest, historyGroups: [] };
+
+  const groups = pages.flat();
+  const latestStart = groups.length - latest.length;
+  const commentaryIndexes = groups
+    .map((group, index) => isCommentaryGroup(group) ? index : -1)
+    .filter((index) => index >= 0);
+  if (commentaryIndexes.length === 0) {
+    return { groups: latest, historyGroups: groups.slice(0, latestStart) };
+  }
+
+  const selected = new Set<number>();
+  const pinnedCommentaries = commentaryIndexes.slice(0, PINNED_LIVE_COMMENTARIES);
+  for (const index of pinnedCommentaries) selected.add(index);
+  const latestCommentary = commentaryIndexes.at(-1)!;
+  for (let index = latestCommentary; index < groups.length; index += 1) selected.add(index);
+
+  const renderSelection = (selection: ReadonlySet<number>): LiveGroupedActivityPage => ({
+    groups: groupsWithGaps(groups, selection),
+    historyGroups: groups.filter((_group, index) => index < latestCommentary || !selection.has(index)),
+  });
+  const fits = (selection: ReadonlySet<number>): boolean => {
+    const view = renderSelection(selection);
+    return groupedActivityPageFits(view.groups, projectCwd, {});
+  };
+
+  if (!fits(selected)) {
+    const latestExecutions = [...selected]
+      .filter((index) => index > latestCommentary && groups[index]?.kind === "execution")
+      .sort((left, right) => left - right);
+    const newestExecution = latestExecutions.at(-1);
+    for (const index of latestExecutions) {
+      if (fits(selected) || index === newestExecution) break;
+      selected.delete(index);
+    }
+  }
+
+  return renderSelection(selected);
+}
+
+function isCommentaryGroup(group: GroupedTurnActivity): boolean {
+  return group.kind === "activity" && isCommentaryActivity(group.activity);
+}
+
+function groupsWithGaps(
+  groups: GroupedTurnActivity[],
+  selected: ReadonlySet<number>,
+): GroupedTurnActivity[] {
+  const indexes = [...selected].sort((left, right) => left - right);
+  const visible: GroupedTurnActivity[] = [];
+  const append = (group: GroupedTurnActivity): void => {
+    if (group.kind === "gap" && visible.at(-1)?.kind === "gap") return;
+    visible.push(group);
+  };
+  let previous = -1;
+  for (const index of indexes) {
+    if (previous >= 0 && index > previous + 1) {
+      append({ kind: "gap", id: `gap:${previous}:${index}` });
+    }
+    const group = groups[index];
+    if (group) append(group);
+    previous = index;
+  }
+  return visible;
+}
+
 function countCardComponents(value: unknown): number {
   if (Array.isArray(value)) {
     return value.reduce((total, entry) => total + countCardComponents(entry), 0);
@@ -1791,13 +1961,22 @@ function renderToolDetails(tool: ToolState, projectCwd?: string): string {
   const result = tool.error ?? tool.output ?? fileSummary;
   const normalizedCommand = stripAnsi(command).trim();
   const displayCommand = tool.kind === "command"
-    ? unwrapPowerShellCommand(normalizedCommand) ?? normalizedCommand
+    ? unwrapShellCommand(normalizedCommand) ?? normalizedCommand
     : normalizedCommand;
-  const commandText = truncateText(displayCommand, 800);
-  const resultText = result ? truncateMiddle(stripAnsi(result).trim(), 1_200) : undefined;
+  const commandText = truncateText(displayCommand, 600);
+  const resultText = result ? truncateToolResult(stripAnsi(result).trim()) : undefined;
   return codeBlock([`$ ${commandText}`, resultText].filter((part): part is string => part !== undefined).join("\n"), 2_003);
 }
 
+function truncateToolResult(result: string): string {
+  const maxLength = 900;
+  const marker = "\n...\n";
+  const tailLength = 600;
+  if (result.length <= maxLength) return result;
+  const headLength = maxLength - marker.length - tailLength;
+  return `${result.slice(0, headLength)}${marker}${result.slice(-tailLength)}`;
+}
+
 function displayFilePath(filePath: string, projectCwd?: string): string {
   if (!projectCwd) return filePath;
   const pathApi = usesWindowsPaths(projectCwd, filePath) ? path.win32 : path;
@@ -1826,7 +2005,7 @@ function toolPanelTitle(tool: ToolState): string {
   const command = stripAnsi(tool.command ?? tool.title).trim();
   const meaningfulCommand = tool.kind === "web_search"
     ? tool.title
-    : unwrapPowerShellCommand(command) ?? tool.title;
+    : unwrapShellCommand(command) ?? tool.title;
   const duration = toolDuration(tool);
   const prefix = `${icon} `;
   const suffix = duration ? ` · ${duration}` : "";
@@ -1875,6 +2054,10 @@ function formatTurnDuration(durationMs: number): string {
   return `${seconds}s`;
 }
 
+function unwrapShellCommand(command: string): string | undefined {
+  return unwrapPowerShellCommand(command) ?? unwrapPosixShellCommand(command);
+}
+
 function unwrapPowerShellCommand(command: string): string | undefined {
   const executable = command.match(
     /^(?:"[^"]*(?:pwsh|powershell)\.exe"|(?:\S*[\\/])?(?:pwsh|powershell)(?:\.exe)?)(?=\s|$)/i,
@@ -1885,6 +2068,71 @@ function unwrapPowerShellCommand(command: string): string | undefined {
   if (!commandFlag) return undefined;
   const payload = args.slice(commandFlag.index + commandFlag[0].length).trim();
   if (!payload) return undefined;
+  return unwrapQuotedPayload(payload);
+}
+
+function unwrapPosixShellCommand(command: string): string | undefined {
+  let executable = readCommandWord(command, 0);
+  if (!executable) return undefined;
+
+  if (posixExecutableName(executable.value) === "env") {
+    let cursor = executable.end;
+    while (true) {
+      const candidate = readCommandWord(command, cursor);
+      if (!candidate) return undefined;
+      const name = posixExecutableName(candidate.value);
+      if (isPosixShell(name)) {
+        executable = candidate;
+        break;
+      }
+      if (!candidate.value.startsWith("-") && !/^[A-Za-z_][A-Za-z0-9_]*=/.test(candidate.value)) {
+        return undefined;
+      }
+      cursor = candidate.end;
+    }
+  } else if (!isPosixShell(posixExecutableName(executable.value))) {
+    return undefined;
+  }
+
+  const args = command.slice(executable.end);
+  const commandFlag = /(?:^|\s)(?:-[A-Za-z]*c[A-Za-z]*|--command)(?:\s+|=)/.exec(args);
+  if (!commandFlag) return undefined;
+  const payload = args.slice(commandFlag.index + commandFlag[0].length).trim();
+  if (!payload) return undefined;
+  return unwrapQuotedPayload(payload);
+}
+
+function readCommandWord(command: string, start: number): { value: string; end: number } | undefined {
+  let cursor = start;
+  while (cursor < command.length && /\s/.test(command[cursor] ?? "")) cursor += 1;
+  if (cursor >= command.length) return undefined;
+
+  const quote = command[cursor];
+  if (quote === "\"" || quote === "'") {
+    const endQuote = command.indexOf(quote, cursor + 1);
+    if (endQuote < 0) return undefined;
+    return { value: command.slice(cursor + 1, endQuote), end: endQuote + 1 };
+  }
+
+  const word = /^\S+/.exec(command.slice(cursor));
+  if (!word) return undefined;
+  return { value: word[0], end: cursor + word[0].length };
+}
+
+function posixExecutableName(executable: string): string {
+  return executable.replaceAll("\\", "/").split("/").at(-1)?.toLowerCase() ?? "";
+}
+
+function isPosixShell(executable: string): boolean {
+  return executable === "sh"
+    || executable === "bash"
+    || executable === "zsh"
+    || executable === "dash"
+    || executable === "ksh"
+    || executable === "fish";
+}
+
+function unwrapQuotedPayload(payload: string): string {
   const quote = payload[0];
   if ((quote === "\"" || quote === "'") && payload.at(-1) === quote) return payload.slice(1, -1).trim();
   return payload;
@@ -2316,10 +2564,12 @@ function turnCard(
         tag: "plain_text",
         content: title,
       },
-      subtitle: {
-        tag: "plain_text",
-        content: subtitle,
-      },
+      ...(subtitle ? {
+        subtitle: {
+          tag: "plain_text",
+          content: subtitle,
+        },
+      } : {}),
       padding: "12px 12px 12px 12px",
     },
     body: {
@@ -2360,6 +2610,34 @@ function sectionCard(
   };
 }
 
+function compactCard(
+  title: string,
+  template: string,
+  elements: Record<string, unknown>[],
+): Record<string, unknown> {
+  return {
+    schema: "2.0",
+    config: {
+      update_multi: true,
+      width_mode: "compact",
+    },
+    header: {
+      template,
+      title: {
+        tag: "plain_text",
+        content: title,
+      },
+      padding: "12px 12px 12px 12px",
+    },
+    body: {
+      direction: "vertical",
+      vertical_spacing: "12px",
+      padding: "12px 12px 12px 12px",
+      elements,
+    },
+  };
+}
+
 function formatUpdate(update: Record<string, JsonValue>): string {
   const updateType = update.sessionUpdate;
   if (updateType === "agent_message_chunk" && isObject(update.content)) {

package/src/feishu/FeishuMarkdown.ts

@@ -6,6 +6,8 @@ interface FenceState {
 }
 
 const FENCE_OPENER = /^([ \t]*)((?:`{3,})|(?:~{3,}))(.*)$/;
+const MARKDOWN_LINK = /(!?)\[([^\]\r\n]*)\]\((<?[^)\r\n]+>?)\)/g;
+const LOCAL_FILE_LINE_REFERENCE = /(:\d+(?::\d+)?)$/;
 
 export function normalizeFeishuMarkdown(markdown: string): string {
   const lines = markdown.match(/[^\r\n]*(?:\r\n|\n)|[^\r\n]+$/g) ?? [];
@@ -17,7 +19,7 @@ export function normalizeFeishuMarkdown(markdown: string): string {
 
     if (!fence) {
       const opener = FENCE_OPENER.exec(body);
-      if (!opener?.[2]) return line;
+      if (!opener?.[2]) return `${includeLocalFileLineReferences(body)}${ending}`;
 
       const indent = opener[1] ?? "";
       const delimiter = opener[2];
@@ -38,6 +40,30 @@ export function normalizeFeishuMarkdown(markdown: string): string {
   }).join("");
 }
 
+function includeLocalFileLineReferences(markdown: string): string {
+  return markdown.replace(MARKDOWN_LINK, (link, imageMarker: string, label: string, rawTarget: string) => {
+    if (imageMarker) return link;
+
+    const target = unwrapMarkdownTarget(rawTarget.trim());
+    if (!isLocalFileTarget(target)) return link;
+
+    const reference = LOCAL_FILE_LINE_REFERENCE.exec(target)?.[1];
+    if (!reference || label.endsWith(reference)) return link;
+    return `[${label}${reference}](${rawTarget})`;
+  });
+}
+
+function unwrapMarkdownTarget(target: string): string {
+  return target.startsWith("<") && target.endsWith(">") ? target.slice(1, -1) : target;
+}
+
+function isLocalFileTarget(target: string): boolean {
+  return /^file:\/\//i.test(target)
+    || /^\/?[a-z]:[\\/]/i.test(target)
+    || /^\\\\/.test(target)
+    || /^\/(?!\/)/.test(target);
+}
+
 function isFenceCloser(line: string, fence: FenceState): boolean {
   const match = /^[ \t]*(`+|~+)[ \t]*$/.exec(line);
   const delimiter = match?.[1];