aitable-workflow-cli 0.1.13-beta.1

package/templates/support-qa/workflows/daily-review/recipes/daily_review_handler.recipe.ts

@@ -0,0 +1,26 @@
+import type { EventHandlerRecipeDefinition, HandlerInitContext, HandlerInstance } from "aitable-workflow-core";
+
+/** cron tick → 建一条每日复盘工单(实际复盘逻辑在 daily_review step recipe) */
+const recipe: EventHandlerRecipeDefinition = {
+  meta: { id: "daily_review_handler", name: "每日复盘触发器", description: "cron tick → 建一条每日复盘工单" },
+  create(ctx: HandlerInitContext): HandlerInstance {
+    return {
+      onEvent(event) {
+        const firedAt = String(event.payload?.firedAt ?? new Date().toISOString());
+        // cron 事件携带调度时区与预定时刻；按时区取运行日期，避免 UTC 运行环境下标题日期错位
+        const timezone = typeof event.payload?.timezone === "string" ? (event.payload.timezone as string) : "Asia/Shanghai";
+        const scheduledFor = String(event.payload?.scheduledFor ?? firedAt);
+        let dateStr: string;
+        try {
+          dateStr = new Intl.DateTimeFormat("en-CA", { timeZone: timezone, year: "numeric", month: "2-digit", day: "2-digit" }).format(new Date(scheduledFor));
+        } catch {
+          dateStr = scheduledFor.slice(0, 10); // 时区非法时回退
+        }
+        ctx.log(`每日复盘触发 @ ${firedAt} (tz=${timezone}, 运行日=${dateStr})`);
+        ctx.pushEvent({ action: "create_record", fields: { "标题": `每日复盘 ${dateStr}` } });
+      },
+      stop() {},
+    };
+  },
+};
+export default recipe;

package/templates/support-qa/workflows/daily-review/workflow.yml

@@ -0,0 +1,65 @@
+meta:
+  name: "每日复盘"
+  version: "1.0.0"
+  domain: daily_review
+  description: "每日凌晨读取各群昨日短期记忆,coding agent 压缩/统计/需求Bug 抽取,写长期记忆+每日统计表+产品需求池;有活动才留痕(不发群)"
+
+notification:
+  channel: "none"
+
+# ─── 复盘留痕表(每个有活动的复盘日留一行运行记录;table_id 留空 setup 自动建表回写)──
+# ⚠️ 占位:部署前替换为你自己的 base_id/table_id;不可与 group-qa 同表
+tracker:
+  label: "每日复盘留痕表"
+  description: "记录每日复盘运行:日期/处理群数/需求Bug数/摘要"
+  base_id: ""
+  table_id: ""
+  states:
+    initial: "待处理"
+    active: [ "处理中" ]
+    terminal: [ "已完成", "已关闭" ]
+    blocked: "已阻塞"
+  fields:
+    state: "状态"
+    title: "标题"
+    current_step: "当前步骤"
+    event_log: "事件日志"
+  field_definitions:
+    - name: 复盘日期
+      type: text
+    - name: 处理群数
+      type: text
+    - name: 需求Bug数
+      type: text
+    - name: 摘要
+      type: text
+  views:
+    - id: default_grid
+      type: Grid
+      name: 表格
+      field_order: [ 标题, 复盘日期, 处理群数, 需求Bug数, 摘要, 状态, 当前步骤, 事件日志 ]
+      description: 每日复盘留痕
+
+# ─── 事件源：cron 每日触发,on_demand(无活动不建行)──
+event_sources:
+  - name: 每日复盘调度
+    type: cron_scheduler
+    handler: daily_review_handler
+    record_policy: on_demand
+
+steps:
+  - id: daily_review
+    name: "每日复盘"
+    recipe: daily_review
+    auto: true
+    output_mapping:
+      review_date: "复盘日期"
+      group_count: "处理群数"
+      needs_bug_count: "需求Bug数"
+      summary: "摘要"
+
+edges:
+  - from: __start__
+    to: daily_review
+  - from: daily_review
+    to: __end__

package/templates/support-qa/workflows/group-qa/recipes/answer.recipe.ts

