#多 Agent 协同工作技巧

export const meta = {
  name: 'parallel-build',
  description: '并行构建无依赖模块',
  phases: [{ title: 'Build' }],
};

phase('Build');
const results = await parallel([
  () => agent('实现 T1：导出 CSV Service，带单元测试', { phase: 'Build' }),
  () => agent('实现 T2：统计面板 Service，带单元测试', { phase: 'Build' }),
]);
// results[0] → T1 产出, results[1] → T2 产出
// 两个 Agent 同时跑，互不阻塞

export const meta = {
  name: 'build-export-and-stats',
  description: '并行构建导出和统计模块',
  phases: [{ title: 'Build Services' }],
};

phase('Build Services');
await parallel([
  () =>
    agent(
      '实现 T1-export-csv-service：ExportService 类，含 exportCsv() 和 maskPhone()，' +
        '用 StreamingResponseBody 流式输出，写 JUnit 测试覆盖 3 种订单状态',
      { phase: 'Build Services' },
    ),
  () =>
    agent(
      '实现 T2-stats-service：StatsService 类，含 getWeeklyStats()，' +
        '查询最近 7 天数据（读只读从库），返回 WeeklyStats DTO，' +
        '写 JUnit 测试覆盖 0 数据 / 正常数据 / 跨月数据',
      { phase: 'Build Services' },
    ),
]);

export const meta = {
  name: 'build-user-mgmt-components',
  description: '并行构建搜索、列表、导出三个独立组件',
  phases: [{ title: 'Build Components' }],
};

phase('Build Components');
await parallel([
  () =>
    agent(
      '实现 T1-search-input：SearchInput.vue，含姓名输入框（v-model + 防抖 300ms）、' +
        '状态下拉（全部/激活/禁用）、DateRangePicker 日期范围选择。' +
        '每个筛选项变化时 emit filter-change 事件。用 vitest + @vue/test-utils 写测试',
      { phase: 'Build Components' },
    ),
  () =>
    agent(
      '实现 T2-user-table：UserTable.vue，接收 filters prop，' +
        'watchEffect 触发 /api/users 请求，展示分页表格。' +
        '含 loading（骨架屏）、empty（"暂无数据"）、error（重试按钮）三个状态。' +
        '用 vitest 写测试——mock fetch 验证三种状态渲染',
      { phase: 'Build Components' },
    ),
  () =>
    agent(
      '实现 T3-export-button：ExportButton.vue，接收 filters prop，' +
        '点击触发 /api/users/export/csv 下载。loading 态显示"导出中…"，' +
        '完成后恢复按钮文字。用 vitest 写测试',
      { phase: 'Build Components' },
    ),
]);

export const meta = {
  name: 'pipeline-build',
  description: '流水线：独立任务完成后立刻集成',
  phases: [{ title: 'Build' }, { title: 'Integrate' }],
};

const tasks = [
  { name: 'T1', prompt: '实现导出 Service…' },
  { name: 'T2', prompt: '实现统计 Service…' },
];

await pipeline(
  tasks,
  // Stage 1：并行编译各任务
  (task) => agent(task.prompt, { label: task.name, phase: 'Build' }),
  // Stage 2：T1/T2 完成后立刻进入集成——不等另一个
  (result, task) =>
    agent(`将 ${task.name} 集成到 T3 Controller…`, { label: `integrate-${task.name}`, phase: 'Integrate' }),
);

export const meta = {
  name: 'build-and-integrate-orders',
  description: '流水线构建导出和统计后立刻集成',
  phases: [{ title: 'Build Services' }, { title: 'Controller Integration' }],
};

const services = [
  { id: 'export', prompt: '实现 T1-export-csv-service…' },
  { id: 'stats', prompt: '实现 T2-stats-service…' },
];

await pipeline(
  services,
  (svc) => agent(svc.prompt, { label: svc.id, phase: 'Build Services' }),
  (result, svc) =>
    agent(`集成 ${svc.id} 到 OrderAdminController：加对应端点，注入 Service，加集成测试`, {
      label: `integrate-${svc.id}`,
      phase: 'Controller Integration',
    }),
);

export const meta = {
  name: 'build-and-integrate-user-mgmt',
  description: '流水线构建三个组件后立刻页面集成',
  phases: [{ title: 'Build Components' }, { title: 'Page Integration' }],
};

const components = [
  { id: 'search', prompt: '实现 T1-search-input…' },
  { id: 'table', prompt: '实现 T2-user-table…' },
  { id: 'export', prompt: '实现 T3-export-button…' },
];

await pipeline(
  components,
  (comp) => agent(comp.prompt, { label: comp.id, phase: 'Build Components' }),
  (result, comp) =>
    agent(`在 UserManage.vue 中引入 ${comp.id} 组件，带交互测试`, {
      label: `integrate-${comp.id}`,
      phase: 'Page Integration',
    }),
);

export const meta = {
  name: 'find-all-issues',
  description: '循环发现代码问题，直到连续 2 轮无新发现',
  phases: [{ title: 'Find' }],
};

const seen = new Set();
let dry = 0;
const issues = [];

while (dry < 2) {
  const result = await agent(`扫描代码库找问题（排除已发现的：${[...seen].join(', ')}），返回新问题列表`, {
    phase: 'Find',
    schema: {
      type: 'object',
      properties: {
        issues: {
          type: 'array',
          items: { type: 'object', properties: { id: { type: 'string' }, desc: { type: 'string' } } },
        },
      },
    },
  });
  if (!result || !result.issues.length) {
    dry++;
    continue;
  }
  dry = 0;
  for (const issue of result.issues) {
    if (!seen.has(issue.id)) {
      seen.add(issue.id);
      issues.push(issue);
    }
  }
}
log(`发现 ${issues.length} 个问题，扫描完成`);

