aitable-workflow-cli 0.1.28 → 0.1.29-beta.1790736949347

package/templates/ai-native-sdlc/workflows/execution/recipes/review.recipe.ts

@@ -0,0 +1,257 @@
+import type { RecipeDefinition } from "aitable-workflow-core";
+import { z } from "zod";
+import { devStageConfig } from "../../../lib/recipe-config.js";
+import { artifactName, artifactPath, resolveWorktreeDir } from "../../../lib/artifacts.js";
+import {
+  agentQuestions,
+  appendHandledComments,
+  appendArtifact,
+  appendStageTransition,
+  blockExecution,
+  blocked,
+  changeId,
+  commentRepairNotice,
+  commitOptions,
+  consumeAnswersOrBlock,
+  crEntries,
+  failed,
+  handleCodingFailure,
+  isTestDemand,
+  isCurrentRecipe,
+  persistCodingSession,
+  questionsText,
+  repoPathFromUrl,
+  repositoryUrl,
+  requireRepositories,
+  sessionMap,
+  success,
+  testDemandInstruction,
+  unhandledComments,
+  waitForExternalProgress,
+  worktreeOptions,
+  MAX_REVIEW_ROUNDS,
+  parseReviewRound,
+} from "../../../lib/recipe-helpers.js";
+
+// review 是唯一需要反向闭环需求池的执行步骤，跨 workflow tracker 引用随本 recipe 就近声明。
+const reviewStageConfig = devStageConfig.extend({
+  intake_tracker: z.object({
+    base_id: z.string().min(1),
+    table_id: z.string().min(1),
+  }),
+});
+
+const recipe: RecipeDefinition = {
+  meta: {
+    id: "review",
+    name: "评审",
+    role: "reviewer",
+    description: "Dev 跟踪既有 CR、处理评论，全部 CR 合并即完成变更",
+    version: "1.0.0",
+    requiresAgent: true,
+    config: reviewStageConfig,
+  },
+  async execute(ctx) {
+    const row = await ctx.toolkit.table.readCurrentRow();
+    const id = changeId(row);
+    const configuredRepos = requireRepositories(ctx, "dev_repositories");
+    const repos = isTestDemand(row) ? configuredRepos.slice(0, 1) : configuredRepos;
+    const intakeTarget = ctx.config.intake_tracker as
+      | { base_id?: string; table_id?: string }
+      | undefined;
+    if (!id || !repos.length)
+      return failed("评审阶段缺少变更编号或 Dev 候选仓库配置");
+    if (!intakeTarget?.base_id || !intakeTarget.table_id)
+      return failed("评审阶段缺少需求池 tracker 引用配置");
+    if (!isCurrentRecipe(row, ctx.stepId)) {
+      return blocked("当前步骤与执行 recipe 不一致，拒绝重复执行评审");
+    }
+    // 有界重试：超过最大轮次则升级人工
+    const currentRound = parseReviewRound(row);
+    if (currentRound > MAX_REVIEW_ROUNDS) {
+      return blocked(`评审修复已超过 ${MAX_REVIEW_ROUNDS} 轮，请人工介入`);
+    }
+    const resumed = await consumeAnswersOrBlock(ctx, row);
+    if (resumed.blocked) return resumed.blocked;
+    const existing = crEntries(row["当前CR链接"]);
+    if (!existing.length) return blocked("评审阶段缺少 coding 创建的代码 CR 链接");
+    if (existing.length) {
+      const unknownRepository = existing.find(
+        (entry) => !repos.some(
+          (repo) => repoPathFromUrl(repositoryUrl(repo)) === entry.repoUrl,
+        ),
+      );
+      if (unknownRepository) {
+        return failed(`评审 CR 不属于已配置的 Dev 仓库：${unknownRepository.repoUrl}`);
+      }
+      const checks = await Promise.all(
+        existing.map(async (entry) => {
+          const [comments, ready] = await Promise.all([
+            ctx.toolkit.codeReview.listUnresolvedComments(
+              entry.mrId,
+              repoPathFromUrl(entry.repoUrl),
+            ),
+            ctx.toolkit.codeReview.isReadyToMerge(
+              entry.mrId,
+              repoPathFromUrl(entry.repoUrl),
+            ),
+          ]);
+          return { entry, ready, comments };
+        }),
+      );
+      const repairTargets = checks.flatMap((check) => {
+        const comments = unhandledComments(
+          row["产出物"],
+          "review",
+          check.entry.mrId,
+          check.comments,
+        );
+        return comments.length ? [{ ...check, comments }] : [];
+      });
+      if (repairTargets.length) {
+        const repairRepos = repairTargets.map((target) => repos.find(
+          (repo) => repoPathFromUrl(repositoryUrl(repo)) === target.entry.repoUrl,
+        )!);
+        const repairWorktrees = await Promise.all(
+          repairRepos.map((repo) =>
+            ctx.toolkit.git.ensureWorktree(repo, id, id, worktreeOptions(repo)),
+          ),
+        );
+        const candidateWorktrees = repairWorktrees
+          .map((worktree, index) => `- ${repositoryUrl(repairRepos[index]!)}: ${resolveWorktreeDir(ctx.configDir, worktree.dir)}`)
+          .join("\n");
+        const repair = await ctx.toolkit.coding.run(
+          `## 候选业务 worktree
+${candidateWorktrees}
+公共父目录不是 Git 仓库；所有文件只能写入具体仓库 worktree。
+进入某仓库前先读取其根目录 AGENTS.md（若存在），并遵循其约定。
+
+${testDemandInstruction(row)}
+
+## 按仓库分组的未解决评论
+\`\`\`json
+${JSON.stringify(repairTargets.map((target) => ({
+  repo: target.entry.repoUrl,
+  mrId: target.entry.mrId,
+  comments: target.comments,
+})), null, 2)}
+\`\`\`
+
+## 已消费的人工答复
+${resumed.answers}
+
+## 本轮任务
+逐项修复评论并运行真实测试。
+在评论所属仓库的 ${artifactPath("review", id)} 更新处理结果。`.trim(),
+          {
+            sessionId: sessionMap(row["Agent会话ID"])["review:dev"],
+          },
+        );
+        if (!repair.success) {
+          return handleCodingFailure(
+            ctx,
+            row,
+            "review",
+            "review:dev",
+            repair,
+            "CR 评论修复 Agent 未完成",
+          );
+        }
+        const agentSession = await persistCodingSession(ctx, row, "review:dev", repair);
+        const commits = await Promise.all(
+          repairWorktrees.map((worktree) =>
+            ctx.toolkit.git.commit(worktree.dir, `${id}: review fixes`, commitOptions(row)),
+          ),
+        );
+        let artifacts = appendArtifact(
+          row["产出物"],
+          `${artifactName("review")}；评论修复commit=${commits.some((commit) => commit.committed) ? `${id}: review fixes` : "已存在"}`,
+        );
+        for (const target of repairTargets) {
+          artifacts = appendHandledComments(
+            artifacts,
+            "review",
+            target.entry.mrId,
+            target.comments,
+          );
+        }
+        const persisted = {
+          产出物: artifacts,
+          Agent会话ID: agentSession,
+          审查轮次: currentRound + 1,
+        };
+        const questions = agentQuestions(repair.response, "review");
+        if (questions.length) {
+          return blockExecution(
+            ctx,
+            "CR 评论修复仍有待确认问题",
+            "在人工答复中按问题编号逐项回答后自动续跑",
+            questionsText(questions),
+            persisted,
+          );
+        }
+        await Promise.all(
+          repairWorktrees.map((worktree) => ctx.toolkit.git.push(worktree.dir, id)),
+        );
+        return waitForExternalProgress(
+          ctx,
+          row,
+          "CR 评论已修复，等待复审",
+          "等待评审者关闭评论或提出新评论",
+          {
+            评审进展: commentRepairNotice(repairTargets.map((target) => ({
+              repoUrl: target.entry.repoUrl,
+              mrUrl: target.entry.mrUrl,
+              commentCount: target.comments.length,
+            }))),
+            ...persisted,
+          },
+        );
+      }
+      const pending = checks.filter(
+        (check) => !check.ready || check.comments.length > 0,
+      );
+      if (pending.length) {
+        return waitForExternalProgress(
+          ctx,
+          row,
+          `仍有 ${pending.length} 个 CR 未可合并或存在未解决评论`,
+          "等待审核通过，或等待新评论被自动修复",
+          { 当前角色: "Dev" },
+        );
+      }
+      // 代码 CR 的合并由仓库流程负责；本工作流完成条件只包含评审通过和评论清零。
+      const demandTitle = String(row["需求"] ?? "").trim();
+      if (!demandTitle) return failed("变更流水缺少关联需求，无法完成需求闭环");
+      const demand = await ctx.toolkit.table.findRecordIn(
+        { baseId: intakeTarget.base_id, tableId: intakeTarget.table_id },
+        "需求标题",
+        demandTitle,
+      );
+      if (!demand)
+        return failed(`未在需求池找到关联需求：${demandTitle}`);
+      // 先完成需求池回写，避免执行记录进入 shipped 后因下游表写失败而失去重试机会。
+      await ctx.toolkit.table.updateRecordIn(
+        { baseId: intakeTarget.base_id, tableId: intakeTarget.table_id },
+        demand.recordId,
+        { 需求状态: "已完成" },
+      );
+      await ctx.toolkit.table.updateCurrentRow({
+        当前阶段: "已发布",
+        当前角色: "人",
+        状态: "shipped",
+        当前CR链接: "",
+        评审进展: "",
+        阻塞原因: "",
+        解除条件: "",
+        审计日志: appendStageTransition(
+          row["审计日志"],
+          id,
+          "已发布",
+        ),
+      });
+      return success({}, "全部代码 CR 已通过评审且无未解决评论，变更与关联需求均已完成");
+    }
+  },
+};
+export default recipe;

