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

package/templates/ai-native-sdlc/test/recipe-helpers.test.ts

@@ -0,0 +1,931 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+import { readFileSync } from "node:fs";
+import { resolve } from "node:path";
+import { parse } from "yaml";
+import {
+  agentQuestions,
+  answersForQuestions,
+  changeTitle,
+  commentRepairNotice,
+  consumeAnswersOrBlock,
+  crId,
+  crEntries,
+  formatCrEntries,
+  hasHandledComments,
+  handleCodingFailure,
+  isTestDemand,
+  appendHandledComments,
+  persistCodingSession,
+  parseAnswers,
+  questionsText,
+  repoPathFromUrl,
+  testDemandInstruction,
+  commitOptions,
+  worktreeOptions,
+  buildChangeDetails,
+  unhandledComments,
+  waitForExternalProgress,
+  unansweredQuestions,
+} from "../lib/recipe-helpers.js";
+
+test("构建改动详情只取 build 工件的指定章节", () => {
+  assert.equal(
+    buildChangeDetails("# 构建\n\n## 改动内容\n\n- 新增导出\n\n## 测试命令与结果\n\npnpm test"),
+    "- 新增导出",
+  );
+  assert.equal(buildChangeDetails("## 测试命令与结果\n\npnpm test"), undefined);
+  assert.equal(buildChangeDetails("## 改动内容\n\n  \n## CI 证据\n通过"), undefined);
+});
+
+test("仅精确测试标题注入收窄代码库调研的提示", () => {
+  assert.match(testDemandInstruction({ 标题: "【测试】新增冒烟工件" }), /不得调研/);
+  assert.equal(testDemandInstruction({ 标题: "新增冒烟工件" }), "");
+  assert.equal(isTestDemand({ 需求: "【测试】兼容旧标题字段" }), true);
+  assert.equal(isTestDemand({ 标题: "测试】错误标记" }), false);
+  assert.deepEqual(commitOptions({ 标题: "【测试】新增冒烟工件" }), { noVerify: true });
+  assert.equal(commitOptions({ 标题: "新增冒烟工件" }), undefined);
+  assert.deepEqual(
+    worktreeOptions({ url: "git@example.test:repo.git", default_branch: "master" }),
+    { baseRef: "master" },
+  );
+});
+
+test("仓库在 profile YAML anchor 中只定义一次，steps 使用完整结构 alias", () => {
+  const source = readFileSync(resolve("profile/profile.yml"), "utf8");
+  const profile = parse(source) as {
+    workflows?: { execution?: { steps?: Record<string, Record<string, unknown>> } };
+  };
+  const steps = profile.workflows?.execution?.steps;
+
+  assert.match(source, /we_notable:\s*&we_notable/);
+  assert.match(source, /dev_repositories:\s*\[\*we_notable, \*lippi_notable\]/);
+  assert.deepEqual(steps?.spec?.dev_repositories, [
+    {
+      url: "git@gitlab.alibaba-inc.com:alidocs/we-notable.git",
+      default_branch: "origin/master",
+      commands: [{ bin: "pnpm", args: ["install", "--frozen-lockfile"], timeout_ms: 1200000 }],
+    },
+    {
+      url: "git@gitlab.alibaba-inc.com:alidocs/lippi-doc-notable.git",
+      default_branch: "origin/master",
+    },
+  ]);
+});
+
+test("执行流正常走完时首个终态为 shipped", () => {
+  const workflow = parse(readFileSync(resolve("workflows/execution/workflow.yml"), "utf8")) as {
+    tracker?: { states?: { terminal?: string[] } };
+  };
+
+  assert.equal(workflow.tracker?.states?.terminal?.[0], "shipped");
+});
+
+test("执行流将角色路由和阶段幂等字段明确命名", () => {
+  const workflow = parse(readFileSync(resolve("workflows/execution/workflow.yml"), "utf8")) as {
+    tracker?: { field_definitions?: Array<{ name: string }> };
+  };
+  const names = workflow.tracker?.field_definitions?.map((field) => field.name) ?? [];
+
+  assert.ok(names.includes("当前角色"));
+  assert.ok(names.includes("审计日志"));
+  assert.ok(!names.includes("属主"));
+  assert.ok(!names.includes("阶段跃迁审计"));
+});
+import mechanicalDeduplicate from "../workflows/intake/recipes/mechanical-deduplicate.recipe.js";
+import createChange from "../workflows/intake/recipes/create-change.recipe.js";
+import classifyModule from "../workflows/intake/recipes/classify-module.recipe.js";
+import review from "../workflows/execution/recipes/review.recipe.js";
+
+test("问题必须按编号逐项获得人工答复", () => {
+  const questions = JSON.stringify([
+    { id: "plan-Q1", question: "需要支持哪些客户端？" },
+    { id: "plan-Q2", question: "是否允许灰度？" },
+  ]);
+  const answers = JSON.stringify([{ id: "plan-Q1", answer: "Web 和移动端" }]);
+
+  assert.deepEqual(unansweredQuestions(questions, answers), [
+    { id: "plan-Q2", question: "是否允许灰度？" },
+  ]);
+  assert.equal(answersForQuestions(questions, answers), answers);
+});
+
+test("Agent 问题保留显式编号并兼容旧字符串格式", () => {
+  assert.deepEqual(
+    agentQuestions('SDLC_QUESTIONS=[{"id":"build-Q9","question":"需要开关吗？"}]', "build"),
+    [{ id: "build-Q9", question: "需要开关吗？" }],
+  );
+  assert.deepEqual(agentQuestions('SDLC_QUESTIONS=["是否兼容旧接口？"]', "build"), [
+    { id: "build-Q1", question: "是否兼容旧接口？" },
+  ]);
+});
+
+test("AI 问题以人可读的 Q 编号写入，人工答复可按相同编号恢复", () => {
+  const questions = questionsText([
+    { id: "prd-Q9", question: "是否需要灰度发布？" },
+    { id: "prd-Q10", question: "是否保留旧入口？" },
+  ]);
+
+  assert.equal(questions, "Q1: 是否需要灰度发布？\nQ2: 是否保留旧入口？");
+  assert.deepEqual(unansweredQuestions(questions, "Q1: 需要灰度发布"), [
+    { id: "Q2", question: "是否保留旧入口？" },
+  ]);
+});
+
+test("Agent 问题文本含 ] 时不被截断丢弃", () => {
+  // 旧非贪婪正则会在第一个 ] 处截断，JSON.parse 失败并静默丢掉全部问题。
+  assert.deepEqual(
+    agentQuestions(
+      'SDLC_QUESTIONS=["需覆盖哪些表格产品？请确认是否包含 [+ viewId] 形态","第二个问题"]',
+      "prd",
+    ),
+    [
+      { id: "prd-Q1", question: "需覆盖哪些表格产品？请确认是否包含 [+ viewId] 形态" },
+      { id: "prd-Q2", question: "第二个问题" },
+    ],
+  );
+  assert.deepEqual(
+    agentQuestions(
+      '前置说明 SDLC_QUESTIONS=[{"id":"prd-Q9","question":"选项 (a)/(b) [见附录] 如何取舍？"}] 收尾散文',
+      "prd",
+    ),
+    [{ id: "prd-Q9", question: "选项 (a)/(b) [见附录] 如何取舍？" }],
+  );
+});
+
+test("评论按 ID 去重，不受行号漂移或同批评论增减影响", () => {
+  const first = { id: 7, note: "补测试", author: "reviewer", path: "a.ts", line: 12, createdAt: "" };
+  const second = { id: 8, note: "补文档", author: "reviewer", path: "README.md", line: 3, createdAt: "" };
+  const previous = appendHandledComments("", "review", "42", [first]);
+
+  assert.equal(hasHandledComments(previous, "review", "42", [{ ...first, line: 4 }]), true);
+  assert.deepEqual(unhandledComments(previous, "review", "42", [{ ...first, line: 4 }, second]), [second]);
+  assert.deepEqual(unhandledComments(previous, "review", "42", [second]), [second]);
+});
+
+test("当前 CR 链接同时兼容纯详情链接与历史 ID 标记", () => {
+  assert.equal(
+    crId("https://code.alibaba-inc.com/group/project/codereview/30086655"),
+    "30086655",
+  );
+  assert.equal(
+    crId("[去评审](https://code.alibaba-inc.com/group/project/codereview/30086655?from=table)"),
+    "30086655",
+  );
+  assert.equal(crId("- `group/project`: [!42](https://example.test/42)"), "42");
+  assert.equal(crId("https://code.alibaba-inc.com/group/project"), undefined);
+});
+
+test("人工易读答复格式也可以恢复", () => {
+  assert.deepEqual(parseAnswers("plan-Q1: Web 和移动端"), [
+    { id: "plan-Q1", answer: "Web 和移动端" },
+  ]);
+});
+
+test("CR 等待保持 active，且相同等待事实不会重复回写", async () => {
+  const updates: Record<string, unknown>[] = [];
+  const row = {
+    状态: "active",
+    阻塞原因: "PRD CR 尚未通过或仍有未解决评论",
+    解除条件: "等待审核通过，或等待新评论被自动修复",
+    当前角色: "PM",
+  };
+  const context = {
+    toolkit: {
+      table: {
+        updateCurrentRow: async (values: Record<string, unknown>) => {
+          updates.push(values);
+        },
+      },
+    },
+  };
+
+  const result = await waitForExternalProgress(
+    context as never,
+    row,
+    "PRD CR 尚未通过或仍有未解决评论",
+    "等待审核通过，或等待新评论被自动修复",
+    { 当前角色: "PM" },
+  );
+
+  assert.equal(result.status, "needs_human");
+  assert.deepEqual(updates, []);
+});
+
+test("Agent 原生提问转为可由人工答复恢复的 blocked", async () => {
+  const updates: Record<string, unknown>[] = [];
+  const result = await handleCodingFailure(
+    {
+      toolkit: {
+        table: {
+          updateCurrentRow: async (values: Record<string, unknown>) => {
+            updates.push(values);
+          },
+        },
+      },
+    } as never,
+    { Agent会话ID: "{}" },
+    "build",
+    "build:dev",
+    {
+      success: false,
+      response: "ASK_HUMAN_DETECTED: 是否允许修改兼容层？",
+      sessionId: "session-1",
+    },
+    "构建 Agent 未完成",
+  );
+
+  assert.equal(result.status, "blocked");
+  assert.deepEqual(updates, [{
+    状态: "blocked",
+    阻塞原因: "build 阶段需要人工答复",
+    解除条件: "在人工答复中按问题编号逐项回答后自动续跑",
+    AI问题: "Q1: 是否允许修改兼容层？",
+    Agent会话ID: JSON.stringify({ "build:dev": "session-1" }),
+  }]);
+});
+
+test("成功的 Agent session 在 Git 后置操作前持久化", async () => {
+  const updates: Record<string, unknown>[] = [];
+  const session = await persistCodingSession(
+    {
+      toolkit: {
+        table: {
+          updateCurrentRow: async (values: Record<string, unknown>) => {
+            updates.push(values);
+          },
+        },
+      },
+    } as never,
+    { Agent会话ID: "{}" },
+    "prd:pm",
+    { success: true, response: "已完成", sessionId: "session-2" },
+  );
+
+  assert.equal(session, JSON.stringify({ "prd:pm": "session-2" }));
+  assert.deepEqual(updates, [{ Agent会话ID: session }]);
+});
+
+test("成功但未返回 sessionId 时不产生无意义表格写入", async () => {
+  const updates: Record<string, unknown>[] = [];
+  const session = await persistCodingSession(
+    {
+      toolkit: {
+        table: {
+          updateCurrentRow: async (values: Record<string, unknown>) => {
+            updates.push(values);
+          },
+        },
+      },
+    } as never,
+    { Agent会话ID: '{"prd:pm":"old-session"}' },
+    "prd:pm",
+    { success: true, response: "已完成" },
+  );
+
+  assert.equal(session, '{"prd:pm":"old-session"}');
+  assert.deepEqual(updates, []);
+});
+
+test("非提问类失败把超时等根因写进 trace logs 与阻塞原因", async () => {
+  const updates: Record<string, unknown>[] = [];
+  const result = await handleCodingFailure(
+    {
+      toolkit: {
+        table: {
+          updateCurrentRow: async (values: Record<string, unknown>) => {
+            updates.push(values);
+          },
+        },
+      },
+    } as never,
+    { Agent会话ID: "{}" },
+    "prd",
+    "prd:pm",
+    {
+      success: false,
+      response: "coding agent 执行超时 (600000ms)",
+      // 引擎超时不回传 sessionId
+    },
+    "PRD Agent 未完成",
+  );
+
+  assert.equal(result.status, "blocked");
+  const logs = (result.logs ?? []).join("\n");
+  assert.match(logs, /coding agent 执行超时 \(600000ms\)/);
+  assert.match(logs, /PRD Agent 未完成｜coding agent 执行超时/);
+  assert.equal(updates.length, 1);
+  assert.match(String(updates[0]!["阻塞原因"]), /PRD Agent 未完成｜coding agent 执行超时/);
+  assert.match(String(updates[0]!["解除条件"]), /调整 timeoutMs|人工确认/);
+});
+
+test("执行工作流只轮询 active，避免 blocked 问答重复执行", () => {
+  const workflow = parse(
+    readFileSync(resolve("workflows/execution/workflow.yml"), "utf8"),
+  ) as { tracker?: { states?: { active?: string[] } } };
+
+  assert.deepEqual(workflow.tracker?.states?.active, ["active"]);
+});
+
+test("需求池状态使用开发生命周期而非已合并", () => {
+  const workflow = parse(
+    readFileSync(resolve("workflows/intake/workflow.yml"), "utf8"),
+  ) as {
+    tracker?: { field_definitions?: Array<{ name: string; options?: string[] }> };
+  };
+
+  const demandState = workflow.tracker?.field_definitions?.find(
+    (field) => field.name === "需求状态",
+  );
+  assert.deepEqual(demandState?.options, [
+    "待评估",
+    "已接受",
+    "开发中",
+    "已完成",
+    "已驳回",
+    "待澄清",
+  ]);
+});
+
+test("PRD 与技术方案均使用独立评审步骤和用户可见阶段", () => {
+  const workflow = parse(
+    readFileSync(resolve("workflows/execution/workflow.yml"), "utf8"),
+  ) as {
+    steps?: Array<{ id: string }>;
+    edges?: Array<{ from: string; to: string }>;
+    tracker?: { field_definitions?: Array<{ name: string; options?: string[] }> };
+  };
+
+  assert.deepEqual(
+    workflow.steps?.map((step) => step.id),
+    ["prd", "prd_review", "spec", "spec_review", "coding", "review"],
+  );
+  assert.deepEqual(
+    workflow.edges?.filter(
+      (edge) =>
+        edge.from === "__start__" || edge.from === "prd" || edge.from === "prd_review",
+    ),
+    [
+      { from: "__start__", to: "prd" },
+      { from: "prd", to: "prd_review" },
+      { from: "prd_review", to: "spec" },
+    ],
+  );
+  assert.ok(
+    workflow.tracker?.field_definitions
+      ?.find((field) => field.name === "当前阶段")
+      ?.options?.includes("PRD 评审"),
+  );
+  assert.ok(
+    workflow.tracker?.field_definitions
+      ?.find((field) => field.name === "当前阶段")
+    ?.options?.includes("技术方案评审"),
+  );
+});
+
+test("CR 待审通知展示当前 CR 链接列表，不使用单一去评审按钮", () => {
+  for (const file of ["cr-review.json", "cr-review-dev.json"]) {
+    const automation = JSON.parse(
+      readFileSync(resolve("workflows/execution/automations", file), "utf8"),
+    ) as {
+      steps?: { start?: { data?: { updatedFields?: string[] } }; send?: { data?: { content?: Array<{ text?: string; ref?: string }>; buttons?: unknown } } };
+    };
+    assert.ok(automation.steps?.start?.data?.updatedFields?.includes("<评审进展_fieldId>"));
+    assert.equal(automation.steps?.send?.data?.buttons, undefined);
+    assert.deepEqual(automation.steps?.send?.data?.content?.slice(-2), [
+      { text: "\n评审链接：\n" },
+      { ref: "$.start.<当前CR链接_fieldId>", title: "待评审 CR" },
+    ]);
+  }
+});
+
+test("评论修复通知按仓库报告数量，评审链接由当前 CR 字段展示", () => {
+  assert.equal(
+    commentRepairNotice([
+      { repoUrl: "alidocs/repo-a", mrUrl: "https://code.example.com/a", commentCount: 3 },
+      { repoUrl: "alidocs/repo-b", mrUrl: "https://code.example.com/b", commentCount: 2 },
+    ]),
+    "repo-a：本轮已修复3条评论、已推送，等待复审\nrepo-b：本轮已修复2条评论、已推送，等待复审",
+  );
+});
+
+test("当前 CR 链接只展示可点击的仓库短名，并能还原评审所需信息", () => {
+  const entries = [{
+    repoUrl: "git@gitlab.alibaba-inc.com:alidocs/we-notable.git",
+    mrId: "30154119",
+    mrUrl: "https://code.alibaba-inc.com/alidocs/we-notable/codereview/30154119",
+  }];
+  const formatted = formatCrEntries(entries);
+
+  assert.equal(
+    formatted,
+    "- [we-notable](https://code.alibaba-inc.com/alidocs/we-notable/codereview/30154119)",
+  );
+  assert.deepEqual(crEntries(formatted), [{
+    repoUrl: "alidocs/we-notable",
+    mrId: "30154119",
+    mrUrl: "https://code.alibaba-inc.com/alidocs/we-notable/codereview/30154119",
+  }]);
+});
+
+test("执行通知正文均先展示需求名称", () => {
+  for (const file of [
+    "blocked-questions.json",
+    "blocked-questions-dev.json",
+    "cr-review.json",
+    "cr-review-dev.json",
+  ]) {
+    const automation = JSON.parse(
+      readFileSync(resolve("workflows/execution/automations", file), "utf8"),
+    ) as { steps?: { send?: { data?: { content?: Array<{ text?: string; ref?: string }> } } } };
+    const content = automation.steps?.send?.data?.content ?? [];
+    assert.ok(content.some((item) => item.ref === "$.start.<需求_fieldId>"));
+    if (file.startsWith("cr-review")) {
+      assert.ok(content.some((item) => item.ref === "$.start.<当前阶段_fieldId>"));
+    }
+  }
+});
+
+type MechanicalContext = {
+  toolkit: {
+    table: {
+      readCurrentRow: () => Promise<Record<string, unknown>>;
+      queryRows: (filter: Record<string, string>, limit: number) => Promise<unknown[]>;
+      updateCurrentRow: (values: Record<string, unknown>) => Promise<void>;
+    };
+  };
+};
+
+const executeMechanicalDeduplicate = mechanicalDeduplicate.execute as unknown as (
+  ctx: MechanicalContext,
+) => Promise<{ status: string }>;
+
+test("机械去重只按需求标题拦截重复项，不调用 Agent", async () => {
+  const updates: Record<string, unknown>[] = [];
+  const result = await executeMechanicalDeduplicate({
+    toolkit: {
+      table: {
+        readCurrentRow: async () => ({ 需求标题: "支持多维表导出" }),
+        queryRows: async (filter, limit) => {
+          assert.deepEqual(filter, { 需求标题: "支持多维表导出" });
+          assert.equal(limit, 3);
+          return [{}, {}];
+        },
+        updateCurrentRow: async (values) => {
+          updates.push(values);
+        },
+      },
+    },
+  });
+
+  assert.equal(result.status, "blocked");
+  assert.deepEqual(updates, [{
+    需求状态: "待澄清",
+    产出物: "机械去重：发现相同标题的已有需求",
+  }]);
+});
+
+test("唯一标题直接通过机械去重", async () => {
+  const result = await executeMechanicalDeduplicate({
+    toolkit: {
+      table: {
+        readCurrentRow: async () => ({ 需求标题: "修复导出乱码" }),
+        queryRows: async () => [{}],
+        updateCurrentRow: async () => {},
+      },
+    },
+  });
+
+  assert.equal(result.status, "success");
+});
+
+test("消费答复后同时清空人工答复，旧答案不能冒充新问题的答复", async () => {
+  const updates: Record<string, unknown>[] = [];
+  const row = {
+    AI问题: JSON.stringify([{ id: "plan-Q1", question: "需要支持哪些客户端？" }]),
+    人工答复: "plan-Q1: Web 和移动端",
+  };
+
+  const result = await consumeAnswersOrBlock(
+    {
+      toolkit: {
+        table: {
+          updateCurrentRow: async (values: Record<string, unknown>) => {
+            updates.push(values);
+          },
+        },
+      },
+    } as never,
+    row,
+  );
+
+  assert.equal(result.blocked, undefined);
+  assert.deepEqual(JSON.parse(result.answers), [
+    { id: "plan-Q1", answer: "Web 和移动端" },
+  ]);
+  assert.deepEqual(updates, [{
+    状态: "active",
+    阻塞原因: "",
+    解除条件: "",
+    AI问题: "",
+    人工答复: "",
+  }]);
+});
+
+type CreatedRecord = Record<string, unknown>;
+
+const executeCreateChange = createChange.execute as unknown as (
+  ctx: unknown,
+) => Promise<{ status: string }>;
+
+function createChangeContext(
+  row: Record<string, unknown>,
+  created: CreatedRecord[],
+  existing?: { recordId: string },
+  updates: CreatedRecord[] = [],
+) {
+  return {
+    stepId: "create_change",
+    config: { execution_tracker: { base_id: "base", table_id: "table" } },
+    toolkit: {
+      table: {
+        readCurrentRow: async () => row,
+        findRecordIn: async () => existing,
+        createRecordIn: async (_ref: unknown, fields: CreatedRecord) => {
+          created.push(fields);
+          return { recordId: "rec-new" };
+        },
+        updateCurrentRow: async (fields: CreatedRecord) => {
+          updates.push(fields);
+        },
+      },
+    },
+  };
+}
+
+const acceptedIntake = (title: string) => ({
+  需求状态: "已接受",
+  需求标题: title,
+  需求详情: "支持导出，需兼容现有权限与异步任务。",
+  模块: "前端与交互",
+});
+
+test("不同中文标题的需求生成不同的变更编号", async () => {
+  const created: CreatedRecord[] = [];
+  await executeCreateChange(
+    createChangeContext(acceptedIntake("支持多维表导出"), created),
+  );
+  await executeCreateChange(
+    createChangeContext(acceptedIntake("修复导出乱码"), created),
+  );
+
+  assert.equal(created.length, 2);
+  const [first, second] = created.map((record) => String(record["变更编号"]));
+  assert.match(first, /^CHG-\d{8}-change-[a-z0-9]{6}$/);
+  assert.notEqual(first, second);
+});
+
+test("同一需求重试生成相同变更编号并复用已有记录", async () => {
+  const created: CreatedRecord[] = [];
+  const row = acceptedIntake("支持多维表导出");
+  await executeCreateChange(createChangeContext(row, created));
+  const id = String(created[0]!["变更编号"]);
+
+  const reused: CreatedRecord[] = [];
+  const result = await executeCreateChange(
+    createChangeContext(row, reused, { recordId: "rec-existing" }),
+  );
+
+  assert.equal(result.status, "success");
+  assert.equal(reused.length, 0);
+  assert.ok(id.length > 0);
+});
+
+test("创建变更后需求进入开发中", async () => {
+  const created: CreatedRecord[] = [];
+  const updates: CreatedRecord[] = [];
+  await executeCreateChange(
+    createChangeContext(acceptedIntake("支持多维表导出"), created, undefined, updates),
+  );
+
+  assert.deepEqual(updates, [{
+    产出物: "变更流水记录：rec-new",
+    需求状态: "开发中",
+  }]);
+});
+
+test("创建变更将富文本需求详情复制到执行记录", async () => {
+  const created: CreatedRecord[] = [];
+  await executeCreateChange(createChangeContext(acceptedIntake("支持多维表导出"), created));
+  assert.equal(created[0]!["需求详情"], "支持导出，需兼容现有权限与异步任务。");
+});
+
+test("singleSelect 单元格以对象形态读回时仍能识别已接受状态", async () => {
+  const created: CreatedRecord[] = [];
+  const row = {
+    需求状态: { id: "AZXa4bwhUQ", name: "已接受" },
+    需求标题: "支持多维表导出",
+    模块: "前端与交互",
+  };
+  const result = await executeCreateChange(createChangeContext(row, created));
+
+  assert.equal(result.status, "success");
+  assert.equal(created.length, 1);
+  assert.match(
+    String(created[0]!["变更编号"]),
+    /^CHG-\d{8}-change-[a-z0-9]{6}$/,
+  );
+});
+
+test("singleSelect 单元格为非已接受状态时保持 needs_human 自轮询等待受理", async () => {
+  const created: CreatedRecord[] = [];
+  const row = {
+    需求状态: { id: "pending", name: "待评估" },
+    需求标题: "支持多维表导出",
+    模块: "前端与交互",
+  };
+  const result = await executeCreateChange(createChangeContext(row, created));
+
+  assert.equal(result.status, "needs_human");
+  assert.equal(created.length, 0);
+});
+
+const executeReview = review.execute as unknown as (
+  ctx: unknown,
+) => Promise<{ status: string }>;
+
+test("全部代码 CR 通过评审且无未解决评论后将关联需求写为已完成", async () => {
+  const intakeUpdates: Array<{ recordId: string; fields: CreatedRecord }> = [];
+  const executionUpdates: CreatedRecord[] = [];
+  const repo = "git@gitlab.alibaba-inc.com:alidocs/we-notable.git";
+
+  const result = await executeReview({
+    stepId: "review",
+    config: {
+      dev_repositories: [{ url: repo, default_branch: "master" }],
+      intake_tracker: { base_id: "intake-base", table_id: "intake-table" },
+    },
+    toolkit: {
+      table: {
+        readCurrentRow: async () => ({
+          变更编号: "CHG-20260917-complete",
+          需求: "支持多维表导出",
+          当前步骤: "review",
+          当前CR链接: "- [we-notable](https://code.alibaba-inc.com/alidocs/we-notable/codereview/42)",
+          审计日志: "",
+        }),
+        findRecordIn: async (target: unknown, field: string, value: string) => {
+          assert.deepEqual(target, { baseId: "intake-base", tableId: "intake-table" });
+          assert.equal(field, "需求标题");
+          assert.equal(value, "支持多维表导出");
+          return { recordId: "demand-record" };
+        },
+        updateRecordIn: async (
+          _target: unknown,
+          recordId: string,
+          fields: CreatedRecord,
+        ) => {
+          intakeUpdates.push({ recordId, fields });
+        },
+        updateCurrentRow: async (fields: CreatedRecord) => {
+          executionUpdates.push(fields);
+        },
+      },
+      git: {
+        ensureWorktree: async () => ({ dir: "/tmp/worktree" }),
+      },
+      codeReview: {
+        listUnresolvedComments: async () => [],
+        isReadyToMerge: async () => true,
+        isMerged: async () => {
+          throw new Error("review 不应查询 CR 是否已合并");
+        },
+      },
+    },
+  });
+
+  assert.equal(result.status, "success");
+  assert.deepEqual(intakeUpdates, [{
+    recordId: "demand-record",
+    fields: { 需求状态: "已完成" },
+  }]);
+  assert.deepEqual(executionUpdates, [{
+    当前阶段: "已发布",
+    当前角色: "人",
+    状态: "shipped",
+    当前CR链接: "",
+    评审进展: "",
+    阻塞原因: "",
+    解除条件: "",
+    审计日志: "CHG-20260917-complete+已发布",
+  }]);
+});
+
+test("CR 未可合并但无评论时保持 active 轮询，且不创建 worktree", async () => {
+  let worktreeCalls = 0;
+  const updates: CreatedRecord[] = [];
+  const repo = "git@gitlab.alibaba-inc.com:alidocs/we-notable.git";
+
+  const result = await executeReview({
+    stepId: "review",
+    config: {
+      dev_repositories: [{ url: repo, default_branch: "master" }],
+      intake_tracker: { base_id: "intake-base", table_id: "intake-table" },
+    },
+    toolkit: {
+      table: {
+        readCurrentRow: async () => ({
+          变更编号: "CHG-20260920-wait-review",
+          当前步骤: "review",
+          当前CR链接: "- [we-notable](https://code.alibaba-inc.com/alidocs/we-notable/codereview/42)",
+          状态: "active",
+        }),
+        updateCurrentRow: async (fields: CreatedRecord) => {
+          updates.push(fields);
+        },
+      },
+      git: {
+        ensureWorktree: async () => {
+          worktreeCalls += 1;
+          return { dir: "/tmp/worktree" };
+        },
+      },
+      codeReview: {
+        listUnresolvedComments: async () => [],
+        isReadyToMerge: async () => false,
+      },
+    },
+  });
+
+  assert.equal(result.status, "needs_human");
+  assert.equal(worktreeCalls, 0);
+  assert.deepEqual(updates, [{
+    阻塞原因: "仍有 1 个 CR 未可合并或存在未解决评论",
+    解除条件: "等待审核通过，或等待新评论被自动修复",
+    当前角色: "Dev",
+  }]);
+});
+
+test("repoPathFromUrl 把 clone URL 解析成 a1 需要的 group/project", () => {
+  assert.equal(
+    repoPathFromUrl("git@gitlab.alibaba-inc.com:xule-test/ai-staff.git"),
+    "xule-test/ai-staff",
+  );
+  assert.equal(
+    repoPathFromUrl("https://gitlab.alibaba-inc.com/xule-test/ai-staff.git"),
+    "xule-test/ai-staff",
+  );
+  assert.equal(repoPathFromUrl("xule-test/ai-staff"), "xule-test/ai-staff");
+  assert.equal(repoPathFromUrl(""), "");
+});
+
+test("changeTitle 优先用标题，缺失时退回需求再退回变更编号", () => {
+  assert.equal(
+    changeTitle({ 标题: "支持直接输入表格链接", 需求: "同步需求" }, "CHG-1"),
+    "支持直接输入表格链接",
+  );
+  assert.equal(changeTitle({ 需求: "同步需求" }, "CHG-1"), "同步需求");
+  assert.equal(changeTitle({}, "CHG-1"), "CHG-1");
+});
+
+test("review 缺少 build 创建的 CR 时阻塞而不调用 Agent", async () => {
+  const repo = "git@gitlab.alibaba-inc.com:alidocs/we-notable.git";
+  const mrCalls: Array<{ repo: string; title: string }> = [];
+  let agentCalls = 0;
+
+  const result = await executeReview({
+    stepId: "review",
+    config: {
+      dev_repositories: [{ url: repo, default_branch: "master" }],
+      intake_tracker: { base_id: "intake-base", table_id: "intake-table" },
+    },
+    toolkit: {
+      table: {
+        readCurrentRow: async () => ({
+          变更编号: "CHG-20260917-build",
+          标题: "钉钉表格数据源同步支持直接输入钉钉表格链接",
+          当前步骤: "review",
+          当前CR链接: "",
+          审计日志: "",
+        }),
+        updateCurrentRow: async () => {},
+      },
+      git: {
+        ensureWorktree: async () => ({ dir: "/tmp/worktree" }),
+        commit: async () => ({ committed: true }),
+        diff: async () => ({ files: [{ path: "changes/x/06-review.md" }] }),
+        push: async () => {},
+      },
+      coding: {
+        run: async () => {
+          agentCalls += 1;
+          return { success: true, response: "已完成评审" };
+        },
+      },
+      codeReview: {
+        createMR: async (
+          repoArg: string,
+          _source: string,
+          _target: string,
+          title: string,
+        ) => {
+          mrCalls.push({ repo: repoArg, title });
+          return { mrId: "77", mrUrl: "https://example.test/77" };
+        },
+      },
+    },
+  });
+
+  assert.equal(result.status, "blocked");
+  assert.equal(mrCalls.length, 0);
+  assert.equal(agentCalls, 0);
+});
+
+// ── classify-module：等待人工一律 needs_human（行保持 active 可自推进），不得用 blocked ──
+
+const executeClassifyModule = classifyModule.execute as unknown as (
+  ctx: unknown,
+) => Promise<{ status: string; blockReason?: string }>;
+
+function classifyModuleContext(
+  row: Record<string, unknown>,
+  modules: Array<{ fields: Record<string, unknown> }>,
+  agentResponse: string | null,
+  updates: CreatedRecord[] = [],
+) {
+  const state = { agentCalls: 0 };
+  const ctx = {
+    stepId: "classify_module",
+    config: { module_config: { baseId: "base", tableId: "module-table" } },
+    toolkit: {
+      table: {
+        readCurrentRow: async () => row,
+        listRecordsIn: async () => modules,
+        updateCurrentRow: async (fields: CreatedRecord) => {
+          updates.push(fields);
+        },
+      },
+      coding: {
+        run: async () => {
+          state.agentCalls += 1;
+          if (agentResponse === null) throw new Error("不应调用 Agent");
+          return { success: true, response: agentResponse };
+        },
+      },
+    },
+  };
+  return { ctx, state, updates };
+}
+
+test("模块已判定时等待受理用 needs_human 且指引改需求状态", async () => {
+  const { ctx, state } = classifyModuleContext(
+    { 模块: "数据源与同步", 需求标题: "【测试】数据源不同步" },
+    [],
+    null,
+  );
+
+  const result = await executeClassifyModule(ctx);
+
+  assert.equal(result.status, "needs_human");
+  assert.equal(state.agentCalls, 0);
+  assert.ok(result.blockReason?.includes("已接受"), "文案必须告诉人改哪个字段");
+});
+
+test("模块配置表为空时不调 Agent，直接提示先补配置", async () => {
+  const { ctx, state } = classifyModuleContext({ 需求标题: "新需求" }, [], null);
+
+  const result = await executeClassifyModule(ctx);
+
+  assert.equal(result.status, "needs_human");
+  assert.equal(state.agentCalls, 0);
+  assert.ok(result.blockReason?.includes("模块配置表"));
+});
+
+test("AI 判定不在配置表时暂存为候选并等待人工确认，不丢弃判定", async () => {
+  const { ctx, updates } = classifyModuleContext(
+    { 需求标题: "【测试】数据源不同步" },
+    [{ fields: { 模块名称: "数据源与同步" } }],
+    "数据源\n涉及同步链路",
+  );
+
+  const result = await executeClassifyModule(ctx);
+
+  assert.equal(result.status, "needs_human");
+  assert.deepEqual(updates, [{ 模块: "数据源" }]);
+  assert.ok(result.blockReason?.includes("数据源"));
+});
+
+// 防回归：配置表内容即白名单，不得在代码里硬编码候选模块名——
+// 用户在表里自由维护的模块（哪怕完全不在历史预设分类里）必须可判定。
+test("自定义模块（不在任何预设分类里）命中配置表即判定成功", async () => {
+  const { ctx, updates } = classifyModuleContext(
+    { 需求标题: "【测试】工单要能导出 PDF" },
+    [{ fields: { 模块名称: "报表与导出" } }],
+    "报表与导出\n导出链路相关",
+  );
+
+  const result = await executeClassifyModule(ctx);
+
+  assert.equal(result.status, "success");
+  assert.deepEqual(updates, [{ 模块: "报表与导出", 需求状态: "待评估" }]);
+});