@@ -0,0 +1,223 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import type { RecipeDefinition, RecipeContext, RecipeResult } from "aitable-workflow-core";
+import { contractPromptBlock, extractSupportReply, type SupportReply } from "../../../lib/contract.js";
+import { profileAssembleGuard } from "../../../lib/profile-guard.js";
+import { SUPPORT_DECISION_CONTENT, SUPPORT_MEMORY_KINDS, SUPPORT_MEMORY_ROLES, questionKey, supportEntry, supportScope } from "../../../lib/memory-events.js";
+
+/**
+ * 单 agent 应答（support-qa L0）
+ *
+ * 一次 coding.run 让 agent 依据知识库 + 近期对话上下文，按契约返回严格 JSON：
+ *   { action, reason, reply?, module? }（契约单一事实源见 lib/contract.ts）
+ *
+ * 拍平 action 契约（spec 2026-07-28）：
+ *   1. 单一 action 取代 shouldReply + silenceCode 的组合歧义（Bug/Feature 不再坠入 kb_gap）；
+ *   2. agent 失败/解析失败先重试 1 次，仍失败 → action=agent_failure 且写短期记忆
+ *      （故障与"判定型静默"分开审计，绝不混入 kb_gap 知识待办）；
+ *   3. 追问补位闸门参数（profile gates.standby）动态注入 prompt；
+ *   4. 本步对静默类 action 一律 tracker:false —— 留痕与否由下游 on_action 按 profile 裁决。
+ */
+
+const MAX_AGENT_ATTEMPTS = 2; // 1 次正常 + 1 次重试
+
+async function runAgentOnce(
+  ctx: RecipeContext,
+  prompt: string,
+  workDir: string,
+): Promise<SupportReply | null> {
+  const result = await ctx.toolkit.coding.run(prompt, { workDir });
+  if (!result.response) return null;
+  return extractSupportReply(result.response);
+}
+
+const recipe: RecipeDefinition = {
+  meta: {
+    id: "answer",
+    name: "单 agent 应答",
+    role: "support",
+    description: "一次 agent 调用产出契约 JSON（action/reason/reply/module）",
+    version: "1.0.0",
+    requiresAgent: true,
+    timeoutMs: 420_000,
+    config: z.object({
+      coding: z.object({ engine: z.string().optional() }).optional(),
+      standby: z.object({
+        enabled: z.boolean().describe("是否启用追问补位"),
+        wait_minutes: z.number().describe("等待时间（分钟）"),
+      }).optional().describe("追问补位（L3）：用户 @真人后超时无人回且用户追问时放行"),
+    }),
+  },
+
+  async execute(ctx: RecipeContext): Promise<RecipeResult> {
+    const { input, toolkit, log } = ctx;
+    const content = String(input.content ?? "");
+    const context = String(input.context ?? "").trim();
+    const senderName = String(input.senderName ?? "").trim();
+    const priorAction = String(input.action ?? "").trim();
+    const conversationId = String(input.conversationId ?? "").trim();
+
+    // 上游 Recipe（fastpath/troubleshoot 等 L3 包）已产出 action → 透传
+    if (priorAction) {
+      log(`已由上游 Recipe 处理(action=${priorAction})，answer 跳过`);
+      return { status: "success", output: {}, tracker: false, logs: [`透传：${priorAction}`] };
+    }
+
+    if (!content.trim()) {
+      return {
+        status: "success",
+        output: { action: "no_question", module: "", answer: "", reason: "空消息" },
+        tracker: false,
+        logs: ["空消息 → 静默"],
+      };
+    }
+
+    // 装配前置（评审 P1/P3）：校验+装配 profile 产物；校验失败则阻断作答（agent_failure
+    // 静默留痕，运营可见），绝不带着错误/降级的 profile 继续调 agent 。同一闸门也前置在
+    // fastpath/troubleshoot（见 lib/profile-guard.ts），确保 L3 直出路径不绕过校验。
+    // 正式入口是 `npm run assemble`（写盘）/ `npm run check`（preflight）。
+    const guard = profileAssembleGuard(ctx, log);
+    if (guard) return guard;
+    const roleId = ctx.roleContext?.id?.trim() || "support";
+    const workDir = path.resolve(ctx.configDir, "workspaces", roleId);
+
+    // ─── 长期记忆注入（写入工作目录供 agent 按需 Read/Grep，仅辅助上下文） ───
+    let memSection = "";
+    try {
+      const longTerm = await toolkit.memory.readLongTerm(supportScope()).catch(() => "");
+      if (longTerm && longTerm.trim()) {
+        fs.mkdirSync(workDir, { recursive: true });
+        fs.writeFileSync(path.join(workDir, ".long-term.md"), longTerm, "utf8");
+        memSection = `\n## 长期记忆（可用，仅作辅助上下文，不作事实依据）
+- 近期群聊复盘沉淀的高频问题与趋势已写入工作目录下的 .long-term.md，可按需 Read/Grep 搜索以理解语境；一切事实依据仍只能来自知识库，不得据此作答。\n`;
+        log(`已写入长期记忆到 ${path.join(workDir, ".long-term.md")} (${longTerm.length} 字符)`);
+      }
+    } catch (err) {
+      log(`写入长期记忆失败(不影响主流程): ${err}`);
+    }
+
+    // ─── 追问补位闸门参数（profile 驱动，动态注入；AGENTS.md 含规则正文） ───
+    const sbCfg = ctx.config.standby as { enabled?: boolean; wait_minutes?: number } | undefined;
+    const standby = { enabled: sbCfg?.enabled ?? false, waitMinutes: sbCfg?.wait_minutes ?? 30 };
+    const standbyNote = standby.enabled
+      ? `\n**追问补位参数**：本实例已启用"@真人未响应补位"（闸门规则 7）：用户 @过真人负责人、且距该消息已超过 ${standby.waitMinutes} 分钟（依据对话历史 [hh:mm] 时间戳判断）、真人未回复、当前消息是用户对同一问题的追问 → 允许回答，reply 开头用一句补位语气（如"看到相关同学暂时没回，先提供帮助文档里的信息："）。\n`
+      : "\n**追问补位参数**：本实例未启用补位（闸门规则 7 不适用，用户 @真人后一律礼让静默）。\n";
+
+    const hasImage = /!\[图片\]\([^)]+\)/.test(content);
+    const imageNote = hasImage
+      ? "\n**本条消息包含图片**（已内联为 `![图片](路径)`）：请先用 Read 打开该图片，结合图片内容（多为报错截图/操作截图）理解用户的真实问题后再作答。\n"
+      : "";
+
+    // 前置拦截（非法 module 根治）：把 owner-map 的合法模块清单直接写进契约 prompt，
+    // 解析后再做出口校验——清单外的 module 在 producer 就地置空，不流入 on_action。
+    let moduleKeys: string[] = [];
+    try {
+      const ownerMap = JSON.parse(fs.readFileSync(path.join(workDir, "owner-map.json"), "utf8")) as Record<string, unknown>;
+      if (ownerMap && typeof ownerMap === "object" && !Array.isArray(ownerMap)) moduleKeys = Object.keys(ownerMap);
+    } catch {
+      // owner-map 缺失（无转人工配置）→ 退回通用契约描述，不阻断主流程
+    }
+
+    const assistantName = ctx.roleContext?.name ?? "答疑助手";
+    const prompt = `开始处理前，必须先使用 Read 读取并完整遵循本工作目录下的 AGENTS.md，将其作为本次答疑的完整业务执行规范。
+
+你是「${assistantName}」。用户在钉钉群中发出了以下消息，请按 AGENTS.md 的闸门规则先判定是否需要回复，再基于知识库为用户提供准确解答。
+
+在对话历史中，标记为"(答疑机器人/即你自己之前的回复)"的消息就是你之前发出的回复；标记为"(真人同事)"的是真人值班同事。
+${memSection}${standbyNote}
+${contractPromptBlock(moduleKeys)}
+
+示例（仅用于说明格式，内容请按用户的真实问题作答）：
+{"action":"reply","reason":"知识库有据","reply":"Hi 小明，单表上限 20 万行。\\n\\n> 来源:https://example.com/xxx"}
+{"action":"no_question","reason":"用户表示感谢，非有效提问"}
+{"action":"kb_gap","reason":"普通资源咨询，知识库无据"}
+{"action":"bug","module":"数据源","reason":"确认是异常但文档无明确结论","reply":"Hi 小明，当前能确认的是……；你描述的现象还需要进一步排查。"}
+
+要求：
+1. reply 开头先用「Hi ${senderName || "用户"}，」打招呼，然后直接给出解答内容，不要寒暄复述。
+2. 引用出处按 AGENTS.md 的来源规则附在 reply 末尾。
+${context ? `\n${context}\n` : ""}
+${imageNote}用户消息（发送者：${senderName || "未知"}）：
+${content}`;
+
+    log(`answer prompt 就绪（workDir=${workDir}）: ${content.slice(0, 60)}`);
+
+    // ─── 执行（失败重试 1 次；G9） ───
+    let decision: SupportReply | null = null;
+    for (let attempt = 1; attempt <= MAX_AGENT_ATTEMPTS && !decision; attempt++) {
+      if (attempt > 1) log(`agent 无有效响应/解析失败，重试第 ${attempt - 1} 次`);
+      decision = await runAgentOnce(ctx, prompt, workDir);
+    }
+
+    if (!decision) {
+      log("agent 重试后仍失败 → agent_failure 兜底静默（写记忆，交 on_action 处置）");
+      if (conversationId) {
+        void toolkit.memory.append(
+          supportScope(conversationId),
+          supportEntry({
+            kind: SUPPORT_MEMORY_KINDS.agentFailure,
+            content: content.slice(0, 200),
+            sender: "agent",
+            role: SUPPORT_MEMORY_ROLES.agent,
+            conversationId,
+            summary: `agent 失败兜底静默: ${content.slice(0, 80)}`,
+            meta: { action: "agent_failure", attempts: MAX_AGENT_ATTEMPTS, question: questionKey(content) },
+          }),
+        ).catch((err) => log(`memory.append(agent_failure) 失败(不影响主流程): ${err}`));
+      }
+      return {
+        status: "success",
+        output: { action: "agent_failure", module: "", answer: "", reason: "agent 重试后仍无有效响应" },
+        tracker: false, // 留痕与否由 on_action 按 profile 裁决
+        logs: ["agent_failure → 交 on_action 处置"],
+      };
+    }
+
+    const action = decision.action;
+    const isReplyBearing = action === "reply" || action === "bug" || action === "feature";
+    const reason = String(decision.reason ?? "");
+    const reply = String(decision.reply ?? "");
+    let module = String(decision.module ?? "");
+    // 出口校验：清单外的 module 视同未给出（on_action 会走降级发送，不会拿非法 key 去查 Owner）
+    if (module && moduleKeys.length > 0 && !moduleKeys.includes(module)) {
+      log(`invalid_module_stripped: 「${module}」不在 owner-map 清单中，已置空`);
+      module = "";
+    }
+
+    const output: Record<string, unknown> = {
+      action,
+      module,
+      reason,
+      answer: isReplyBearing ? reply : "",
+    };
+
+    // 决策写短期记忆（发送事实由 reply-to-group 在发送成功后另记）
+    if (conversationId) {
+      void toolkit.memory.append(
+        supportScope(conversationId),
+        supportEntry({
+          kind: SUPPORT_MEMORY_KINDS.agentDecision,
+          // 正文只记占位：话术真相在发送事实（agent_reply_sent/owner_escalation_sent），不在决策里存半成品副本
+          content: isReplyBearing ? SUPPORT_DECISION_CONTENT.reply : SUPPORT_DECISION_CONTENT.silent,
+          sender: "agent",
+          role: SUPPORT_MEMORY_ROLES.agent,
+          conversationId,
+          summary: `答疑决策: ${action}${module ? `[${module}]` : ""}${reason ? ` - ${reason.slice(0, 80)}` : ""}`,
+          meta: { action, module, reason, question: questionKey(content) },
+        }),
+      ).catch((err) => log(`memory.append(agent_decision) 失败(不影响主流程): ${err}`));
+    }
+
+    log(`决策: ${action}${module ? `[${module}]` : ""}${reason ? `（${reason}）` : ""}`);
+    return {
+      status: "success",
+      output,
+      // reply/bug/feature → 建行留痕；静默类 → 本步不表态（tracker:false），由 on_action 按 profile 裁决
+      ...(isReplyBearing ? {} : { tracker: false }),
+      logs: [`决策 ${action}`, reason].filter(Boolean),
+    };
+  },
+};
+
+export default recipe;

