aitable-workflow-cli 0.1.13-beta.1

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

@@ -0,0 +1,667 @@
+import fs from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import { type RecipeDefinition, type RecipeContext, type RecipeResult, type TableRef, tableRefConfigSchema, type MemoryScope, type MemoryEntry, isGlobalVarRef, resolveGlobalVarRef } from "aitable-workflow-core";
+import { SUPPORT_MEMORY_KINDS, questionKey, supportScope } from "../../../lib/memory-events.js";
+import { KB_STATUS } from "../../../lib/contract.js";
+
+/**
+ * 每日复盘 Step Recipe（记忆叠加版）
+ *
+ * cron_scheduler 每日凌晨触发(on_demand) → 读取昨日短期记忆 → coding.run 压缩+统计+抽取
+ * → memory.compact 写共享长期记忆 → table.upsertRecordIn 写每日统计表
+ * → table.createRecordsIn 写产品需求池。
+ *
+ * 无活动(各群昨日无短期记忆)→ 返回 tracker:false,on_demand 下不建复盘留痕行。
+ *
+ * 短期记忆按群隔离（含 conversationId），长期记忆产品级共享（不含 conversationId）。
+ * coding.run 用 workspaces/daily-review/AGENTS.md 承载全部压缩/统计/抽取规范。
+ * 各群消息不内联进 prompt（单群 500 条可达数百 KB，会打爆 agent），而是落盘到工作目录下
+ * .today/<序号>-<群ID>.md，prompt 只给文件清单让 agent 自行 Read；coding.run 结束即删除。
+ *
+ * 群列表适配：aitable-handoff 的群是动态的，由 config-sync 发布到 globalVar(group_configs)。
+ * step.config.conversation_ids 二选一：静态数组，或引用 ${globalVar.group_configs}（无隐式回退）。
+ */
+
+// ─── 配置解析 ──────────────────────────────────────────
+
+interface ReviewConfig {
+  /** 复盘群来源：静态字符串数组，或 "${globalVar.group_configs}" 引用（运行期解析） */
+  conversationIds: unknown;
+  dailyStatsTable: TableRef | null;
+  productBacklogTable: TableRef | null;
+  /** 学习候选写入表（= group-qa 群问答表，reference 模式，用户填 base/table） */
+  learningCandidateTable: TableRef | null;
+  savedMinutesPerReply: number;
+  /** 复盘日期计算时区（IANA），应与 cron 的 timezone 一致；默认 Asia/Shanghai */
+  timezone: string;
+}
+
+function isTableRefConfigured(raw: unknown): raw is { baseId: string; tableId: string } {
+  return !!raw && typeof raw === "object" && typeof (raw as Record<string, unknown>).baseId === "string" && typeof (raw as Record<string, unknown>).tableId === "string";
+}
+
+/** reference 模式表：要求 baseId 与 tableId 均非空（空 = 未配置，跳过而非误写） */
+function configuredTableRef(raw: unknown): TableRef | null {
+  if (!raw || typeof raw !== "object") return null;
+  const baseId = String((raw as Record<string, unknown>).baseId ?? "").trim();
+  const tableId = String((raw as Record<string, unknown>).tableId ?? "").trim();
+  return baseId && tableId ? { baseId, tableId } : null;
+}
+
+function parseConfig(raw: Record<string, unknown>): ReviewConfig {
+  const dst = raw.daily_stats_table as { baseId?: string; tableId?: string } | undefined;
+  const pbt = raw.product_backlog_table as { baseId?: string; tableId?: string } | undefined;
+  const saved = typeof raw.saved_minutes_per_reply === "number" ? raw.saved_minutes_per_reply : 15;
+
+  return {
+    conversationIds: raw.conversation_ids,
+    dailyStatsTable: isTableRefConfigured(dst) ? { baseId: dst.baseId, tableId: dst.tableId } : null,
+    productBacklogTable: isTableRefConfigured(pbt) ? { baseId: pbt.baseId, tableId: pbt.tableId } : null,
+    learningCandidateTable: configuredTableRef(raw.learning_candidate_table),
+    savedMinutesPerReply: saved,
+    timezone: normalizeTimezone(typeof raw.timezone === "string" ? raw.timezone : undefined),
+  };
+}
+
+/** 校验 IANA 时区，非法/缺省回退 Asia/Shanghai（与 cron 默认一致） */
+function normalizeTimezone(raw: string | undefined): string {
+  const candidate = raw?.trim();
+  if (!candidate) return "Asia/Shanghai";
+  try {
+    new Intl.DateTimeFormat("en-US", { timeZone: candidate }).format(new Date());
+    return candidate;
+  } catch {
+    return "Asia/Shanghai";
+  }
+}
+
+/**
+ * 解析复盘群列表：显式二选一，无隐式回退。
+ * - 静态字符串数组 → 直接用
+ * - "${globalVar.group_configs}" 引用 → 活读并抽取 groupId（支持 [{groupId}] / ["cid"]）
+ */
+function resolveConversationIds(raw: unknown, get: (path: string) => unknown): string[] {
+  if (isGlobalVarRef(raw)) return extractGroupIds(resolveGlobalVarRef(raw, get));
+  if (Array.isArray(raw)) return raw.map((s) => String(s).trim()).filter(Boolean);
+  return [];
+}
+
+/** 从群配置数组抽取 groupId（[{groupId}] 或 ["cid"]）；非数组/空 → 空数组 */
+function extractGroupIds(list: unknown): string[] {
+  if (!Array.isArray(list)) return [];
+  return list
+    .map((g) => (typeof g === "string" ? g : g && typeof g === "object" ? String((g as Record<string, unknown>).groupId ?? "") : ""))
+    .map((s) => s.trim())
+    .filter(Boolean);
+}
+
+// ─── JSON 提取 ─────────────────────────────────────────
+
+interface ReviewResult {
+  summary: string;
+  metrics: DailyReviewMetric[];
+  needsBugs: Array<{
+    type: string;
+    title: string;
+    description: string;
+    sourceMessage: string;
+    sender: string;
+    sourceGroup: string;
+    priority: string;
+  }>;
+  /** 学习候选：提问→真人解答→确认 链（learning.from_admin_replies 开启时提炼；否则空） */
+  learningCandidates: Array<{
+    question: string;
+    answer: string;
+    sourceGroup: string;
+    asker?: string;
+    resolver?: string;
+    sourceContext?: string;
+  }>;
+}
+
+type DailyReviewMetric = {
+  conversationId: string;
+  questionCount: number;
+  agentAnsweredCount?: number;
+  humanAnsweredCount?: number;
+  answeredCount: number;
+  unansweredCount: number;
+  silentCount?: number;
+  sendFailedCount?: number;
+  kbMissCount?: number;
+  demandCount?: number;
+  bugCount?: number;
+  servedUsers: number;
+  avgFirstResponseMinutes?: number;
+};
+
+function num(value: unknown, fallback = 0): number {
+  return typeof value === "number" && Number.isFinite(value) ? value : fallback;
+}
+
+function includesAny(text: string, patterns: string[]): boolean {
+  return patterns.some((pattern) => text.includes(pattern));
+}
+
+function computeAvgFirstResponseMinutes(entries: MemoryEntry[]): number {
+  const responseMinutes: number[] = [];
+  const answerKinds = new Set<string>([
+    SUPPORT_MEMORY_KINDS.agentReplySent,
+    SUPPORT_MEMORY_KINDS.adminMessage,
+  ]);
+
+  const sorted = [...entries].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+
+  // 关联键索引：user_message 正文归一化 → 首次提问时间。agent 侧事件带 meta.question 回指提问，
+  // 据此精确配对；纯按时序 FIFO 时，一个被静默的提问会把后续回复错配到它身上。
+  const questionFirstTs = new Map<string, number>();
+  const pendingQuestionTimes: number[] = [];
+  const matchedKeys = new Set<string>();
+
+  for (const entry of sorted) {
+    const ts = Date.parse(entry.timestamp);
+    if (!Number.isFinite(ts)) continue;
+    if (entry.kind === SUPPORT_MEMORY_KINDS.userMessage) {
+      const key = questionKey(entry.content);
+      if (key && !questionFirstTs.has(key)) questionFirstTs.set(key, ts);
+      pendingQuestionTimes.push(ts);
+      continue;
+    }
+    if (!answerKinds.has(entry.kind)) continue;
+
+    const key = typeof entry.meta?.question === "string" ? questionKey(entry.meta.question) : "";
+    const questionTs = key ? questionFirstTs.get(key) : undefined;
+    if (questionTs !== undefined) {
+      // 同一提问只计首次响应
+      if (matchedKeys.has(key)) continue;
+      matchedKeys.add(key);
+      if (ts >= questionTs) responseMinutes.push((ts - questionTs) / 60_000);
+      continue;
+    }
+    // 旧数据（无 meta.question，如真人 admin_message）回退时序配对
+    if (pendingQuestionTimes.length === 0) continue;
+    const fallbackTs = pendingQuestionTimes.shift()!;
+    if (ts >= fallbackTs) responseMinutes.push((ts - fallbackTs) / 60_000);
+  }
+
+  if (responseMinutes.length === 0) return 0;
+  const avg = responseMinutes.reduce((sum, value) => sum + value, 0) / responseMinutes.length;
+  return Math.round(avg * 100) / 100;
+}
+
+function computeDeterministicMetric(
+  conversationId: string,
+  entries: MemoryEntry[],
+  needsBugs: ReviewResult["needsBugs"],
+): DailyReviewMetric {
+  const userMessages = entries.filter((entry) => entry.kind === SUPPORT_MEMORY_KINDS.userMessage);
+  const agentAnsweredCount = entries.filter((entry) => entry.kind === SUPPORT_MEMORY_KINDS.agentReplySent).length;
+  // 口径说明：support-qa 里真人同事发言以 admin_message 入短期记忆（学习通道原料），
+  // 这里用它作为“真人回复”的近似口径（发言≠必然在答题，复盘摘要里由 agent 结合上下文修正）。
+  // owner_escalation_sent（bug/feature/kb_gap 升级找人）不计入已回答（spec §13）。
+  const humanAnsweredCount = entries.filter((entry) => entry.kind === SUPPORT_MEMORY_KINDS.adminMessage).length;
+  const answeredCount = agentAnsweredCount + humanAnsweredCount;
+  // 静默口径：新数据用 meta.action（群行为为 silent 的 action 闭集；Bug/Feature 升级不算静默），
+  // 旧数据（无 meta.action）回退历史判定
+  const silentActions = new Set(["kb_gap", "no_question", "human_handled", "owner_mentioned", "safety", "agent_failure"]);
+  const isSilentDecision = (entry: MemoryEntry) =>
+    typeof entry.meta?.action === "string" && entry.meta.action
+      ? silentActions.has(String(entry.meta.action))
+      : entry.content.trim() === "(静默)" || entry.meta?.shouldReply !== true;
+  const silentDecisions = entries.filter((entry) => {
+    if (entry.kind !== SUPPORT_MEMORY_KINDS.agentDecision) return false;
+    return isSilentDecision(entry);
+  });
+  const sendFailedCount = entries.filter((entry) => entry.kind === SUPPORT_MEMORY_KINDS.sendFailed).length;
+  // 结构化 action 优先（拍平契约）；旧 silenceCode 仅作历史数据回退，关键词再次回退
+  const kbMissCount = silentDecisions.filter((entry) => {
+    if (typeof entry.meta?.action === "string" && entry.meta.action) return entry.meta.action === "kb_gap";
+    if (entry.meta?.silenceCode === "kb_gap") return true;
+    if (typeof entry.meta?.silenceCode === "string" && entry.meta.silenceCode) return false;
+    const reason = String(entry.meta?.reason ?? entry.content ?? "");
+    return includesAny(reason, ["知识库未覆盖", "知识库不可用", "无据", "未找到相关说明", "文档未覆盖"]);
+  }).length;
+  const servedUsers = new Set(userMessages.map((entry) => String(entry.meta?.sender ?? "")).filter(Boolean)).size;
+  const groupNeedsBugs = needsBugs.filter((item) => !item.sourceGroup || item.sourceGroup === conversationId);
+
+  return {
+    conversationId,
+    questionCount: userMessages.length,
+    agentAnsweredCount,
+    humanAnsweredCount,
+    answeredCount,
+    unansweredCount: Math.max(0, userMessages.length - answeredCount),
+    silentCount: silentDecisions.length,
+    sendFailedCount,
+    kbMissCount,
+    demandCount: groupNeedsBugs.filter((item) => item.type === "需求").length,
+    bugCount: groupNeedsBugs.filter((item) => item.type === "Bug").length,
+    servedUsers,
+    avgFirstResponseMinutes: computeAvgFirstResponseMinutes(entries),
+  };
+}
+
+function extractReviewResult(raw: string): ReviewResult | null {
+  if (!raw) return null;
+  let s = raw.trim();
+  const fence = s.match(/```(?:json)?\s*([\s\S]*?)```/i);
+  if (fence?.[1]) s = fence[1].trim();
+  const start = s.indexOf("{");
+  const end = s.lastIndexOf("}");
+  if (start === -1 || end === -1 || end <= start) return null;
+  try {
+    const parsed = JSON.parse(s.slice(start, end + 1));
+    if (typeof parsed !== "object" || parsed === null) return null;
+    return {
+      summary: String(parsed.summary ?? ""),
+      metrics: Array.isArray(parsed.metrics) ? parsed.metrics : [],
+      needsBugs: Array.isArray(parsed.needsBugs) ? parsed.needsBugs : [],
+      learningCandidates: Array.isArray(parsed.learningCandidates) ? parsed.learningCandidates : [],
+    };
+  } catch {
+    return null;
+  }
+}
+
+// ─── 日期工具 ──────────────────────────────────────────
+
+/** 某时区当前时刻的墙上日期（YYYY-MM-DD） */
+function zonedDateParts(date: Date, timeZone: string): { year: number; month: number; day: number } {
+  const parts = new Intl.DateTimeFormat("en-CA", { timeZone, year: "numeric", month: "2-digit", day: "2-digit" }).formatToParts(date);
+  const pick = (t: string) => Number(parts.find((p) => p.type === t)!.value);
+  return { year: pick("year"), month: pick("month"), day: pick("day") };
+}
+
+/** 某时区在给定瞬间的 UTC 偏移（ms）；用于把墙上时间换算成 UTC 瞬间 */
+function tzOffsetMs(date: Date, timeZone: string): number {
+  const parts = new Intl.DateTimeFormat("en-US", {
+    timeZone,
+    hour12: false,
+    year: "numeric",
+    month: "2-digit",
+    day: "2-digit",
+    hour: "2-digit",
+    minute: "2-digit",
+    second: "2-digit",
+  }).formatToParts(date);
+  const map: Record<string, number> = {};
+  for (const p of parts) if (p.type !== "literal") map[p.type] = Number(p.value);
+  const hour = map.hour === 24 ? 0 : map.hour;
+  const asUTC = Date.UTC(map.year, map.month - 1, map.day, hour, map.minute, map.second);
+  return asUTC - date.getTime();
+}
+
+/** 把某时区的墙上时间转成 UTC ISO；迭代一次修正跨 DST 边界的偏移 */
+function zonedWallClockToUtc(y: number, mon: number, d: number, h: number, min: number, s: number, ms: number, timeZone: string): string {
+  // 偏移与毫秒无关，且 formatToParts 不保留毫秒，故先置 0 算偏移再补回 ms
+  const guess = Date.UTC(y, mon, d, h, min, s, 0);
+  const offset = tzOffsetMs(new Date(guess), timeZone);
+  return new Date(guess - offset + ms).toISOString();
+}
+
+/**
+ * 计算指定时区下"昨天"的 [00:00:00, 23:59:59.999] 对应的 UTC ISO 区间。
+ * 用 Intl 取时区墙上日期，避免运行环境时区（如远端 UTC 机器）导致"昨天"错位。
+ */
+function yesterdayRange(timeZone: string): { since: string; until: string; dateStr: string } {
+  const today = zonedDateParts(new Date(), timeZone);
+  // 用 UTC 运算减一天，避开 DST/月末边界问题
+  const y = new Date(Date.UTC(today.year, today.month - 1, today.day) - 86_400_000);
+  const yy = y.getUTCFullYear();
+  const mm = y.getUTCMonth();
+  const dd = y.getUTCDate();
+  const dateStr = `${yy}-${String(mm + 1).padStart(2, "0")}-${String(dd).padStart(2, "0")}`;
+  const since = zonedWallClockToUtc(yy, mm, dd, 0, 0, 0, 0, timeZone);
+  const until = zonedWallClockToUtc(yy, mm, dd, 23, 59, 59, 999, timeZone);
+  return { since, until, dateStr };
+}
+
+// ─── 消息格式化 ────────────────────────────────────────
+
+function formatMessages(conversationId: string, entries: MemoryEntry[]): string {
+  const lines = entries.map((e) => {
+    const ts = e.timestamp.slice(11, 16); // HH:mm
+    const sender = String(e.meta?.sender ?? "未知");
+    const role = e.meta?.role ? `/${String(e.meta.role)}` : "";
+    // 决策行附 action/module/reason（拍平契约）：正文已不含话术副本（见 SUPPORT_DECISION_CONTENT），
+    // 判定依据改由 meta.reason 承载，供复盘 agent 聚合 Bug/需求提示（仍需合并同根因/去重/纠错）
+    const isDecision = e.kind === SUPPORT_MEMORY_KINDS.agentDecision;
+    const decision = isDecision && typeof e.meta?.action === "string"
+      ? ` action=${String(e.meta.action)}${e.meta?.module ? ` module=${String(e.meta.module)}` : ""}`
+      : "";
+    const reason = isDecision && typeof e.meta?.reason === "string" && e.meta.reason
+      ? ` reason=${e.meta.reason.slice(0, 120)}`
+      : "";
+    return `[${ts}] ${sender}${role} <${e.kind}${decision}>:${reason} ${e.content}`;
+  });
+  return `### 群: ${conversationId}\n${lines.join("\n")}`;
+}
+
+/** conversationId 是 base64 风格（含 + / =），归一化为安全文件名；前置序号防归一化后重名 */
+function inboxFileName(conversationId: string, index: number): string {
+  const safe = conversationId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 60);
+  return `${String(index + 1).padStart(2, "0")}-${safe}.md`;
+}
+
+// ─── Recipe 定义 ───────────────────────────────────────
+
+const recipe: RecipeDefinition = {
+  meta: {
+    id: "daily_review",
+    name: "每日复盘",
+    role: "daily-review",
+    description: "读取昨日群短期记忆 → coding.run 压缩/统计/抽取 → 写长期记忆+统计表+需求池",
+    version: "1.0.0",
+    requiresAgent: true,
+    config: z.object({
+      conversation_ids: z.union([z.array(z.string()), z.string()]).describe("复盘群来源：静态 conversationId 数组，或引用 ${globalVar.group_configs}（二选一，无隐式回退）"),
+      daily_stats_table: tableRefConfigSchema({
+        label: "每日统计表",
+        description: "每日统计表（upsertRecordIn 写入）",
+        access: "write",
+        ownership: "owned",
+        autoCreate: true,
+        defaultBase: "workflow.tracker.base_id",
+        setupSchema: {
+          fields: [
+            { name: "统计键", type: "text" },
+            { name: "统计日期", type: "text" },
+            { name: "群ID", type: "text" },
+            { name: "提问题数", type: "number" },
+            { name: "Agent回复数", type: "number" },
+            { name: "真人回复数", type: "number" },
+            { name: "已回复数", type: "number" },
+            { name: "未回复数", type: "number" },
+            { name: "静默数", type: "number" },
+            { name: "发送失败数", type: "number" },
+            { name: "知识库未覆盖数", type: "number" },
+            { name: "需求数", type: "number" },
+            { name: "Bug数", type: "number" },
+            { name: "服务用户数", type: "number" },
+            { name: "平均首次响应分钟", type: "number" },
+            { name: "节省工时", type: "number" },
+            { name: "摘要内容", type: "text" },
+          ],
+        },
+      }),
+      product_backlog_table: tableRefConfigSchema({
+        label: "产品需求池",
+        description: "产品需求池（createRecordsIn 写入）",
+        access: "write",
+        ownership: "owned",
+        autoCreate: true,
+        defaultBase: "workflow.tracker.base_id",
+        setupSchema: {
+          fields: [
+            { name: "标题", type: "text" },
+            { name: "类型", type: "text" },
+            { name: "描述", type: "text" },
+            { name: "来源消息", type: "text" },
+            { name: "发送人", type: "text" },
+            { name: "来源群", type: "text" },
+            { name: "优先级", type: "text" },
+            { name: "复盘日期", type: "text" },
+            { name: "状态", type: "text" },
+          ],
+        },
+      }),
+      saved_minutes_per_reply: z.number().optional().describe("每条 Agent 回复节省的人工工时（分钟），默认 15"),
+      learning_candidate_table: tableRefConfigSchema({
+        label: "学习候选写入表",
+        description: "学习候选新建行写入表（引用 group-qa 群问答表）；learning.from_admin_replies 开启时生效",
+        access: "write",
+        ownership: "reference",
+        defaultBase: "workflow.tracker.base_id",
+      }).optional(),
+      timezone: z.string().optional().describe("复盘日期计算时区（IANA，如 Asia/Shanghai），应与 cron 的 timezone 一致；默认 Asia/Shanghai。远端 UTC 机器上必须显式设置以避免\"昨天\"错位"),
+      learning: z.object({
+        from_admin_replies: z.boolean().describe("是否从管理员回复中提炼学习候选"),
+        review: z.enum(["human-approve", "auto"]).describe("审核模式：human-approve（人工确认）或 auto（自动入库）"),
+      }).optional().describe("学习通道（L2）：提炼真人解答为候选，人工确认入库；省略即关闭"),
+    }),
+  },
+
+  async execute(ctx: RecipeContext): Promise<RecipeResult> {
+    const config = parseConfig(ctx.config);
+
+    const { toolkit, log, configDir } = ctx;
+    const { memory, table, coding } = toolkit;
+
+    // 学习通道（config 驱动）：from_admin_replies 开启才提炼学习候选
+    const learningConfig = ctx.config.learning as { from_admin_replies?: boolean; review?: string } | undefined;
+    const learning = {
+      enabled: learningConfig?.from_admin_replies === true,
+      review: learningConfig?.review === "auto" ? "auto" as const : "human-approve" as const,
+    };
+
+    // 0. 恢复孤儿 processing 文件
+    try {
+      await memory.recover();
+    } catch (err) {
+      log(`memory.recover 失败(不影响主流程): ${err}`);
+    }
+
+    // 1. 解析复盘群列表：显式配置静态数组，或引用 ${globalVar.group_configs}（无隐式空回退）
+    const conversationIds = resolveConversationIds(config.conversationIds, ctx.getGlobalVar);
+    if (conversationIds.length === 0) {
+      return { status: "failed", output: {}, error: "daily-review: conversation_ids 不能为空", retryable: false, logs: [] };
+    }
+
+    // 2. 计算昨日时间范围（按配置时区，避免运行环境时区错位）
+    const { since, until, dateStr } = yesterdayRange(config.timezone);
+    log(`每日复盘开始: 日期=${dateStr}, 时区=${config.timezone}, 群数=${conversationIds.length}`);
+
+    // 3. 按群读取短期记忆
+    const groupEntries = new Map<string, MemoryEntry[]>();
+
+    for (const convId of conversationIds) {
+      const scope = supportScope(convId);
+      const entries = await memory.readShortTerm(scope, { since, until, limit: 500 });
+      if (entries.length > 0) {
+        groupEntries.set(convId, entries);
+        log(`群 ${convId}: 读取 ${entries.length} 条短期记忆`);
+      } else {
+        log(`群 ${convId}: 无短期记忆，跳过`);
+      }
+    }
+
+    if (groupEntries.size === 0) {
+      log("所有群均无短期记忆，每日复盘结束(不留痕)");
+      return { status: "success", output: {}, tracker: false, logs: ["无活动"] };
+    }
+
+    // 4. 各群消息落盘到工作目录，prompt 只给路径（内联全部原文会把 prompt 打爆：单群 500 条可达数百 KB）
+    const agentWorkDir = path.resolve(configDir, "workspaces/daily-review");
+    const inboxDir = path.join(agentWorkDir, ".today");
+    const cleanupInbox = () => {
+      try {
+        fs.rmSync(inboxDir, { recursive: true, force: true });
+      } catch (err) {
+        log(`清理 .today 失败(不影响主流程): ${err}`);
+      }
+    };
+
+    cleanupInbox();
+    fs.mkdirSync(inboxDir, { recursive: true });
+    const inboxList: string[] = [];
+    let inboxIndex = 0;
+    for (const [convId, entries] of groupEntries) {
+      const fileName = inboxFileName(convId, inboxIndex++);
+      fs.writeFileSync(path.join(inboxDir, fileName), formatMessages(convId, entries), "utf8");
+      inboxList.push(`- \`.today/${fileName}\` — 群 ${convId}，${entries.length} 条`);
+    }
+
+    const learningNote = learning.enabled
+      ? `\n## 学习候选提炼（本实例已开启 learning.from_admin_replies）\n额外识别「用户提问 → 真人同事(admin_message)给出解答 → 用户确认/无异议」的问答链，作为知识沉淀候选。仅在真有清晰一问一答链时提取，绝不虚构结论；把原始提问、真人解答原文、来源群、提问人、解答人、溯源(时间/上下文)写入 learningCandidates。\n`
+      : "";
+    const contractFields = `summary、metrics、needsBugs${learning.enabled ? "、learningCandidates" : ""} 字段`;
+    const prompt = `按【本工作目录下 AGENTS.md 的规范】阅读今日所有群的短期记忆消息，完成压缩摘要、统计指标抽取、需求与 Bug 识别。
+
+## 今日消息（${dateStr}）
+
+消息已按群落盘到本工作目录下的 \`.today/\` 目录，每群一个文件。请逐个 Read 下列全部文件后再分析，不要遗漏：
+
+${inboxList.join("\n")}
+${learningNote}
+## 输出契约
+
+请按 AGENTS.md 的规范输出严格 JSON 对象，包含 ${contractFields}。`;
+
+    log(`调用 coding agent (workDir=${agentWorkDir}, 群文件=${inboxList.length})...`);
+    let result: Awaited<ReturnType<typeof coding.run>>;
+    try {
+      result = await coding.run(prompt, { workDir: agentWorkDir });
+    } finally {
+      cleanupInbox();
+    }
+
+    if (!result.response) {
+      log("coding agent 未产出有效响应，每日复盘终止");
+      // cron 每日仅触发一次：瞬时故障（agent 拖动/网络）可重试，避免丢掉整天复盘
+      return { status: "failed", output: {}, error: "coding agent 未产出有效响应", retryable: true, logs: ["coding agent 无响应"] };
+    }
+
+    // 5. 解析 JSON 输出
+    const review = extractReviewResult(result.response);
+    if (!review) {
+      log(`JSON 解析失败，每日复盘终止。原始响应前120字: ${result.response.slice(0, 120)}`);
+      // 解析失败多为 agent 单次输出不稳，重试可能恢复
+      return { status: "failed", output: {}, error: "复盘 JSON 解析失败", retryable: true, logs: ["JSON 解析失败"] };
+    }
+
+    log(`解析成功: summary=${review.summary.length}字, metrics=${review.metrics.length}组, needsBugs=${review.needsBugs.length}条`);
+    const metrics = Array.from(groupEntries.entries()).map(([convId, entries]) =>
+      computeDeterministicMetric(convId, entries, review.needsBugs),
+    );
+
+    // 6. 写共享长期记忆（不含 conversationId，所有群共用）
+    // sourceScopes 负责从各群读取并 checkpoint 短期记忆，targetScope 只承载共享 long-term.md。
+    const sharedScope: MemoryScope = {
+      ...supportScope(),
+    };
+    const sourceScopes: MemoryScope[] = Array.from(groupEntries.keys()).map((convId) => supportScope(convId));
+    try {
+      const compactResult = await memory.compact(sharedScope, {
+        summary: review.summary,
+        sourceScopes,
+        query: { since, until },
+      });
+      log(`长期记忆写入成功: 压缩 ${compactResult.entryCount} 条短期记忆`);
+    } catch (err) {
+      log(`memory.compact 失败(不影响后续写表): ${err}`);
+    }
+
+    // 7. 写每日统计表（按群 upsert）
+    if (!config.dailyStatsTable) {
+      log("daily_stats_table 未配置，跳过每日统计表写入");
+    }
+    for (const metric of metrics) {
+      if (!config.dailyStatsTable) continue;
+      const statsKey = `${dateStr}_${metric.conversationId}`;
+      const agentAnsweredCount = num(metric.agentAnsweredCount);
+      const humanAnsweredCount = num(metric.humanAnsweredCount);
+      const answeredCount = num(metric.answeredCount, agentAnsweredCount + humanAnsweredCount);
+      const automatedAnsweredCount = agentAnsweredCount || answeredCount;
+      const savedHours = Math.round(
+        automatedAnsweredCount * config.savedMinutesPerReply * 100 / 60,
+      ) / 100;
+
+      try {
+        await table.upsertRecordIn(config.dailyStatsTable, "统计键", {
+          "统计键": statsKey,
+          "统计日期": dateStr,
+          "群ID": metric.conversationId,
+          "提问题数": num(metric.questionCount),
+          "Agent回复数": agentAnsweredCount,
+          "真人回复数": humanAnsweredCount,
+          "已回复数": answeredCount,
+          "未回复数": num(metric.unansweredCount),
+          "静默数": num(metric.silentCount),
+          "发送失败数": num(metric.sendFailedCount),
+          "知识库未覆盖数": num(metric.kbMissCount),
+          "需求数": num(metric.demandCount),
+          "Bug数": num(metric.bugCount),
+          "服务用户数": num(metric.servedUsers),
+          "平均首次响应分钟": num(metric.avgFirstResponseMinutes),
+          "节省工时": savedHours,
+          "摘要内容": review.summary,
+        });
+        log(`每日统计表 upsert 成功: ${statsKey} (提问题数=${metric.questionCount}, 节省工时=${savedHours})`);
+      } catch (err) {
+        log(`每日统计表 upsert 失败: ${statsKey}: ${err}`);
+      }
+    }
+
+    // 8. 写产品需求池（批量 create）
+    if (!config.productBacklogTable) {
+      log("product_backlog_table 未配置，跳过产品需求池写入");
+    } else if (review.needsBugs.length > 0) {
+      const rows = review.needsBugs.map((item) => ({
+        "标题": String(item.title ?? ""),
+        "类型": String(item.type ?? "需求"),
+        "描述": String(item.description ?? ""),
+        "来源消息": String(item.sourceMessage ?? ""),
+        "发送人": String(item.sender ?? ""),
+        "来源群": String(item.sourceGroup ?? ""),
+        "优先级": String(item.priority ?? "中"),
+        "复盘日期": dateStr,
+        "状态": "待处理",
+      }));
+
+      try {
+        const createResult = await table.createRecordsIn(config.productBacklogTable, rows);
+        log(`产品需求池写入成功: ${createResult.recordIds.length} 条`);
+      } catch (err) {
+        log(`产品需求池写入失败: ${err}`);
+      }
+    } else {
+      log("无需求/Bug 需要写入");
+    }
+
+    // 9. 写学习候选（新建行到群问答表；不回填旧行，human-approve→待确认，auto→待沉淀）
+    let learningWritten = 0;
+    if (learning.enabled && !config.learningCandidateTable) {
+      log("learning 已开启但 learning_candidate_table 未配置，跳过学习候选写入");
+    } else if (learning.enabled && config.learningCandidateTable && review.learningCandidates.length > 0) {
+      const kbStatus = learning.review === "auto" ? KB_STATUS.READY_TO_PERSIST : KB_STATUS.PENDING_CONFIRM;
+      const rows = review.learningCandidates
+        .filter((c) => String(c.question ?? "").trim() && String(c.answer ?? "").trim())
+        .map((c) => ({
+          "消息内容": String(c.question ?? ""),
+          "发送人": String(c.asker ?? ""),
+          "群ID": String(c.sourceGroup ?? ""),
+          "对话上下文": `[学习候选·daily-review ${dateStr}] 溯源：${String(c.sourceContext ?? "")}${c.resolver ? `；解答人：${c.resolver}` : ""}`,
+          "管理员更新": String(c.answer ?? ""),
+          "知识沉淀": kbStatus,
+        }));
+      if (rows.length > 0) {
+        try {
+          const r = await table.createRecordsIn(config.learningCandidateTable, rows);
+          learningWritten = r.recordIds.length;
+          log(`学习候选写入成功: ${learningWritten} 条（知识沉淀=${kbStatus}）`);
+        } catch (err) {
+          log(`学习候选写入失败: ${err}`);
+        }
+      } else {
+        log("学习候选均缺失提问或答案，跳过写入");
+      }
+    }
+
+    log("每日复盘完成");
+    return {
+      status: "success",
+      output: {
+        review_date: dateStr,
+        group_count: String(groupEntries.size),
+        needs_bug_count: String(review.needsBugs.length),
+        learning_candidate_count: String(learningWritten),
+        summary: review.summary,
+      },
+      logs: [`群 ${groupEntries.size}`, `需求Bug ${review.needsBugs.length}`, `学习候选 ${learningWritten}`],
+    };
+  },
+};
+
+export default recipe;