// ponytail: 循环发现比"列清单—逐一检查"更适合"不确定有多少"的场景
let dry = 0;
const found = [];

while (dry < 2) {
  const result = await agent(
    `扫描 src/** /controller/ 下的所有 Controller，找出缺少标准 CRUD 端点的类` +
      `（已发现：${found.map((f) => f.file).join(', ')}），返回新发现`,
    { phase: 'Find', schema: MISSING_ENDPOINT_SCHEMA },
  );
  if (!result || !result.endpoints.length) {
    dry++;
    continue;
  }
  dry = 0;
  found.push(...result.endpoints);
}
log(`${found.length} 个 Controller 缺少端点：${found.map((f) => f.file + ':' + f.missing).join(', ')}`);

let dry = 0;
const found = [];

while (dry < 2) {
  const result = await agent(
    `扫描 src/components/ 下的所有 Vue 组件，找出有异步请求但没有 loading 状态的` +
      `（已发现：${found.map((f) => f.file).join(', ')}），返回新发现的`,
    { phase: 'Find', schema: MISSING_LOADING_SCHEMA },
  );
  if (!result || !result.components.length) {
    dry++;
    continue;
  }
  dry = 0;
  found.push(...result.components);
}
log(`${found.length} 个组件缺 loading 状态`);

export const meta = {
  name: 'judge-design',
  description: '多角度独立评审 + 综合打分',
  phases: [{ title: 'Judge' }, { title: 'Synthesize' }],
};

const ANGLES = [
  { key: 'perf', prompt: '从性能角度评审…' },
  { key: 'security', prompt: '从安全角度评审…' },
  { key: 'maintainability', prompt: '从可维护性角度评审…' },
];

phase('Judge');
const verdicts = await parallel(ANGLES.map((a) => () => agent(a.prompt, { label: a.key, schema: VERDICT_SCHEMA })));

phase('Synthesize');
const report = await agent(`综合以下三个角度的评审结果，给出最终建议：\n${JSON.stringify(verdicts.filter(Boolean))}`, {
  label: 'synthesize',
});

const ANGLES = [
  {
    key: 'perf',
    prompt:
      '从性能角度评审 ExportService：CSVPrinter + StreamingResponseBody 在 5000 条订单时会不会阻塞？有没有内存隐患？',
  },
  { key: 'security', prompt: '从安全角度评审：maskPhone 脱敏是否充分？导出有没有越权风险？CSV 注入防护做了吗？' },
  {
    key: 'maint',
    prompt: '从可维护性评审：ExportService 的职责是否单一？如果将来要加 Excel/PDF 导出，现在的结构好扩展吗？',
  },
];

phase('Judge');
const verdicts = await parallel(ANGLES.map((a) => () => agent(a.prompt, { label: a.key })));

const ANGLES = [
  {
    key: 'ux',
    prompt:
      '从 UX 角度评审三个组件：防抖 300ms 合适吗？loading/empty/error 三个状态都覆盖了吗？键盘导航和焦点管理考虑了吗？',
  },
  { key: 'perf', prompt: '从性能角度评审：watchEffect 在筛选条件快速变化时会不会频繁请求？组件有没有不必要的重渲染？' },
  { key: 'maint', prompt: '从可维护性评审：三个组件的职责边界清晰吗？filters 作为 props 的接口设计够不够稳？' },
];

phase('Judge');
const verdicts = await parallel(ANGLES.map((a) => () => agent(a.prompt, { label: a.key })));

export const meta = {
  name: 'verify-findings',
  description: '对抗验证：3 个 Agent 独立尝试证伪每个发现',
  phases: [{ title: 'Verify' }],
};

const confirmed = [];

for (const finding of reviewFindings) {
  const votes = await parallel(
    Array.from(
      { length: 3 },
      () => () =>
        agent(
          `尝试证伪这个审查发现——默认判定为"不真实"，除非代码中确实存在：\n${finding.desc}\n文件：${finding.file}:${finding.line}`,
          { label: `verify:${finding.file}:${finding.line}`, schema: VERDICT_SCHEMA },
        ),
    ),
  );
  const realVotes = votes.filter(Boolean).filter((v) => v.isReal).length;
  if (realVotes >= 2) confirmed.push(finding);
  else log(`❌ 证伪：${finding.file}:${finding.line} — ${finding.desc}（${realVotes}/3 确认真实）`);
}

log(`审查发现 ${reviewFindings.length} 个问题，${confirmed.length} 个确认真实`);

// 全分支终审
phase('Final Review');
const finalFindings = await agent('审查整个分支的 diff，返回所有问题（按严重度排序）', {
  label: 'sprint-review',
  model: 'opus',
  schema: FINDINGS_SCHEMA,
});

// adversarial verify
phase('Verify');
const confirmed = [];
for (const f of finalFindings.findings) {
  const votes = await parallel(
    Array.from(
      { length: 3 },
      () => () =>
        agent(`尝试证伪：代码中真的存在这个问题吗？\n${f.desc}\n${f.file}:${f.line}`, {
          label: `verify:${f.file}`,
          schema: VERDICT_SCHEMA,
        }),
    ),
  );
  if (votes.filter(Boolean).filter((v) => v.isReal).length >= 2) confirmed.push(f);
}