package/templates/support-qa/workflows/group-qa/recipes/conversation_handler.recipe.ts

@@ -0,0 +1,269 @@
+import type {
+  EventContext,
+  EventHandlerRecipeDefinition,
+  HandlerInitContext,
+  HandlerInstance,
+} from "aitable-workflow-core";
+import {
+  resolveDingTalkStreamMessageEventContext,
+  resolveDingTalkWebhookMentionEventContext,
+  resolveGlobalVarRef,
+} from "aitable-workflow-core";
+import { z } from "zod";
+import { SUPPORT_MEMORY_KINDS, SUPPORT_MEMORY_ROLES, supportEntry, supportScope } from "../../../lib/memory-events.js";
+import { isRecentOutboundEcho } from "../../../lib/echo-guard.js";
+
+/**
+ * 会话消息处理器（support-qa L0）
+ *
+ * 事件源只产出统一的 message_received。本 handler 是长活单例：
+ *   - onEvent 纯同步（无长 await）：回声过滤 → 摄入本轮消息 + 构建「近期对话上下文」→ pushEvent 建单。
+ *   - 内存里按 conversationId 维护近期消息环形缓冲（容量/TTL 限制，重启清空）。
+ *
+ * 与 aitable-handoff 版的三处 Pattern 级差异：
+ *   1. 出站回声防护：reply 发布的内容指纹命中 → 按机器人消息处理（只记历史不建单），
+ *      防 webhook 回复以真人名义回流造成自激（评测硬用例 G1）。
+ *   2. 管理员/真人同事消息写入短期记忆（role=admin）：学习通道（daily-review 提炼
+ *      「提问→真人解答」）的原料，不建单不回复但必须留原料（勿删）。
+ *   3. 历史消息带时间戳注入上下文：追问补位闸门（gates.standby）需要"@Owner 后已等多久"。
+ *
+ * 名单来源（均为 globalVar 引用，config-sync L2 装包后发布；未装包时为空集不影响 L0）：
+ *   - conversation_ids → 群配置（[{groupId, botNick}]）：识别机器人自身消息
+ *   - admins           → 真人同事名单（[{nick, openDingTalkId}] 或 ["花名"]）
+ */
+
+const HISTORY_CAPACITY = 20;
+const HISTORY_TTL_MS = 30 * 60 * 1000;
+const IMAGE_MARK = "![图片]";
+const CONFIG_CACHE_TTL_MS = 30 * 1000;
+
+type HistoryEntry = { sender: string; openId: string; content: string; ts: number };
+type IdentitySets = { ids: Set<string>; nicks: Set<string> };
+type GroupRuntimeConfig = {
+  identity: IdentitySets;
+  outbound: string;
+};
+
+function parseNicks(raw: unknown): Set<string> {
+  const arr = Array.isArray(raw) ? raw.map(String) : String(raw ?? "").split(/[,，]/);
+  return new Set(arr.map((s) => s.trim()).filter(Boolean));
+}
+
+/** 先按 openDingTalkId 精确匹配，匹配不到再用花名兜底 */
+function matchesIdentity(sets: IdentitySets, sender: string, openId: string): boolean {
+  if (openId && sets.ids.has(openId)) return true;
+  return !!sender && sets.nicks.has(sender);
+}
+
+function loadGroupBots(list: unknown): Map<string, GroupRuntimeConfig> {
+  const map = new Map<string, GroupRuntimeConfig>();
+  for (const g of Array.isArray(list) ? list : []) {
+    if (!g || typeof g !== "object") continue;
+    const rec = g as Record<string, unknown>;
+    const gid = String(rec.groupId ?? "").trim();
+    if (gid) {
+      map.set(gid, {
+        identity: { ids: new Set(), nicks: parseNicks(rec.botNick) },
+        outbound: String(rec.outbound ?? "").trim(),
+      });
+    }
+  }
+  return map;
+}
+
+function loadAdmins(list: unknown): IdentitySets {
+  const ids = new Set<string>();
+  const nicks = new Set<string>();
+  for (const e of Array.isArray(list) ? list : []) {
+    if (typeof e === "string") {
+      const nick = e.trim();
+      if (nick) nicks.add(nick);
+    } else if (e && typeof e === "object") {
+      const rec = e as Record<string, unknown>;
+      const nick = String(rec.nick ?? "").trim();
+      const openId = String(rec.openDingTalkId ?? "").trim();
+      if (nick) nicks.add(nick);
+      if (openId) ids.add(openId);
+    }
+  }
+  return { ids, nicks };
+}
+
+function roleTag(sender: string, openId: string, botSets: IdentitySets, adminSets: IdentitySets): string {
+  if (matchesIdentity(botSets, sender, openId)) return "(答疑机器人/即你自己之前的回复)";
+  if (matchesIdentity(adminSets, sender, openId)) return "(真人同事)";
+  return "";
+}
+
+/** 历史时间戳格式：闸门（追问补位）据此计算等待时长 */
+function formatTs(ts: number): string {
+  const d = new Date(ts);
+  const pad = (n: number) => String(n).padStart(2, "0");
+  return `${pad(d.getHours())}:${pad(d.getMinutes())}`;
+}
+
+function ttlCached<T>(loader: () => T, ttlMs: number): () => T {
+  let cache: T | null = null;
+  let loadedAt = 0;
+  return () => {
+    const now = Date.now();
+    if (cache === null || now - loadedAt > ttlMs) {
+      cache = loader();
+      loadedAt = now;
+    }
+    return cache;
+  };
+}
+
+const recipe: EventHandlerRecipeDefinition = {
+  meta: {
+    id: "conversation_handler",
+    name: "会话消息处理器",
+    description: "message_received → 回声过滤 → 构建近期对话上下文 → 创建工单",
+    config: z.object({
+      conversation_ids: z
+        .string()
+        .optional()
+        .describe("群配置来源（globalVar 引用，默认 ${globalVar.group_configs}，形如 [{groupId, botNick}]）：识别每群机器人身份"),
+      admins: z
+        .string()
+        .optional()
+        .describe("真人同事名单来源（globalVar 引用，默认 ${globalVar.admins}，形如 [{nick, openDingTalkId}] 或 [\"花名\"]）"),
+    }),
+  },
+
+  create(ctx: HandlerInitContext): HandlerInstance {
+    const histories = new Map<string, HistoryEntry[]>();
+    const emptySets: IdentitySets = { ids: new Set(), nicks: new Set() };
+    const groupsRef = String(ctx.config.conversation_ids ?? "${globalVar.group_configs}");
+    const adminsRef = String(ctx.config.admins ?? "${globalVar.admins}");
+    const getAdmins = ttlCached(
+      () => loadAdmins(resolveGlobalVarRef(adminsRef, ctx.getGlobalVar)),
+      CONFIG_CACHE_TTL_MS,
+    );
+    const getGroupBots = ttlCached(
+      () => loadGroupBots(resolveGlobalVarRef(groupsRef, ctx.getGlobalVar)),
+      CONFIG_CACHE_TTL_MS,
+    );
+
+    return {
+      onEvent(event) {
+        const payload = event.payload;
+        const content = String(payload.content ?? "");
+        const hasImage = content.includes(IMAGE_MARK);
+        if (!content.trim() && !hasImage) {
+          ctx.log("消息内容为空且无图片，跳过(不 push)");
+          return;
+        }
+
+        const senderName = String(payload.senderName ?? payload.sender ?? payload.firstSender ?? "");
+        const senderOpenId = String(payload.senderOpenDingTalkId ?? "").trim();
+        const messageId = String(payload.messageId ?? "");
+        const sendTime = String(payload.firstSendTime ?? new Date().toISOString());
+        const conversationId = String(payload.conversationId ?? "");
+        const now = Date.parse(sendTime) || Date.now();
+        const adminSets = getAdmins();
+        const groupConfig = getGroupBots().get(conversationId);
+        const botSets = groupConfig?.identity ?? emptySets;
+        // 出站回声：webhook 回复以真人名义回流时身份匹配失效，用内容指纹兜底（G1）
+        const isEcho = isRecentOutboundEcho(ctx.getGlobalVar, content);
+        const isBot = isEcho || matchesIdentity(botSets, senderName, senderOpenId);
+        const isAdmin = !isBot && matchesIdentity(adminSets, senderName, senderOpenId);
+
+        // 1) 取该群历史，裁剪过期，构建「当前之前」的对话上下文（带角色标记 + 时间戳）
+        const prior = (histories.get(conversationId) ?? []).filter((e) => now - e.ts <= HISTORY_TTL_MS);
+        const contextText =
+          prior.length > 0
+            ? [
+                "以下是群聊中近期的对话历史(帮助理解当前问题的上下文，如追问、反馈、是否已被同事接手；[hh:mm] 为发送时间，供判断等待时长):",
+                "---",
+                ...prior.map((e, i) => `[历史消息 ${i + 1}][${formatTs(e.ts)}] ${e.sender}${roleTag(e.sender, e.openId, botSets, adminSets)}: ${e.content}`),
+                "---",
+              ].join("\n")
+            : "";
+
+        // 2) 追加当前消息到历史并按容量裁剪（机器人/真人同事消息也入历史，作为后续上下文）
+        prior.push({ sender: senderName, openId: senderOpenId, content, ts: now });
+        while (prior.length > HISTORY_CAPACITY) prior.shift();
+        histories.set(conversationId, prior);
+
+        // 机器人自己的消息（含回声）只记录进历史，不建单
+        if (isBot) {
+          ctx.log(`机器人消息${isEcho ? "(出站回声)" : ""}，仅记录进历史不建单: ${senderName}`);
+          return;
+        }
+
+        // 真人同事/管理员消息：不建单不回复，但必须写短期记忆（学习通道原料）
+        if (isAdmin) {
+          ctx.log(`真人同事消息，记历史+记忆不建单: ${senderName}`);
+          void ctx.toolkit.memory.append(supportScope(conversationId), supportEntry({
+            timestamp: sendTime,
+            kind: SUPPORT_MEMORY_KINDS.adminMessage,
+            content,
+            sender: senderName,
+            role: SUPPORT_MEMORY_ROLES.admin,
+            conversationId,
+            meta: { messageId, hasImage },
+          })).catch((err) => ctx.log(`memory.append(admin_message) 失败(不影响主流程): ${err}`));
+          return;
+        }
+
+        ctx.log(`处理群消息: 来自 ${senderName}${hasImage ? "(含图片)" : ""}, 历史 ${prior.length - 1} 条`);
+
+        let eventContext: EventContext | undefined;
+        const replyCtx = (payload.dingtalk ?? {}) as Record<string, unknown>;
+        if (groupConfig?.outbound === "webhook") {
+          // 自定义机器人 Webhook 的 @人身份只跟随本次瞬态 WorkItem，不写入 Tracker。
+          // 任一字段缺失时不附加上下文，消费端会正常发送但不 @ 人。
+          eventContext = resolveDingTalkWebhookMentionEventContext({
+            type: "dingtalk_webhook_mention",
+            conversationId,
+            senderOpenDingTalkId: senderOpenId,
+            senderName,
+          });
+        } else if (replyCtx.credRef) {
+          // Stream 入站 + 会话内（session）出站：透传机器人身份（credRef/robotCode/openMsgId），
+          // 供 reply 步骤解析对应机器人凭据并用 sessionWebhook 会话内回复；缺字段时返回 undefined 降级。
+          eventContext = resolveDingTalkStreamMessageEventContext({
+            type: "dingtalk_stream_message",
+            openMsgId: String(replyCtx.openMsgId ?? ""),
+            conversationId,
+            robotCode: String(replyCtx.robotCode ?? ""),
+            credRef: String(replyCtx.credRef ?? ""),
+          });
+        }
+        if (eventContext?.type === "dingtalk_stream_message") {
+          ctx.toolkit.messaging?.beginDingTalkProcessingFeedback?.(eventContext);
+        }
+
+        ctx.pushEvent({
+          action: "create_record",
+          fields: {
+            "消息内容": content,
+            "发送人": senderName,
+            "发送时间": sendTime,
+            "群ID": conversationId,
+            "对话上下文": contextText,
+          },
+          ...(eventContext ? { eventContext } : {}),
+        });
+
+        // 短期记忆：普通用户消息（fire-and-forget，不阻塞 onEvent）
+        void ctx.toolkit.memory.append(supportScope(conversationId), supportEntry({
+          timestamp: sendTime,
+          kind: SUPPORT_MEMORY_KINDS.userMessage,
+          content,
+          sender: senderName,
+          role: SUPPORT_MEMORY_ROLES.user,
+          conversationId,
+          meta: { messageId, hasImage },
+        })).catch((err) => ctx.log(`memory.append(user_message) 失败(不影响主流程): ${err}`));
+      },
+      stop() {
+        histories.clear();
+      },
+    };
+  },
+};
+
+export default recipe;

