aitable-workflow-cli 0.1.13-beta.1

package/templates/aitable-handoff/workflows/daily-review/recipes/daily_review.recipe.ts

@@ -0,0 +1,529 @@
+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 { HANDOFF_MEMORY_KINDS, handoffScope } from "./memory-events.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 承载全部压缩/统计/抽取规范。
+ *
+ * 群列表适配：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;
+  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";
+}
+
+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,
+    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;
+  }>;
+}
+
+type DailyReviewMetric = {
+  conversationId: string;
+  questionCount: number;
+  agentAnsweredCount?: number;
+  knownErrorAnsweredCount?: 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 pendingQuestionTimes: number[] = [];
+  const responseMinutes: number[] = [];
+  const answerKinds = new Set<string>([
+    HANDOFF_MEMORY_KINDS.agentReplySent,
+    HANDOFF_MEMORY_KINDS.knownErrorReplySent,
+    HANDOFF_MEMORY_KINDS.humanReply,
+  ]);
+
+  const sorted = [...entries].sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+  for (const entry of sorted) {
+    const ts = Date.parse(entry.timestamp);
+    if (!Number.isFinite(ts)) continue;
+    if (entry.kind === HANDOFF_MEMORY_KINDS.userMessage) {
+      pendingQuestionTimes.push(ts);
+      continue;
+    }
+    if (answerKinds.has(entry.kind) && pendingQuestionTimes.length > 0) {
+      const questionTs = pendingQuestionTimes.shift()!;
+      if (ts >= questionTs) {
+        responseMinutes.push((ts - questionTs) / 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 === HANDOFF_MEMORY_KINDS.userMessage);
+  const agentAnsweredCount = entries.filter((entry) => entry.kind === HANDOFF_MEMORY_KINDS.agentReplySent).length;
+  const knownErrorAnsweredCount = entries.filter((entry) => entry.kind === HANDOFF_MEMORY_KINDS.knownErrorReplySent).length;
+  const humanAnsweredCount = entries.filter((entry) => entry.kind === HANDOFF_MEMORY_KINDS.humanReply).length;
+  const answeredCount = agentAnsweredCount + knownErrorAnsweredCount + humanAnsweredCount;
+  const silentDecisions = entries.filter((entry) => {
+    if (entry.kind !== HANDOFF_MEMORY_KINDS.agentDecision) return false;
+    return entry.content.trim() === "(静默)" || entry.meta?.shouldReply !== true;
+  });
+  const sendFailedCount = entries.filter((entry) => entry.kind === HANDOFF_MEMORY_KINDS.sendFailed).length;
+  const kbMissCount = silentDecisions.filter((entry) => {
+    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,
+    knownErrorAnsweredCount,
+    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 : [],
+    };
+  } 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)}` : "";
+    return `[${ts}] ${sender}${role} <${e.kind}>: ${e.content}`;
+  });
+  return `### 群: ${conversationId}\n${lines.join("\n")}`;
+}
+
+// ─── 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: "需求数", 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"),
+      timezone: z.string().optional().describe("复盘日期计算时区（IANA，如 Asia/Shanghai），应与 cron 的 timezone 一致；默认 Asia/Shanghai。远端 UTC 机器上必须显式设置以避免\"昨天\"错位"),
+    }),
+  },
+
+  async execute(ctx: RecipeContext): Promise<RecipeResult> {
+    const config = parseConfig(ctx.config);
+
+    async function run(): Promise<RecipeResult> {
+      const { toolkit, log, configDir } = ctx;
+      const { memory, table, coding } = toolkit;
+
+      // 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 allGroupMessages: string[] = [];
+      const groupEntries = new Map<string, MemoryEntry[]>();
+
+      for (const convId of conversationIds) {
+        const scope = handoffScope(convId);
+        const entries = await memory.readShortTerm(scope, { since, until, limit: 500 });
+        if (entries.length > 0) {
+          groupEntries.set(convId, entries);
+          allGroupMessages.push(formatMessages(convId, entries));
+          log(`群 ${convId}: 读取 ${entries.length} 条短期记忆`);
+        } else {
+          log(`群 ${convId}: 无短期记忆，跳过`);
+        }
+      }
+
+      if (allGroupMessages.length === 0) {
+        log("所有群均无短期记忆，每日复盘结束(不留痕)");
+        return { status: "success", output: {}, tracker: false, logs: ["无活动"] };
+      }
+
+      // 4. 构建 prompt，调用 coding agent
+      const agentWorkDir = path.resolve(configDir, "workspaces/daily-review");
+      const prompt = `按【本工作目录下 AGENTS.md 的规范】阅读以下今日所有群的短期记忆消息，完成压缩摘要、统计指标抽取、需求与 Bug 识别。
+
+## 今日消息（${dateStr}）
+
+${allGroupMessages.join("\n\n")}
+
+## 输出契约
+
+请按 AGENTS.md 的规范输出严格 JSON 对象，包含 summary、metrics、needsBugs 三个字段。`;
+
+      log(`调用 coding agent (workDir=${agentWorkDir})...`);
+      const result = await coding.run(prompt, { workDir: agentWorkDir });
+
+      if (!result.response) {
+        log("coding agent 未产出有效响应，每日复盘终止");
+        return { status: "failed", output: {}, error: "coding agent 未产出有效响应", retryable: false, logs: ["coding agent 无响应"] };
+      }
+
+      // 5. 解析 JSON 输出
+      const review = extractReviewResult(result.response);
+      if (!review) {
+        log(`JSON 解析失败，每日复盘终止。原始响应前120字: ${result.response.slice(0, 120)}`);
+        return { status: "failed", output: {}, error: "复盘 JSON 解析失败", retryable: false, 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 = {
+        ...handoffScope(),
+      };
+      const sourceScopes: MemoryScope[] = Array.from(groupEntries.keys()).map((convId) => handoffScope(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 knownErrorAnsweredCount = num(metric.knownErrorAnsweredCount);
+        const humanAnsweredCount = num(metric.humanAnsweredCount);
+        const answeredCount = num(metric.answeredCount, agentAnsweredCount + knownErrorAnsweredCount + humanAnsweredCount);
+        const automatedAnsweredCount = agentAnsweredCount + knownErrorAnsweredCount || 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,
+            "已知错误回复数": knownErrorAnsweredCount,
+            "真人回复数": 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 需要写入");
+      }
+
+      log("每日复盘完成");
+      return {
+        status: "success",
+        output: {
+          review_date: dateStr,
+          group_count: String(groupEntries.size),
+          needs_bug_count: String(review.needsBugs.length),
+          summary: review.summary,
+        },
+        logs: [`群 ${groupEntries.size}`, `需求Bug ${review.needsBugs.length}`],
+      };
+    }
+
+    return run();
+  },
+};
+
+export default recipe;

package/templates/aitable-handoff/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/aitable-handoff/workflows/daily-review/recipes/memory-events.ts

@@ -0,0 +1,56 @@
+// ⚠️ 与 group-qa/recipes/memory-events.ts 保持一致:scope 常量(channel/scenario)必须相同,否则读不到同一份记忆。
+import type { MemoryEntry, MemoryScope } from "aitable-workflow-core";
+
+export const HANDOFF_SCENARIO = "aitable-handoff";
+export const HANDOFF_CHANNEL = "dingtalk";
+
+export const HANDOFF_MEMORY_KINDS = {
+  userMessage: "user_message",
+  humanReply: "human_reply",
+  agentDecision: "agent_decision",
+  agentReplySent: "agent_reply_sent",
+  knownErrorReplySent: "known_error_reply_sent",
+  sendFailed: "send_failed",
+} as const;
+
+export type HandoffMemoryKind = typeof HANDOFF_MEMORY_KINDS[keyof typeof HANDOFF_MEMORY_KINDS];
+
+export const HANDOFF_MEMORY_ROLES = {
+  user: "user",
+  human: "human",
+  agent: "agent",
+} as const;
+
+export type HandoffMemoryRole = typeof HANDOFF_MEMORY_ROLES[keyof typeof HANDOFF_MEMORY_ROLES];
+
+export function handoffScope(conversationId?: string): MemoryScope {
+  return {
+    channel: HANDOFF_CHANNEL,
+    scenario: HANDOFF_SCENARIO,
+    ...(conversationId ? { conversationId } : {}),
+  };
+}
+
+export function handoffEntry(args: {
+  kind: HandoffMemoryKind;
+  content: string;
+  sender: string;
+  role: HandoffMemoryRole;
+  conversationId: string;
+  timestamp?: string;
+  summary?: string;
+  meta?: Record<string, unknown>;
+}): MemoryEntry {
+  return {
+    timestamp: args.timestamp ?? new Date().toISOString(),
+    kind: args.kind,
+    content: args.content,
+    summary: args.summary ?? `${args.sender}: ${args.content.slice(0, 80)}`,
+    meta: {
+      sender: args.sender,
+      role: args.role,
+      conversationId: args.conversationId,
+      ...args.meta,
+    },
+  };
+}