package/templates/ai-native-sdlc/workflows/execution/recipes/spec-review.recipe.ts

@@ -0,0 +1,242 @@
+import type { RecipeDefinition } from "aitable-workflow-core";
+import { devStageConfig } from "../../../lib/recipe-config.js";
+import {
+  artifactName,
+  artifactPath,
+  resolveWorktreeDir,
+  stageBranchName,
+} from "../../../lib/artifacts.js";
+import {
+  agentQuestions,
+  appendArtifact,
+  appendHandledComments,
+  appendStageTransition,
+  blockExecution,
+  changeId,
+  commentRepairNotice,
+  commitOptions,
+  consumeAnswersOrBlock,
+  crEntries,
+  failed,
+  handleCodingFailure,
+  hasStageTransition,
+  isCurrentRecipe,
+  persistCodingSession,
+  questionsText,
+  repoPathFromUrl,
+  repositoryUrl,
+  requireRepositories,
+  sessionMap,
+  success,
+  testDemandInstruction,
+  unhandledComments,
+  waitForExternalProgress,
+  worktreeOptions,
+  MAX_REVIEW_ROUNDS,
+  parseReviewRound,
+} from "../../../lib/recipe-helpers.js";
+
+const recipe: RecipeDefinition = {
+  meta: {
+    id: "spec-review",
+    name: "技术方案评审",
+    role: "reviewer",
+    description: "Dev 跟踪技术方案 CR、处理评论，全部合并后进入编码",
+    version: "1.0.0",
+    requiresAgent: true,
+    config: devStageConfig,
+  },
+  async execute(ctx) {
+    const row = await ctx.toolkit.table.readCurrentRow();
+    const id = changeId(row);
+    const repos = requireRepositories(ctx, "dev_repositories");
+    if (!id || !repos.length)
+      return failed("技术方案评审缺少变更编号或 Dev 仓库配置");
+    if (!isCurrentRecipe(row, ctx.stepId))
+      return failed("当前步骤与技术方案评审 recipe 不一致");
+    if (hasStageTransition(row["审计日志"], id, "编码"))
+      return success({}, "恢复：技术方案已合并但步骤指针尚未推进");
+    // 有界重试：超过最大轮次则升级人工（放在恢复检查之后，避免误阻塞已完成阶段）
+    const currentRound = parseReviewRound(row);
+    if (currentRound > MAX_REVIEW_ROUNDS) {
+      return blocked(`技术方案评审修复已超过 ${MAX_REVIEW_ROUNDS} 轮，请人工介入`);
+    }
+    const resumed = await consumeAnswersOrBlock(ctx, row);
+    if (resumed.blocked) return resumed.blocked;
+    const entries = crEntries(row["当前CR链接"]);
+    if (!entries.length) return failed("技术方案评审缺少 spec 创建的 CR 链接");
+    const unknown = entries.find(
+      (entry) =>
+        !repos.some(
+          (repo) => repoPathFromUrl(repositoryUrl(repo)) === entry.repoUrl,
+        ),
+    );
+    if (unknown)
+      return failed(`技术方案 CR 不属于已配置的 Dev 仓库：${unknown.repoUrl}`);
+    const checks = await Promise.all(
+      entries.map(async (entry) => ({
+        entry,
+        comments: await ctx.toolkit.codeReview.listUnresolvedComments(
+          entry.mrId,
+          entry.repoUrl,
+        ),
+        merged: await ctx.toolkit.codeReview.isMerged(entry.mrId, entry.repoUrl),
+      })),
+    );
+    const repairs = checks.flatMap((check) => {
+      const comments = unhandledComments(
+        row["产出物"],
+        "spec-review",
+        check.entry.mrId,
+        check.comments,
+      );
+      return comments.length ? [{ ...check, comments }] : [];
+    });
+    if (repairs.length) {
+      const branch = stageBranchName("spec", id);
+      const repairRepos = repairs.map(
+        (repair) =>
+          repos.find(
+            (repo) =>
+              repoPathFromUrl(repositoryUrl(repo)) === repair.entry.repoUrl,
+          )!,
+      );
+      const worktrees = await Promise.all(
+        repairRepos.map((repo) =>
+          ctx.toolkit.git.ensureWorktree(
+            repo,
+            branch,
+            branch,
+            worktreeOptions(repo, id),
+          ),
+        ),
+      );
+      const candidateWorktrees = worktrees
+        .map(
+          (worktree, index) =>
+            `- ${repositoryUrl(repairRepos[index]!)}: ${resolveWorktreeDir(ctx.configDir, worktree.dir)}`,
+        )
+        .join("\n");
+      const repair = await ctx.toolkit.coding.run(
+        `## 候选技术方案 worktree
+${candidateWorktrees}
+公共父目录不是 Git 仓库；所有文件只能写入具体仓库 worktree。
+进入某仓库前先读取其根目录 AGENTS.md（若存在），并遵循其仓库约定。
+
+${testDemandInstruction(row)}
+
+## 按仓库分组的未解决评论
+\`\`\`json
+${JSON.stringify(
+  repairs.map((repair) => ({
+    repo: repair.entry.repoUrl,
+    mrId: repair.entry.mrId,
+    comments: repair.comments,
+  })),
+  null,
+  2,
+)}
+\`\`\`
+
+## 已消费的人工答复
+${resumed.answers}
+
+## 本轮任务
+逐项修复评论，更新 ${artifactPath("spec", id)}，并运行适用校验。`.trim(),
+        { sessionId: sessionMap(row["Agent会话ID"])["spec-review:dev"] },
+      );
+      if (!repair.success) {
+        return handleCodingFailure(
+          ctx,
+          row,
+          "spec-review",
+          "spec-review:dev",
+          repair,
+          "技术方案评论修复 Agent 未完成",
+        );
+      }
+      const session = await persistCodingSession(ctx, row, "spec-review:dev", repair);
+      const commits = await Promise.all(
+        worktrees.map((worktree) =>
+          ctx.toolkit.git.commit(
+            worktree.dir,
+            `${id}: spec review fixes`,
+            commitOptions(row),
+          ),
+        ),
+      );
+      let artifacts = appendArtifact(
+        row["产出物"],
+        `${artifactName("spec")}；评论修复commit=${commits.some((commit) => commit.committed) ? `${id}: spec review fixes` : "已存在"}`,
+      );
+      for (const repairTarget of repairs) {
+        artifacts = appendHandledComments(
+          artifacts,
+        "spec-review",
+          repairTarget.entry.mrId,
+          repairTarget.comments,
+        );
+      }
+      const persisted = { 产出物: artifacts, Agent会话ID: session, 审查轮次: currentRound + 1 };
+      const questions = agentQuestions(repair.response, "spec-review");
+      if (questions.length) {
+        return blockExecution(
+          ctx,
+          "技术方案评论修复仍有待确认问题",
+          "在人工答复中按问题编号逐项回答后自动续跑",
+          questionsText(questions),
+          persisted,
+        );
+      }
+      await Promise.all(
+        worktrees.map((worktree) => ctx.toolkit.git.push(worktree.dir, branch)),
+      );
+      return waitForExternalProgress(
+        ctx,
+        row,
+        "技术方案评论已修复，等待复审",
+        "等待评审者关闭评论或提出新评论",
+        {
+          评审进展: commentRepairNotice(repairs.map((repairTarget) => ({
+            repoUrl: repairTarget.entry.repoUrl,
+            mrUrl: repairTarget.entry.mrUrl,
+            commentCount: repairTarget.comments.length,
+          }))),
+          ...persisted,
+        },
+      );
+    }
+    if (checks.some((check) => !check.merged)) {
+      return waitForExternalProgress(
+        ctx,
+        row,
+        "技术方案 CR 尚未全部合并",
+        "请合并全部技术方案 CR；合并事实将自动进入编码",
+        { 当前角色: "Dev" },
+      );
+    }
+    await Promise.all(
+      entries.map((entry) => {
+        const repository = repos.find(
+          (repo) => repoPathFromUrl(repositoryUrl(repo)) === entry.repoUrl,
+        );
+        if (!repository) throw new Error(`技术方案 CR 仓库配置已失效：${entry.repoUrl}`);
+        return ctx.toolkit.git.syncWorktree(repository, id, id);
+      }),
+    );
+    await ctx.toolkit.table.updateCurrentRow({
+      当前阶段: "编码",
+      当前角色: "Dev",
+      状态: "active",
+      当前CR链接: "",
+      评审进展: "",
+      审计日志: appendStageTransition(row["审计日志"], id, "编码"),
+      AI问题: "",
+      阻塞原因: "",
+      解除条件: "",
+    });
+    return success({}, "全部技术方案 CR 已合并，进入编码");
+  },
+};
+
+export default recipe;