package/templates/support-qa/workflows/group-qa/recipes/fastpath.recipe.ts

@@ -0,0 +1,78 @@
+import { z } from "zod";
+import type { RecipeDefinition, RecipeContext, RecipeResult } from "aitable-workflow-core";
+import { profileAssembleGuard } from "../../../lib/profile-guard.js";
+import { loadFastpathRules, matchFastpath } from "../../../lib/fastpath.js";
+
+/**
+ * fastpath 确定性秒回（support-qa L3，group-qa 首步，非 LLM）
+ *
+ * 按 profile/fastpath/known-answers.yml 的声明式规则（template/contains/regex + 安全兜底）
+ * 单向匹配当前消息，命中即产出「已知错误」类别的固定话术，下游 answer 透传、reply_to_group 发送。
+ *
+ * 关闭/透传语义：
+ *   - profile.fastpath.rules 未配置或文件缺失 → 透传（本步不表态，tracker:false）；
+ *   - 空消息 / 上游已定类 → 透传；
+ *   - 未命中任何规则 → 透传给 answer 走语义答疑（语义匹配不属于 fastpath）。
+ *
+ * 命中即建行：本步返回 output（含 answer）且不置 tracker:false，on_demand 下建行留痕
+ * （与 aitable-handoff 已知错误秒回一致）。
+ */
+const recipe: RecipeDefinition = {
+  meta: {
+    id: "fastpath",
+    name: "确定性秒回",
+    role: "support",
+    description: "声明式规则（template/contains/regex + 安全兜底）单向匹配秒回，非 LLM",
+    version: "1.0.0",
+    requiresAgent: false,
+    timeoutMs: 10_000,
+    config: z.object({
+      rules: z.string().optional().describe("确定性秒回规则文件路径（相对 profile 目录）；省略即关闭 fastpath"),
+    }),
+  },
+
+  async execute(ctx: RecipeContext): Promise<RecipeResult> {
+    const { input, log } = ctx;
+    const content = String(input.content ?? "");
+    const senderName = String(input.senderName ?? "").trim();
+    const priorAction = String(input.action ?? "").trim();
+
+    // 上游已产出 action（fastpath 通常是首步，此处为防御）→ 透传
+    if (priorAction) {
+      return { status: "success", output: {}, tracker: false, logs: [`透传：${priorAction}`] };
+    }
+    if (!content.trim()) {
+      return { status: "success", output: {}, tracker: false, logs: ["空消息，透传"] };
+    }
+
+    // 装配闸门前置（评审 P1）：fastpath 命中即直出固定话术并让 answer 跳过，故 profile
+    // 装配错误时也必须阻断（与 answer 一致），不得带病秒回。
+    const guard = profileAssembleGuard(ctx, log);
+    if (guard) return guard;
+
+    const { config, issues } = loadFastpathRules(ctx.configDir, ctx.config.rules);
+    for (const i of issues) log(`[fastpath] ${i}`);
+    if (!config) {
+      // 未配置/文件缺失 → fastpath 关闭，透传 answer
+      return { status: "success", output: {}, tracker: false, logs: ["fastpath 未启用，透传"] };
+    }
+
+    const match = matchFastpath(config, content);
+    if (!match) {
+      log("未命中 fastpath 规则，交给 answer");
+      return { status: "success", output: {}, tracker: false, logs: ["未命中 fastpath"] };
+    }
+
+    const greeting = senderName ? `Hi ${senderName}，` : "";
+    const answer = `${greeting}${match.reply}`;
+    log(`命中 fastpath 规则 [${match.key}]（${match.kind}），秒回`);
+    return {
+      status: "success",
+      // action=reply：下游 on_action 按 answer 策略透传，reply_to_group 沿用 @提问者
+      output: { action: "reply", answer },
+      logs: [`fastpath 命中 ${match.key}(${match.kind})`],
+    };
+  },
+};
+
+export default recipe;