chatccc 0.2.218 → 0.2.220

package/src/builtin/file-tools.ts

@@ -2,7 +2,9 @@ import { spawn } from "node:child_process";
 import { createHash, randomBytes } from "node:crypto";
 import { createReadStream } from "node:fs";
 import { copyFile, mkdir, open, readFile, readdir, rename, stat, unlink, writeFile } from "node:fs/promises";
-import { basename, dirname, isAbsolute, resolve } from "node:path";
+import { createRequire } from "node:module";
+import { basename, dirname, isAbsolute, relative, resolve, sep } from "node:path";
+import { createInterface } from "node:readline";
 
 import { jsonSchema, tool, type ToolSet } from "ai";
 
@@ -19,6 +21,8 @@ const SEARCH_TIMEOUT_MS = 15_000;
 const MAX_COMMAND_OUTPUT_BYTES = 256 * 1024;
 const DEFAULT_COMMAND_TIMEOUT_MS = 120_000;
 const MAX_COMMAND_TIMEOUT_MS = 900_000;
+const requireFromHere = createRequire(import.meta.url);
+const FALLBACK_SKIPPED_DIRECTORIES = new Set([".git", "node_modules"]);
 
 export interface ReadFileInput {
   path: string;
@@ -77,6 +81,11 @@ export interface SearchCodeOutput {
   truncated: boolean;
 }
 
+/** @internal Allows tests to force the dependency-free fallback path. */
+export interface SearchCodeRuntimeOptions {
+  ripgrepCommands?: readonly string[];
+}
+
 export interface RunCommandInput {
   command: string;
   cwd?: string;
@@ -546,32 +555,44 @@ function parseRgLine(line: string): SearchCodeMatch | null {
   };
 }
 
-export async function searchCodeForTool(
-  cwd: string,
-  input: SearchCodeInput,
-  signal?: AbortSignal,
-): Promise<SearchCodeOutput> {
-  const query = input.query?.trim();
-  if (!query) throw new Error("query is required");
+interface RipgrepOutput {
+  stdout: string;
+  stderr: string;
+  truncated: boolean;
+}
 
-  const searchPath = resolveToolPath(cwd, input.path);
-  const maxResults = Math.min(toPositiveInt(input.maxResults) ?? 50, MAX_SEARCH_RESULTS);
-  const args = [
-    "--line-number",
-    "--column",
-    "--no-heading",
-    "--color",
-    "never",
-    "--max-count",
-    String(maxResults),
-  ];
-  if (input.glob?.trim()) {
-    args.push("--glob", input.glob.trim());
+function resolveBundledRipgrepPath(): string | undefined {
+  try {
+    const bundled = requireFromHere("@vscode/ripgrep") as { rgPath?: unknown };
+    return typeof bundled.rgPath === "string" && bundled.rgPath.trim()
+      ? bundled.rgPath
+      : undefined;
+  } catch {
+    // Unsupported platforms or damaged optional platform packages must not
+    // prevent ChatCCC itself from starting; system rg / Node fallback remain.
+    return undefined;
   }
-  args.push("--", query, searchPath);
+}
+
+function defaultRipgrepCommands(): string[] {
+  const bundled = resolveBundledRipgrepPath();
+  return [...new Set([bundled, "rg"].filter((value): value is string => !!value))];
+}
+
+function isUnavailableExecutableError(err: unknown): boolean {
+  const code = (err as NodeJS.ErrnoException | undefined)?.code;
+  return code === "ENOENT" || code === "EACCES" || code === "EPERM";
+}
 
-  const output = await new Promise<{ stdout: string; stderr: string; truncated: boolean }>((resolvePromise, reject) => {
-    const child = spawn("rg", args, {
+async function runRipgrep(
+  command: string,
+  args: string[],
+  cwd: string,
+  signal?: AbortSignal,
+): Promise<RipgrepOutput> {
+  return new Promise<RipgrepOutput>((resolvePromise, reject) => {
+    let settled = false;
+    const child = spawn(command, args, {
       cwd,
       shell: false,
       windowsHide: true,
@@ -581,14 +602,23 @@ export async function searchCodeForTool(
     let stdout = "";
     let stderr = "";
     let truncated = false;
+    const cleanup = () => {
+      clearTimeout(timeout);
+      signal?.removeEventListener("abort", abort);
+    };
+    const rejectOnce = (err: Error) => {
+      if (settled) return;
+      settled = true;
+      cleanup();
+      reject(err);
+    };
     const timeout = setTimeout(() => {
       child.kill();
-      reject(new Error(`search_code timed out after ${SEARCH_TIMEOUT_MS}ms`));
+      rejectOnce(new Error(`search_code timed out after ${SEARCH_TIMEOUT_MS}ms`));
     }, SEARCH_TIMEOUT_MS);
-
     const abort = () => {
       child.kill();
-      reject(new Error("search_code aborted"));
+      rejectOnce(new Error("search_code aborted"));
     };
     signal?.addEventListener("abort", abort, { once: true });
 
@@ -606,14 +636,11 @@ export async function searchCodeForTool(
     child.stderr?.on("data", (chunk: Buffer) => {
       stderr += chunk.toString("utf8");
     });
-    child.on("error", (err) => {
-      clearTimeout(timeout);
-      signal?.removeEventListener("abort", abort);
-      reject(err);
-    });
+    child.on("error", (err) => rejectOnce(err));
     child.on("close", (code) => {
-      clearTimeout(timeout);
-      signal?.removeEventListener("abort", abort);
+      if (settled) return;
+      settled = true;
+      cleanup();
       if (code !== 0 && code !== 1) {
         reject(new Error(stderr.trim() || `rg exited with code ${code}`));
         return;
@@ -621,20 +648,231 @@ export async function searchCodeForTool(
       resolvePromise({ stdout, stderr, truncated });
     });
   });
+}
+
+function expandGlobBraces(pattern: string): string[] {
+  const openIndex = pattern.indexOf("{");
+  if (openIndex < 0) return [pattern];
+  const closeIndex = pattern.indexOf("}", openIndex + 1);
+  if (closeIndex < 0) return [pattern];
+  const alternatives = pattern.slice(openIndex + 1, closeIndex).split(",");
+  if (alternatives.length < 2) return [pattern];
+  return alternatives.flatMap((alternative) => expandGlobBraces(
+    pattern.slice(0, openIndex) + alternative + pattern.slice(closeIndex + 1),
+  ));
+}
+
+function globToRegExp(pattern: string): RegExp {
+  let source = "";
+  for (let index = 0; index < pattern.length; index += 1) {
+    const char = pattern[index];
+    if (char === "*") {
+      if (pattern[index + 1] === "*") {
+        index += 1;
+        if (pattern[index + 1] === "/") {
+          index += 1;
+          source += "(?:.*/)?";
+        } else {
+          source += ".*";
+        }
+      } else {
+        source += "[^/]*";
+      }
+    } else if (char === "?") {
+      source += "[^/]";
+    } else {
+      source += char.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+    }
+  }
+  return new RegExp(`^${source}$`);
+}
+
+function createGlobMatchers(glob: string | undefined): Array<{ regex: RegExp; basenameOnly: boolean }> {
+  if (!glob?.trim()) return [];
+  return expandGlobBraces(glob.trim().replaceAll("\\", "/")).map((pattern) => ({
+    regex: globToRegExp(pattern),
+    basenameOnly: !pattern.includes("/"),
+  }));
+}
+
+function matchesFallbackGlob(
+  filePath: string,
+  searchRoot: string,
+  matchers: Array<{ regex: RegExp; basenameOnly: boolean }>,
+): boolean {
+  if (matchers.length === 0) return true;
+  const relativePath = relative(searchRoot, filePath).split(sep).join("/");
+  return matchers.some(({ regex, basenameOnly }) => regex.test(
+    basenameOnly ? basename(filePath) : relativePath,
+  ));
+}
+
+async function searchCodeWithNode(
+  query: string,
+  searchPath: string,
+  glob: string | undefined,
+  maxResults: number,
+  signal?: AbortSignal,
+): Promise<{ matches: SearchCodeMatch[]; truncated: boolean }> {
+  let queryRegex: RegExp;
+  try {
+    queryRegex = new RegExp(query);
+  } catch (err) {
+    throw new Error(`invalid search regex: ${(err as Error).message}`);
+  }
+
+  const startedAt = Date.now();
+  const matches: SearchCodeMatch[] = [];
+  const rootInfo = await stat(searchPath);
+  const searchRoot = rootInfo.isDirectory() ? searchPath : dirname(searchPath);
+  const globMatchers = createGlobMatchers(glob);
+  let truncated = false;
+  let outputBytes = 0;
+
+  const ensureActive = () => {
+    if (signal?.aborted) throw new Error("search_code aborted");
+    if (Date.now() - startedAt >= SEARCH_TIMEOUT_MS) {
+      throw new Error(`search_code timed out after ${SEARCH_TIMEOUT_MS}ms`);
+    }
+  };
+
+  const searchFile = async (filePath: string) => {
+    if (!matchesFallbackGlob(filePath, searchRoot, globMatchers)) return;
+    ensureActive();
+    const input = createReadStream(filePath, { encoding: "utf8" });
+    const lines = createInterface({ input, crlfDelay: Infinity });
+    let lineNumber = 0;
+    try {
+      for await (const line of lines) {
+        ensureActive();
+        lineNumber += 1;
+        if (line.includes("\0")) break;
+        const match = queryRegex.exec(line);
+        queryRegex.lastIndex = 0;
+        if (!match) continue;
+        const lineBytes = Buffer.byteLength(line, "utf8");
+        if (outputBytes + lineBytes > MAX_SEARCH_BYTES) {
+          truncated = true;
+          break;
+        }
+        outputBytes += lineBytes;
+        matches.push({
+          path: filePath,
+          line: lineNumber,
+          column: match.index + 1,
+          text: line,
+        });
+        if (matches.length >= maxResults) {
+          truncated = true;
+          break;
+        }
+      }
+    } catch (err) {
+      if (signal?.aborted) throw new Error("search_code aborted");
+      const code = (err as NodeJS.ErrnoException | undefined)?.code;
+      if (code !== "EACCES" && code !== "EPERM" && code !== "ENOENT") throw err;
+    } finally {
+      lines.close();
+      input.destroy();
+    }
+  };
+
+  const visit = async (currentPath: string): Promise<void> => {
+    ensureActive();
+    if (truncated) return;
+    let info;
+    try {
+      info = currentPath === searchPath ? rootInfo : await stat(currentPath);
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException | undefined)?.code;
+      if (code === "EACCES" || code === "EPERM" || code === "ENOENT") return;
+      throw err;
+    }
+    if (info.isFile()) {
+      await searchFile(currentPath);
+      return;
+    }
+    if (!info.isDirectory()) return;
+
+    let entries;
+    try {
+      entries = await readdir(currentPath, { withFileTypes: true });
+    } catch (err) {
+      const code = (err as NodeJS.ErrnoException | undefined)?.code;
+      if (code === "EACCES" || code === "EPERM" || code === "ENOENT") return;
+      throw err;
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (truncated) break;
+      if (entry.name.startsWith(".")) continue;
+      if (entry.isDirectory() && FALLBACK_SKIPPED_DIRECTORIES.has(entry.name)) continue;
+      if (entry.isSymbolicLink()) continue;
+      await visit(resolve(currentPath, entry.name));
+    }
+  };
+
+  await visit(searchPath);
+  return { matches, truncated };
+}
+
+export async function searchCodeForTool(
+  cwd: string,
+  input: SearchCodeInput,
+  signal?: AbortSignal,
+  runtimeOptions: SearchCodeRuntimeOptions = {},
+): Promise<SearchCodeOutput> {
+  const query = input.query?.trim();
+  if (!query) throw new Error("query is required");
+  if (signal?.aborted) throw new Error("search_code aborted");
+
+  const searchPath = resolveToolPath(cwd, input.path);
+  const maxResults = Math.min(toPositiveInt(input.maxResults) ?? 50, MAX_SEARCH_RESULTS);
+  const args = [
+    "--line-number",
+    "--column",
+    "--no-heading",
+    "--color",
+    "never",
+    "--max-count",
+    String(maxResults),
+  ];
+  if (input.glob?.trim()) {
+    args.push("--glob", input.glob.trim());
+  }
+  args.push("--", query, searchPath);
+
+  const commands = runtimeOptions.ripgrepCommands ?? defaultRipgrepCommands();
+  let output: RipgrepOutput | undefined;
+  for (const command of commands) {
+    try {
+      output = await runRipgrep(command, args, cwd, signal);
+      break;
+    } catch (err) {
+      if (!isUnavailableExecutableError(err)) throw err;
+    }
+  }
 
-  const matches = output.stdout
-    .split(/\r?\n/)
-    .filter(Boolean)
-    .map(parseRgLine)
-    .filter((match): match is SearchCodeMatch => !!match)
-    .slice(0, maxResults);
+  const fallback = output
+    ? undefined
+    : await searchCodeWithNode(query, searchPath, input.glob?.trim(), maxResults, signal);
+  const matches = output
+    ? output.stdout
+      .split(/\r?\n/)
+      .filter(Boolean)
+      .map(parseRgLine)
+      .filter((match): match is SearchCodeMatch => !!match)
+      .slice(0, maxResults)
+    : fallback!.matches;
 
   return {
     query,
     path: searchPath,
     ...(input.glob?.trim() ? { glob: input.glob.trim() } : {}),
     matches,
-    truncated: output.truncated || matches.length >= maxResults,
+    truncated: output
+      ? output.truncated || matches.length >= maxResults
+      : fallback!.truncated,
   };
 }
 

package/src/cards.ts

@@ -133,11 +133,12 @@ export function buildHelpCard(
     `发送 **/new** 创建新会话（使用 /cd 设置的目录，默认 ${defaultToolLabel}）`,
     "发送 **/new claude** 创建新 Claude 会话",
     "发送 **/new cursor** 创建新 Cursor 会话",
-    "发送 **/new codex** 创建新 Codex 会话",
+    "发送 **/new codex** 创建新 Codex 会话",
+    "发送 **/new ccc** 创建新 CCC Agent 会话",
     "发送 **/newh** 重置当前会话（沿用当前工作目录，不切换）",
     "发送 **/plan** 以规划模式提问（只读，不执行写操作）",
     "发送 **/ask** 以问答模式提问（只读，不执行写操作）",
-    "发送 **/usage** 查看 Codex 实际存在的 5h/7天用量窗口，以及查询/使用主动重置卡",
+    "发送 **/usage** 查看当前 Agent 的用量或余额",
     "发送 **/restart** 重启 ChatCCC 进程",
     "发送 **/update** 更新并重启（仅 npm 全局安装可用）",
     ABD_HELP_LINE,
@@ -152,7 +153,8 @@ export function buildHelpCard(
         { text: `新建默认会话（/new，${defaultToolLabel}）`, value: JSON.stringify({ cmd: "new" }), type: "primary" },
         { text: "新建 Claude 会话（/new claude）", value: JSON.stringify({ cmd: "new claude" }), type: "primary" },
         { text: "新建 Cursor 会话（/new cursor）", value: JSON.stringify({ cmd: "new cursor" }), type: "primary" },
-        { text: "新建 Codex 会话（/new codex）", value: JSON.stringify({ cmd: "new codex" }), type: "primary" },
+        { text: "新建 Codex 会话（/new codex）", value: JSON.stringify({ cmd: "new codex" }), type: "primary" },
+        { text: "新建 CCC Agent 会话（/new ccc）", value: JSON.stringify({ cmd: "new ccc" }), type: "primary" },
         { text: "重启 ChatCCC（/restart）", value: JSON.stringify({ cmd: "restart" }), type: "danger" },
         { text: "更新并重启（/update）", value: JSON.stringify({ cmd: "update" }), type: "danger" },
         { text: "切换工作路径（/cd）", value: JSON.stringify({ cmd: "cd" }), type: "default" },
@@ -344,8 +346,8 @@ export function buildSessionsCard(sessions: Array<{
       header: { template: "blue", title: { content: "所有会话", tag: "plain_text" } },
       elements: [
         { tag: "div", text: { tag: "lark_md", content: fixedPrivateSession
-          ? `当前没有会话记录。\n\n直接发送普通消息即可创建飞书私聊专属 ${defaultToolLabel} 会话；默认 Agent 变化后，下一条普通消息会创建对应 Agent 的新空会话。发送 **/new**、**/new claude**、**/new cursor** 或 **/new codex** 会另外创建会话群。`
-          : `当前没有会话记录。\n\n使用 **/new**（默认 ${defaultToolLabel}）、**/new claude**、**/new cursor** 或 **/new codex** 创建新会话。\n创建后可在任意会话群内发送 **/sessions** 查看列表，用 **/session 数字** 切换会话。` } },
+          ? `当前没有会话记录。\n\n直接发送普通消息即可创建飞书私聊专属 ${defaultToolLabel} 会话；默认 Agent 变化后，下一条普通消息会创建对应 Agent 的新空会话。发送 **/new**、**/new claude**、**/new cursor**、**/new codex** 或 **/new ccc** 会另外创建会话群。`
+          : `当前没有会话记录。\n\n使用 **/new**（默认 ${defaultToolLabel}）、**/new claude**、**/new cursor**、**/new codex** 或 **/new ccc** 创建新会话。\n创建后可在任意会话群内发送 **/sessions** 查看列表，用 **/session 数字** 切换会话。` } },
         { tag: "hr" },
         { tag: "action", actions: [{ tag: "button", text: { tag: "plain_text", content: "收起" }, type: "default", value: { action: "close" } }] },
       ],

package/src/config.ts

@@ -104,12 +104,18 @@ export interface CodexConfig {
 }
 
 export interface CccConfig {
+  /** Whether the built-in CCC Agent is available for new sessions. */
+  enabled: boolean;
+  /** Whether /new without an explicit tool should use CCC Agent. */
+  defaultAgent: boolean;
   /** DeepSeek API Key for the ChatCCC self-developed agent. */
   DEEPSEEK_API_KEY: string;
   /** DeepSeek-compatible API Base URL for the ChatCCC self-developed agent. */
   DEEPSEEK_BASE_URL: string;
   /** Model used by the ChatCCC self-developed agent. */
   model: string;
+  /** Optional model exposed through /model for manual per-session switching. */
+  alternativeModel: string;
 }
 
 export interface FeishuConfig {
@@ -168,8 +174,8 @@ export interface AppConfig {
   ccc: CccConfig;
 }
 
-export type AgentTool = "claude" | "cursor" | "codex";
-export const AGENT_TOOLS: AgentTool[] = ["claude", "cursor", "codex"];
+export type AgentTool = "claude" | "cursor" | "codex" | "ccc";
+export const AGENT_TOOLS: AgentTool[] = ["claude", "cursor", "codex", "ccc"];
 export type CursorAvatarBatteryMode = "apiPercent" | "onDemandUse";
 
 /** 获取指定 agent 配置中所有模型相关的值（最多 100 个，去重） */
@@ -190,6 +196,7 @@ export function getAllModelsForTool(tool: string, cfg: AppConfig = config): stri
     collect(cfg.codex.alternativeModel);
   } else if (tool === "ccc") {
     collect(cfg.ccc.model);
+    collect(cfg.ccc.alternativeModel);
   }
 
   return Array.from(seen).slice(0, 100);
@@ -445,7 +452,14 @@ function loadConfig(): AppConfig {
       onDemandMonthlyBudget: 1000,
     },
     codex: { enabled: false, defaultAgent: false, path: "", model: "", alternativeModel: "", effort: "", fastMode: false },
-    ccc: { DEEPSEEK_API_KEY: "", DEEPSEEK_BASE_URL: DEFAULT_CCC_DEEPSEEK_BASE_URL, model: DEFAULT_CCC_MODEL },
+    ccc: {
+      enabled: false,
+      defaultAgent: false,
+      DEEPSEEK_API_KEY: "",
+      DEEPSEEK_BASE_URL: DEFAULT_CCC_DEEPSEEK_BASE_URL,
+      model: DEFAULT_CCC_MODEL,
+      alternativeModel: "",
+    },
   };
 
   if (!IS_TEST_ENV) {
@@ -498,7 +512,14 @@ function loadConfig(): AppConfig {
       onDemandMonthlyBudget?: unknown;
     };
     codex?: { enabled?: unknown; defaultAgent?: unknown; path?: unknown; command?: unknown; model?: unknown; alternativeModel?: unknown; effort?: unknown; fastMode?: unknown };
-    ccc?: { DEEPSEEK_API_KEY?: unknown; DEEPSEEK_BASE_URL?: unknown; model?: unknown };
+    ccc?: {
+      enabled?: unknown;
+      defaultAgent?: unknown;
+      DEEPSEEK_API_KEY?: unknown;
+      DEEPSEEK_BASE_URL?: unknown;
+      model?: unknown;
+      alternativeModel?: unknown;
+    };
     webUi?: { openOnStart?: unknown };
     chromeDevtools?: { enabled?: unknown; port?: unknown; chromePath?: unknown };
     rawStreamLogs?: unknown;
@@ -553,7 +574,7 @@ function loadConfig(): AppConfig {
       (typeof cursorRaw.model === "string" && (cursorRaw.model as string).trim()) ||
       (typeof cursorRaw.alternativeModel === "string" && (cursorRaw.alternativeModel as string).trim()),
     );
-  const codexNonEmpty = (): boolean =>
+  const codexNonEmpty = (): boolean =>
     Boolean(
       (typeof codexRaw.path === "string" && codexRaw.path.trim()) ||
       (typeof codexRaw.command === "string" && (codexRaw.command as string).trim()) ||
@@ -561,21 +582,28 @@ function loadConfig(): AppConfig {
       (typeof codexRaw.alternativeModel === "string" && (codexRaw.alternativeModel as string).trim()) ||
       (typeof codexRaw.effort === "string" && (codexRaw.effort as string).trim()) ||
       codexRaw.fastMode === true,
-    );
+    );
+  // 旧版 ccc 配置没有 enabled。只用 API Key 推断启用，避免 sample 中自带的
+  // 默认 Base URL / model 让升级用户在未配置凭证时意外启用 CCC Agent。
+  const cccNonEmpty = (): boolean =>
+    Boolean(typeof cccRaw.DEEPSEEK_API_KEY === "string" && cccRaw.DEEPSEEK_API_KEY.trim());
 
   const claudeEnabled = resolveEnabled(claude.enabled, claudeNonEmpty);
   const cursorEnabled = resolveEnabled(cursorRaw.enabled, cursorNonEmpty);
-  const codexEnabled = resolveEnabled(codexRaw.enabled, codexNonEmpty);
+  const codexEnabled = resolveEnabled(codexRaw.enabled, codexNonEmpty);
+  const cccEnabled = resolveEnabled(cccRaw.enabled, cccNonEmpty);
   const chromeDevtoolsPort = Number(chromeDevtoolsRaw.port);
   const explicitDefaultTool: AgentTool | null =
     typeof claude.defaultAgent === "boolean" && claude.defaultAgent && claudeEnabled ? "claude" :
     typeof cursorRaw.defaultAgent === "boolean" && cursorRaw.defaultAgent && cursorEnabled ? "cursor" :
-    typeof codexRaw.defaultAgent === "boolean" && codexRaw.defaultAgent && codexEnabled ? "codex" :
+    typeof codexRaw.defaultAgent === "boolean" && codexRaw.defaultAgent && codexEnabled ? "codex" :
+    typeof cccRaw.defaultAgent === "boolean" && cccRaw.defaultAgent && cccEnabled ? "ccc" :
     null;
   const fallbackDefaultTool: AgentTool =
     claudeEnabled ? "claude" :
     cursorEnabled ? "cursor" :
-    codexEnabled ? "codex" :
+    codexEnabled ? "codex" :
+    cccEnabled ? "ccc" :
     "claude";
   const defaultTool = explicitDefaultTool ?? fallbackDefaultTool;
 
@@ -655,12 +683,15 @@ function loadConfig(): AppConfig {
       fastMode: codexRaw.fastMode === true,
     },
     ccc: {
+      enabled: cccEnabled,
+      defaultAgent: defaultTool === "ccc",
       DEEPSEEK_API_KEY: normalizeOptionalConfigField(cccRaw.DEEPSEEK_API_KEY, { label: "ccc.DEEPSEEK_API_KEY" }),
       DEEPSEEK_BASE_URL: normalizeOptionalConfigField(cccRaw.DEEPSEEK_BASE_URL, {
         label: "ccc.DEEPSEEK_BASE_URL",
         fallback: DEFAULT_CCC_DEEPSEEK_BASE_URL,
       }),
       model: normalizeOptionalConfigField(cccRaw.model, { label: "ccc.model", fallback: DEFAULT_CCC_MODEL }),
+      alternativeModel: normalizeOptionalConfigField(cccRaw.alternativeModel, { label: "ccc.alternativeModel" }),
     },
   };
 }
@@ -981,7 +1012,7 @@ export const CLAUDE_SESSION_PREFIX = "Claude Code Session:";
 export const CURSOR_SESSION_PREFIX = "Cursor Session:";
 /** 群描述中用于识别 Codex 会话的前缀 */
 export const CODEX_SESSION_PREFIX = "Codex Session:";
-/** 群描述中用于识别 hidden ccc agent 会话的前缀 */
+/** 群描述中用于识别 CCC Agent 会话的前缀 */
 export const CCC_SESSION_PREFIX = "CCC Session:";
 
 /** 根据 tool 名称返回对应的群描述前缀 */

package/src/index.ts

@@ -333,6 +333,19 @@ async function processFeishuMessageEvent(data: Evt): Promise<void> {
     if (delayNotice) {
       const delayToken = await getTenantAccessToken();
       await sendCardReply(delayToken, chatId, "延迟送达", delayNotice, "yellow").catch(() => {});
+      // 延迟送达的旧消息只发提醒、不转发给 agent 执行：
+      // 断线重连或补推时，早已过期的消息不应未经确认就触发新任务。
+      // 用户如需执行可自行重发。
+      logTrace(traceId, "DONE", {
+        outcome: "skip_delayed_feishu_message",
+        chatId,
+        msgTimestamp,
+        delayMinutes: Math.floor((Date.now() - msgTimestamp) / 60000),
+      });
+      console.log(
+        `[${ts()}] [SKIP] Delayed Feishu message not forwarded to agent: messageId=${messageId ?? "(missing id)"} chatId=${chatId} createTime=${msgTimestamp}`,
+      );
+      return;
     }
 
     await handleCommand(