package/templates/ai-native-sdlc/workflows/execution/recipes/spec.recipe.ts

@@ -0,0 +1,173 @@
+import type { RecipeDefinition } from "aitable-workflow-core";
+import { planStageConfig } from "../../../lib/recipe-config.js";
+import {
+  artifactAbsPath,
+  artifactName,
+  artifactPath,
+  resolveWorktreeDir,
+  stageBranchName,
+} from "../../../lib/artifacts.js";
+import {
+  agentQuestions,
+  appendArtifact,
+  appendStageTransition,
+  blockExecution,
+  blocked,
+  changeId,
+  changeTitle,
+  commitOptions,
+  consumeAnswersOrBlock,
+  failed,
+  handleCodingFailure,
+  hasStageTransition,
+  isTestDemand,
+  isCurrentRecipe,
+  persistCodingSession,
+  questionsText,
+  recordValue,
+  repositoryUrl,
+  repoPathFromUrl,
+  formatCrEntries,
+  requireRepositories,
+  requireRepository,
+  sessionMap,
+  success,
+  testDemandInstruction,
+  worktreeOptions,
+} from "../../../lib/recipe-helpers.js";
+
+const recipe: RecipeDefinition = {
+  meta: {
+    id: "spec",
+    name: "技术方案",
+    role: "dev",
+    description: "Dev 基于已通过的 PRD 生成版本化技术方案",
+    version: "1.0.0",
+    requiresAgent: true,
+    config: planStageConfig,
+  },
+  async execute(ctx) {
+    const row = await ctx.toolkit.table.readCurrentRow();
+    const id = changeId(row);
+    const configuredRepos = requireRepositories(ctx, "dev_repositories");
+    const repos = isTestDemand(row) ? configuredRepos.slice(0, 1) : configuredRepos;
+    const pmRepository = requireRepository(ctx, "pm_repository");
+    if (!id || !repos.length || !pmRepository)
+      return failed("技术方案阶段缺少变更编号、PM 仓库或 Dev 候选仓库配置");
+    if (!isCurrentRecipe(row, ctx.stepId)) {
+      return blocked("当前步骤与执行 recipe 不一致，拒绝生成技术方案工件");
+    }
+    if (hasStageTransition(row["审计日志"], id, "技术方案评审")) {
+      return success({}, "恢复：技术方案 CR 已创建但步骤指针尚未推进");
+    }
+    const resumed = await consumeAnswersOrBlock(ctx, row);
+    if (resumed.blocked) return resumed.blocked;
+    const [pmWorktree, ...requirementWorktrees] = await Promise.all([
+      ctx.toolkit.git.ensureWorktree(
+        pmRepository,
+        id,
+        id,
+        worktreeOptions(pmRepository),
+      ),
+      ...repos.map((repo) =>
+        ctx.toolkit.git.ensureWorktree(repo, id, id, worktreeOptions(repo)),
+      ),
+    ]);
+    await Promise.all(requirementWorktrees.map((worktree) => ctx.toolkit.git.push(worktree.dir, id)));
+    const specBranch = stageBranchName("spec", id);
+    const specWorktrees = await Promise.all(
+      repos.map((repo) =>
+        ctx.toolkit.git.ensureWorktree(repo, specBranch, specBranch, worktreeOptions(repo, id)),
+      ),
+    );
+    const candidateWorktrees = specWorktrees
+      .map((worktree, index) => `- ${repositoryUrl(repos[index]!)}: ${resolveWorktreeDir(ctx.configDir, worktree.dir)}`)
+      .join("\n");
+    const result = await ctx.toolkit.coding.run(
+      `## 已合并 PRD（只读）
+PM worktree：${resolveWorktreeDir(ctx.configDir, pmWorktree.dir)}
+先读取：${artifactAbsPath("prd", resolveWorktreeDir(ctx.configDir, pmWorktree.dir), id)}
+
+## 候选业务 worktree
+${candidateWorktrees}
+公共父目录不是 Git 仓库；所有文件只能写入具体仓库 worktree。
+进入某仓库前先读取其根目录 AGENTS.md（若存在），并遵循其约定。
+
+${testDemandInstruction(row)}
+
+## 已消费的人工答复
+${resumed.answers}
+
+## 需求
+标题：${recordValue(row, "需求")}
+详情：${recordValue(row, "需求详情")}
+
+## 本轮任务
+依据角色规程选择要改的仓库。
+在每个选中仓库的 ${artifactPath("spec", id)} 写入技术方案；未选中仓库不写。
+明确列出选中/未选中仓库及理由，并列出文件、风险和测试命令。`.trim(),
+      {
+        sessionId: sessionMap(row["Agent会话ID"])["spec:dev"],
+      },
+    );
+    if (!result.success) {
+      return handleCodingFailure(
+        ctx,
+        row,
+        "spec",
+        "spec:dev",
+        result,
+        "技术方案 Agent 未完成",
+      );
+    }
+    const agentSession = await persistCodingSession(ctx, row, "spec:dev", result);
+    const commits = await Promise.all(
+      specWorktrees.map((worktree) =>
+        ctx.toolkit.git.commit(worktree.dir, `${id}: spec`, commitOptions(row)),
+      ),
+    );
+    const questions = agentQuestions(result.response, "spec");
+    const persisted = {
+      产出物: appendArtifact(
+        row["产出物"],
+        `${artifactName("spec")}；commit=${commits.some((commit) => commit.committed) ? `${id}: spec` : "已存在"}`,
+      ),
+      Agent会话ID: agentSession,
+    };
+    if (questions.length) {
+      return blockExecution(
+        ctx,
+        "技术方案存在待确认问题",
+        "在人工答复中按问题编号逐项回答后自动续跑",
+        questionsText(questions),
+        persisted,
+      );
+    }
+    const diffs = await Promise.all(specWorktrees.map((worktree) => ctx.toolkit.git.diff(worktree.dir, id)));
+    const changed = specWorktrees.filter((_, index) => diffs[index]!.files.length > 0);
+    if (!changed.length) return failed("技术方案完成后没有相对需求分支的已提交改动，无法创建技术方案 CR");
+    const entries = await Promise.all(changed.map(async (worktree) => {
+      const repository = repos[specWorktrees.indexOf(worktree)]!;
+      const repoUrl = repositoryUrl(repository);
+      await ctx.toolkit.git.push(worktree.dir, specBranch);
+      const mr = await ctx.toolkit.codeReview.createMR(
+        repoPathFromUrl(repoUrl), specBranch, id, `${changeTitle(row, id)} · 技术方案`,
+        `请评审 ${artifactPath("spec", id)}；合并后才会进入编码。`,
+      );
+      return { repoUrl, mrId: mr.mrId, mrUrl: mr.mrUrl };
+    }));
+    await ctx.toolkit.table.updateCurrentRow({
+      当前阶段: "技术方案评审",
+      当前角色: "Dev",
+      状态: "active",
+      当前CR链接: formatCrEntries(entries),
+      审计日志: appendStageTransition(row["审计日志"], id, "技术方案评审"),
+      AI问题: "",
+      阻塞原因: "",
+      解除条件: "",
+      ...persisted,
+    });
+    return success({}, "技术方案工件已提交并创建技术方案 CR");
+  },
+};
+export default recipe;