aitable-workflow-cli 0.1.23 → 0.1.24

package/templates/support-qa/workflows/config-sync/recipes/config_sync_handler.recipe.ts

@@ -1,16 +0,0 @@
-import type { EventHandlerRecipeDefinition, HandlerInitContext, HandlerInstance } from "aitable-workflow-core";
-
-const recipe: EventHandlerRecipeDefinition = {
-  meta: { id: "config_sync_handler", name: "配置同步触发器", description: "cron tick → 建一条配置同步工单" },
-  create(ctx: HandlerInitContext): HandlerInstance {
-    return {
-      onEvent(event) {
-        const firedAt = String(event.payload?.firedAt ?? new Date().toISOString());
-        ctx.log(`配置同步触发 @ ${firedAt}`);
-        ctx.pushEvent({ action: "create_record", fields: { "标题": `配置同步 ${firedAt}` } });
-      },
-      stop() {},
-    };
-  },
-};
-export default recipe;

package/templates/support-qa/workflows/config-sync/workflow.yml

@@ -1,62 +0,0 @@
-meta:
-  name: "群/管理员/模块人员配置同步"
-  version: "1.0.0"
-  domain: config_sync
-  description: "定时从固定 AI 表格拉群配置、管理员与功能模块人员,发布到 globalVar(group_configs/admins/module_owners,供 group-qa 活读);不发群"
-
-notification:
-  channel: "none"
-
-tracker:
-  label: "群与管理员配置同步留痕表"
-  base_id: "" # 与其它工作流同 base;table_id 留空 setup 自动建表回写
-  table_id: ""
-  states:
-    initial: "待处理"
-    active: [ "处理中" ]
-    terminal: [ "已完成", "已关闭" ]
-    blocked: "已阻塞"
-  fields:
-    state: "状态"
-    title: "标题"
-    current_step: "当前步骤"
-    event_log: "事件日志"
-  field_definitions:
-    - name: 同步结果
-      type: text
-    - name: 群数量
-      type: text
-    - name: 管理员数量
-      type: text
-    - name: 模块人员数量
-      type: text
-  views:
-    - id: default_grid
-      type: Grid
-      name: 表格
-      field_order: [ 标题, 同步结果, 群数量, 管理员数量, 模块人员数量, 状态, 当前步骤, 事件日志 ]
-      description: 配置同步留痕
-
-event_sources:
-  - name: 定时同步
-    type: cron_scheduler
-    handler: config_sync_handler
-    record_policy: on_demand # 无变更的 tick 不建行(见 config_sync recipe 的 tracker:false)
-
-steps:
-  - id: config_sync
-    name: "拉取并固化群/管理员/模块人员配置"
-    recipe: config_sync
-    auto: true
-    input_mapping: {}
-    output_mapping:
-      sync_result: "同步结果"
-      group_count: "群数量"
-      admin_count: "管理员数量"
-      owner_count: "模块人员数量"
-
-edges:
-  - from: __start__
-    to: config_sync
-  - from: config_sync
-    to: __end__

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

@@ -1,602 +0,0 @@
-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, yesterdayRange, normalizeTimezone } 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 结束即删除。
- *
- * 群列表适配：群是动态的，由 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),
-  };
-}
-
-/**
- * 解析复盘群列表：显式二选一，无隐式回退。
- * - 静态字符串数组 → 直接用
- * - "${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;
-  }
-}
-
-// ─── 消息格式化 ────────────────────────────────────────
-
-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;