@ohos-cpf/3rdloop 0.0.1

package/vendor/Server/Skills/skill-generator/scripts/validate-skill.cjs

@@ -0,0 +1,259 @@
+#!/usr/bin/env node
+/**
+ * @tool validate-skill
+ * @description 校验SKILL目录是否符合Agent Skills规范，检查frontmatter、结构、渐进式披露。跨平台（Windows/macOS/Linux），仅需 Node.js。
+ * @param skillDir: string - SKILL目录绝对路径
+ * @hidden
+ * validate-skill.cjs
+ *
+ * 用法:
+ *   # CLI 模式
+ *   node validate-skill.cjs /path/to/skill
+ *
+ *   # MCP Gateway 模式（第一个参数为 JSON 字符串）
+ *   node validate-skill.cjs '{"skillDir":"/path/to/skill"}'
+ */
+
+'use strict';
+
+const fs = require('node:fs');
+const path = require('node:path');
+
+// ── 参数解析（兼容 MCP Gateway JSON 模式与 CLI 模式） ──────
+
+function parseArgs(argv) {
+  if (argv.length === 0) return {};
+  const first = argv[0];
+  if (typeof first === 'string' && first.startsWith('{')) {
+    try { return JSON.parse(first); } catch (e) { return {}; }
+  }
+  return { skillDir: first };
+}
+
+// ── 输出统计 ─────────────────────────────────────────────
+
+let PASS = 0;
+let FAIL = 0;
+let WARNINGS = 0;
+
+function checkPass(msg) { console.log(`  ✅ ${msg}`); PASS += 1; }
+function checkFail(msg) { console.log(`  ❌ ${msg}`); FAIL += 1; }
+function checkWarn(msg) { console.log(`  ⚠️  ${msg}`); WARNINGS += 1; }
+
+// ── Frontmatter 解析 ─────────────────────────────────────
+
+/**
+ * 解析 SKILL.md 的 frontmatter 与 body。
+ * 返回 { frontmatter: object|null, bodyLines: string[] }
+ */
+function parseFrontmatter(content) {
+  const lines = content.split(/\r?\n/);
+  if (!lines[0] || lines[0].trim() !== '---') {
+    return { frontmatter: null, bodyLines: lines };
+  }
+  let end = -1;
+  for (let i = 1; i < lines.length; i++) {
+    if (lines[i].trim() === '---') { end = i; break; }
+  }
+  if (end === -1) {
+    return { frontmatter: null, bodyLines: lines };
+  }
+  const fmLines = lines.slice(1, end);
+  const fm = {};
+  let currentKey = null;
+  for (const line of fmLines) {
+    const m = line.match(/^([a-zA-Z_][\w-]*):\s*(.*)$/);
+    if (m) {
+      currentKey = m[1];
+      fm[currentKey] = m[2].trim();
+    } else if (currentKey && /^\s+\S/.test(line)) {
+      fm[currentKey] += '\n' + line.trim();
+    }
+  }
+  return { frontmatter: fm, bodyLines: lines.slice(end + 1) };
+}
+
+// ── 主流程 ───────────────────────────────────────────────
+
+function main() {
+  const args = parseArgs(process.argv.slice(2));
+  const skillDir = args.skillDir || '';
+
+  if (!skillDir) {
+    console.log('Usage: node validate-skill.cjs <skillDir>');
+    console.log('Error: skillDir parameter is required');
+    process.exit(1);
+  }
+
+  if (!fs.existsSync(skillDir) || !fs.statSync(skillDir).isDirectory()) {
+    console.log(`Error: Directory does not exist: ${skillDir}`);
+    process.exit(1);
+  }
+
+  console.log('=== SKILL 规范校验 ===');
+  console.log(`目录: ${skillDir}`);
+  console.log('');
+
+  // ─── 1. SKILL.md 存在性 ───
+  console.log('--- 1. 文件结构检查 ---');
+  const skillFile = path.join(skillDir, 'SKILL.md');
+  if (fs.existsSync(skillFile) && fs.statSync(skillFile).isFile()) {
+    checkPass('SKILL.md 存在');
+  } else {
+    checkFail('SKILL.md 不存在');
+    console.log('无法继续校验，SKILL.md 是必需文件');
+    process.exit(1);
+  }
+
+  const content = fs.readFileSync(skillFile, 'utf-8');
+  const { frontmatter, bodyLines } = parseFrontmatter(content);
+
+  // ─── 2. Frontmatter 检查 ───
+  console.log('');
+  console.log('--- 2. Frontmatter 检查 ---');
+
+  if (frontmatter) {
+    checkPass('YAML frontmatter 存在');
+  } else {
+    checkFail('缺少 YAML frontmatter（文件应以 --- 开头并以 --- 结束头部）');
+  }
+
+  const nameField = frontmatter ? String(frontmatter.name || '') : '';
+  if (nameField) {
+    checkPass(`name 字段存在: ${nameField}`);
+
+    // name 字符集校验
+    if (/^[a-z0-9]+(-[a-z0-9]+)*$/.test(nameField)) {
+      checkPass('name 字符集合规（仅小写字母/数字/连字符）');
+    } else {
+      checkFail('name 字符集不合规：应仅含 a-z/0-9/-，不能首尾连字符或连续连字符');
+    }
+
+    // name 长度校验
+    const nameLen = nameField.length;
+    if (nameLen >= 1 && nameLen <= 64) {
+      checkPass(`name 长度合规 (${nameLen} 字符)`);
+    } else {
+      checkFail(`name 长度不合规：应在 1-64 字符之间（当前 ${nameLen}）`);
+    }
+
+    // name 匹配目录名
+    const dirName = path.basename(path.resolve(skillDir));
+    if (nameField === dirName) {
+      checkPass(`name 匹配父目录名 (${dirName})`);
+    } else {
+      checkFail(`name 不匹配父目录名：name='${nameField}' vs 目录='${dirName}'`);
+    }
+  } else {
+    checkFail('name 字段缺失');
+  }
+
+  const descField = frontmatter ? String(frontmatter.description || '') : '';
+  if (descField) {
+    const descLen = descField.length;
+    if (descLen <= 1024) {
+      checkPass(`description 长度合规 (${descLen} 字符)`);
+    } else {
+      checkFail(`description 过长：应 ≤1024 字符（当前 ${descLen}）`);
+    }
+  } else {
+    checkFail('description 字段缺失或为空');
+  }
+
+  if (frontmatter && frontmatter.license) {
+    checkPass('license 字段存在');
+  } else {
+    checkWarn('license 字段缺失（推荐添加）');
+  }
+
+  if (frontmatter && frontmatter.metadata) {
+    checkPass('metadata 字段存在');
+  } else {
+    checkWarn('metadata 字段缺失（推荐添加 author/version）');
+  }
+
+  // ─── 3. Body 检查 ───
+  console.log('');
+  console.log('--- 3. Body 内容检查 ---');
+
+  const bodyLineCount = bodyLines.length;
+  if (bodyLineCount <= 500) {
+    checkPass(`body 行数合规 (${bodyLineCount} 行, ≤500)`);
+  } else {
+    checkWarn(`body 行数较多 (${bodyLineCount} 行，推荐 < 500，考虑拆分到 references/)`);
+  }
+
+  if (/任务参数|## .*参数|\|\s*参数/.test(content)) {
+    checkPass('包含任务参数说明');
+  } else {
+    checkWarn('未找到任务参数表（推荐添加）');
+  }
+
+  if (/工作流程|Phase|## Phase/.test(content)) {
+    checkPass('包含工作流程概览');
+  } else {
+    checkWarn('未找到工作流程概览（推荐添加）');
+  }
+
+  // ─── 4. 渐进式披露检查 ───
+  console.log('');
+  console.log('--- 4. 渐进式披露检查 ---');
+
+  const refsDir = path.join(skillDir, 'references');
+  if (fs.existsSync(refsDir) && fs.statSync(refsDir).isDirectory()) {
+    const refFiles = fs.readdirSync(refsDir)
+      .filter((f) => f.endsWith('.md') && fs.statSync(path.join(refsDir, f)).isFile());
+    checkPass(`references/ 目录存在 (${refFiles.length} 个文档)`);
+
+    // 检查引用深度（一层）
+    const nestedDirs = fs.readdirSync(refsDir, { withFileTypes: true })
+      .filter((d) => d.isDirectory()).length;
+    if (nestedDirs === 0) {
+      checkPass('references 保持一层深度');
+    } else {
+      checkFail(`references 存在嵌套子目录 (${nestedDirs} 个)，应保持一层深度`);
+    }
+  } else {
+    checkWarn('无 references/ 目录（详细内容建议拆分到此目录）');
+  }
+
+  const assetsDir = path.join(skillDir, 'assets');
+  if (fs.existsSync(assetsDir) && fs.statSync(assetsDir).isDirectory()) {
+    checkPass('assets/ 目录存在');
+  } else {
+    checkWarn('无 assets/ 目录（如需模板/资源可添加）');
+  }
+
+  const scriptsDir = path.join(skillDir, 'scripts');
+  if (fs.existsSync(scriptsDir) && fs.statSync(scriptsDir).isDirectory()) {
+    checkPass('scripts/ 目录存在');
+  } else {
+    checkWarn('无 scripts/ 目录（如需可执行脚本可添加）');
+  }
+
+  // 检查文件引用使用相对路径
+  const absRefs = (content.match(/\]\(\/[^)]+\)/g) || []).length;
+  if (absRefs === 0) {
+    checkPass('文件引用使用相对路径');
+  } else {
+    checkFail(`发现 ${absRefs} 个绝对路径引用，应使用相对路径`);
+  }
+
+  // ─── 5. 总结 ───
+  console.log('');
+  console.log('=== 校验总结 ===');
+  console.log(`  ✅ 通过: ${PASS}`);
+  console.log(`  ❌ 失败: ${FAIL}`);
+  console.log(`  ⚠️  警告: ${WARNINGS}`);
+  console.log('');
+
+  if (FAIL === 0) {
+    console.log('ALL CHECKS PASSED');
+    process.exit(0);
+  } else {
+    console.log(`VALIDATION FAILED: ${FAIL} 个必须修复的问题`);
+    process.exit(1);
+  }
+}
+
+main();

package/vendor/Server/Skills/task-analysis/SKILL.md

@@ -0,0 +1,234 @@
+---
+name: task-analysis
+description: 分析自然语言任务描述，提取核心意图、领域、关键词、约束条件、技术栈，并生成结构化验收标准。当需要将一个高层任务描述拆解为意图分析与验收标准生成时使用此技能。适用于 AI Loop 系统中 Brain 模块的任务分析阶段，支持首轮分析与重规划场景。
+license: Apache-2.0
+compatibility: 由 Brain 模块通过 opencode CLI 调用（SkillExecutor），或降级为直接 LLM 调用。需要写入权限到任务工作目录，输出纯 JSON 格式分析结果。
+metadata:
+  author: LoopEngine
+  version: "2.0.0"
+  category: task-planning
+  language: natural-language
+  invoked-by: AnalysisStrategies._analyzeViaCLI / _analyzeWithContextViaCLI
+  consumed-by: AnalysisStrategies.normalizeAnalysis → DecompositionStrategies → Brain.taskDef
+---
+
+# 任务分析技能
+
+本技能通过 LLM 分析自然语言任务描述，提取任务的关键信息并生成结构化验收标准，为后续的任务拆解提供基础。
+
+> ⚠️ **核心原则：分析结果必须包含可验证的验收标准，每条标准具体且可执行。输出必须为纯 JSON。**
+
+---
+
+## 调用方式
+
+本 SKILL 由 Brain 模块的 `AnalysisStrategies` 调用，通过 `SkillExecutor.invokeSkill` 执行：
+
+- **首轮分析**：`AnalysisStrategies._analyzeViaCLI(taskDescription, userCriteria, ctx)`
+- **重规划分析**：`AnalysisStrategies._analyzeWithContextViaCLI(taskDescription, userCriteria, context, ctx)`
+
+调用方会构建以下 prompt 段落传入：
+- `## SKILL 目录` — 本 SKILL 目录路径（opencode 读取 SKILL.md 执行）
+- `## 工作目录` — 任务工作目录
+- `## 结果文件输出路径` — JSON 输出路径（`brain_analysis_loop{N}.json`）
+- `## 任务描述` — 自然语言任务描述
+- `## 用户提供的验收标准` 或 `## 验收标准`（未提供时自动生成）
+- 重规划时额外注入：`## 重规划上下文` / `## 上一轮审核摘要` / `## 未满足的验收标准` / `## 改进建议` / `## 重分析要求`
+
+> 完整调用链路与消费方式参见 [调用链路说明](references/INTEGRATION_CONTEXT.md)
+
+---
+
+## 任务参数
+
+| 参数 | 类型 | 必填 | 说明 |
+|------|------|------|------|
+| `taskDescription` | string | ✅ | 自然语言任务描述（由调用方通过 prompt 注入） |
+| `acceptanceCriteria` | string | ❌ | 用户提供的验收标准（自然语言），未提供时自动生成 |
+| `workDir` | string | ✅ | 任务工作目录（由调用方指定） |
+| `resultFilePath` | string | ✅ | 分析结果 JSON 输出路径（由调用方指定） |
+| `context` | object | ❌ | 重规划上下文（仅重规划时提供，含 failedCriteria、improvementSuggestions、prevCheckSummary、loopCount 等） |
+
+---
+
+## 输入依赖
+
+- **前置 SKILL**：无。作为任务拆解流程的第一步执行。
+- **输入文件**：无（任务描述通过 prompt 注入）。
+- **下游 SKILL**：`task-decomposition`（消费本 SKILL 的输出进行步骤拆解）。
+
+---
+
+## 工作流程概览
+
+```
+Phase 1: 任务理解与上下文解析
+    ↓
+Phase 2: 关键信息提取（intent/domain/keywords/constraints/techStack/complexity/estimatedSteps）
+    ↓
+Phase 3: 验收标准生成（3-8 条，含 type 分类与 verification）
+    ↓
+Phase 4: 结果输出（纯 JSON 写入 resultFilePath）
+```
+
+---
+
+## Phase 1：任务理解与上下文解析
+
+### 1.1 解析任务描述
+
+读取 `## 任务描述` 段落，理解任务的核心目标和预期产出。提取：
+- **核心目标**：任务要达成什么
+- **预期产出**：最终交付什么（代码、文档、报告等）
+- **领域线索**：技术领域、平台、语言等
+
+### 1.2 处理用户验收标准
+
+读取 `## 用户提供的验收标准` 段落（如果存在）：
+- 将用户自然语言标准作为基础
+- 细化补充为结构化的验收标准（补全 type、verification 字段）
+- 确保每条标准具体、可验证
+
+如果段落为 `## 验收标准`（未提供用户标准），则根据任务描述自动生成。
+
+### 1.3 处理重规划上下文（如果提供）
+
+如果 prompt 中包含 `## 重规划上下文` 段落，进入重规划模式：
+- 读取 `## 未满足的验收标准` — 上一轮未通过的标准及其失败原因
+- 读取 `## 改进建议` — 上一轮的改进方向
+- 读取 `## 上一轮审核摘要` — 审核总结
+- **保持原始任务目标不变**，仅调整策略和标准
+- 分析失败原因，生成 `failureAnalysis` 字段
+- 制定调整策略，生成 `adjustmentStrategy` 字段
+
+> 详细处理流程参见 [重规划上下文处理指南](references/REPLAN_CONTEXT_GUIDE.md)
+
+---
+
+## Phase 2：关键信息提取
+
+提取以下字段：
+
+| 字段 | 类型 | 说明 |
+|------|------|------|
+| `intent` | string | 任务核心意图（一句话概括，≤100 字符） |
+| `domain` | string | 任务领域（kebab-case，如 `harmonyos-porting`、`code-quality`、`documentation`、`bug-fix`、`feature`、`refactoring`） |
+| `keywords` | string[] | 关键词列表（用于后续 SKILL 匹配，≥1 个） |
+| `constraints` | string[] | 约束条件列表 |
+| `techStack` | string[] | 技术栈列表（≥1 个） |
+| `complexity` | string | 复杂度：`low`（1-3步/单模块）/ `medium`（4-7步/2-3模块）/ `high`（8+步/跨系统） |
+| `estimatedSteps` | number | 预估步骤数（≥1，供 task-decomposition SKILL 参考） |
+
+### 提取要点
+
+- `keywords` 要包含技术名词、动作词、领域词，直接影响后续 SKILL 匹配准确性
+- `techStack` 要完整列出所有涉及的技术栈，便于步骤拆解时匹配专用 SKILL
+- `estimatedSteps` 应与 `complexity` 对应，重规划时可根据失败原因调整
+
+> 完整字段规范参见 [输出 Schema](references/ANALYSIS_SCHEMA.md)
+
+---
+
+## Phase 3：验收标准生成
+
+### 3.1 生成原则
+
+- **具体可验证**：每条标准必须能通过检查文件、执行命令或人工审查来判定 pass/fail
+- **覆盖关键产出**：至少 1 条 `output` 类型 + 至少 1 条 `quality`/`compliance` 类型
+- **数量合理**：3-8 条
+- **避免模糊**：禁止"分析完成""代码质量好"等不可验证描述
+
+### 3.2 type 分类
+
+| type | 说明 | 验证方式 |
+|------|------|----------|
+| `output` | 产物检查 — 文件/内容是否存在、是否完整 | 检查文件存在性、大小、格式 |
+| `quality` | 质量要求 — 产物质量是否达标 | 内容审查、规则匹配 |
+| `performance` | 性能指标 — 定量指标 | 执行命令获取数值 |
+| `compliance` | 合规性 — 是否符合规范 | 规范比对、lint 检查 |
+
+### 3.3 每条标准必含字段
+
+| 字段 | 必填 | 说明 |
+|------|------|------|
+| `id` | ✅ | 从 `ac1` 开始递增（ac1, ac2, ac3...） |
+| `criterion` | ✅ | 具体标准描述，非空 |
+| `type` | ✅ | `output`/`quality`/`performance`/`compliance` |
+| `verification` | ✅ | 验证方式描述（具体到可执行命令或检查方法） |
+
+### 3.4 重规划时的额外处理
+
+- 针对未满足标准调整验证方式（更明确）
+- 补充新标准覆盖上轮遗漏维度
+- 必须生成 `failureAnalysis` 和 `adjustmentStrategy` 字段
+
+> 编写指南与示例参见 [验收标准编写指南](references/ACCEPTANCE_CRITERIA_GUIDE.md)
+
+---
+
+## Phase 4：结果输出
+
+### 4.1 输出文件
+
+将分析结果以 **纯 JSON** 格式写入 `## 结果文件输出路径` 指定的路径。
+
+### 4.2 JSON 结构（首轮）
+
+```json
+{
+  "intent": "任务核心意图",
+  "domain": "任务领域",
+  "keywords": ["关键词1", "关键词2"],
+  "constraints": ["约束条件1"],
+  "techStack": ["技术栈1"],
+  "complexity": "low|medium|high",
+  "estimatedSteps": 3,
+  "acceptanceCriteria": [
+    {
+      "id": "ac1",
+      "criterion": "具体标准描述",
+      "type": "output|quality|performance|compliance",
+      "verification": "验证方式"
+    }
+  ]
+}
+```
+
+### 4.3 重规划时额外字段
+
+```json
+{
+  "failureAnalysis": "上一轮失败原因分析",
+  "adjustmentStrategy": "本轮调整策略"
+}
+```
+
+### 4.4 输出规范
+
+- ✅ 纯 JSON（无 markdown 代码块标记，无注释，无前后缀文字）
+- ✅ 合法可解析格式
+- ✅ 验收标准 `id` 从 `ac1` 递增
+- ✅ 所有字符串字段非空
+
+> 完整输出示例参见 [输出示例](assets/OUTPUT_EXAMPLES.md)
+
+---
+
+## 自检
+
+输出完成后，可运行校验脚本验证 JSON 合规性：
+
+```bash
+bash scripts/validate-analysis-output.sh <resultFile>
+```
+
+---
+
+## 注意事项
+
+1. **不要修改任务目标** — `intent` 在重规划时保持不变，仅调整策略和标准
+2. **验收标准必须可验证** — 避免模糊描述，verification 要具体到可执行
+3. **关键词要准确** — 直接影响后续 SKILL 匹配的准确性
+4. **技术栈要完整** — 列出所有涉及的技术栈，便于步骤拆解时匹配专用 SKILL
+5. **重规划时保持目标一致** — 调整的是 `acceptanceCriteria`/`estimatedSteps`/`failureAnalysis`/`adjustmentStrategy`，不是 `intent`
+6. **输出纯 JSON** — 下游有容错机制但应输出纯 JSON，不依赖容错

package/vendor/Server/Skills/task-analysis/assets/OUTPUT_EXAMPLES.md

@@ -0,0 +1,160 @@
+# 任务分析输出示例
+
+> 完整的分析结果 JSON 示例，供 SKILL 执行时参考格式。
+
+---
+
+## 1. 首轮分析输出示例
+
+以"鸿蒙 ArkTS 三方库内存泄漏检测"任务为例：
+
+```json
+{
+  "intent": "分析鸿蒙 ArkTS 三方库的内存泄漏问题，生成结构化检测报告",
+  "domain": "harmonyos-porting",
+  "keywords": ["ArkTS", "内存泄漏", "生命周期", "OpenHarmony", "leak-detection"],
+  "constraints": [
+    "必须兼容 ArkTS 编译规则",
+    "分析结果输出为纯 JSON 格式",
+    "覆盖目标库所有源文件"
+  ],
+  "techStack": ["ArkTS", "OpenHarmony", "鸿蒙 SDK"],
+  "complexity": "medium",
+  "estimatedSteps": 5,
+  "acceptanceCriteria": [
+    {
+      "id": "ac1",
+      "criterion": "内存泄漏分析报告 JSON 文件已生成且可解析",
+      "type": "output",
+      "verification": "检查 {workDir}/leak-analysis.json 存在，JSON.parse 成功"
+    },
+    {
+      "id": "ac2",
+      "criterion": "报告包含 intent、domain、keywords、techStack 字段且均非空",
+      "type": "quality",
+      "verification": "读取 JSON，逐字段检查存在性和非空"
+    },
+    {
+      "id": "ac3",
+      "criterion": "扫描覆盖目标库所有源文件（覆盖率 100%）",
+      "type": "performance",
+      "verification": "对比源文件列表与扫描结果，确认无遗漏"
+    },
+    {
+      "id": "ac4",
+      "criterion": "每个疑似泄漏点包含位置、类型、严重等级信息",
+      "type": "quality",
+      "verification": "读取报告中 leakPoints 数组，每条含 file/line/level 字段"
+    },
+    {
+      "id": "ac5",
+      "criterion": "分析结果符合 JSON 输出规范（纯 JSON、字段完整）",
+      "type": "compliance",
+      "verification": "运行 validate-output.sh 校验脚本，检查通过"
+    }
+  ]
+}
+```
+
+---
+
+## 2. 重规划分析输出示例
+
+第 1 轮重规划（loopCount=1），上一轮 ac3/ac4 未通过：
+
+```json
+{
+  "intent": "分析鸿蒙 ArkTS 三方库的内存泄漏问题，生成结构化检测报告",
+  "domain": "harmonyos-porting",
+  "keywords": ["ArkTS", "内存泄漏", "生命周期", "OpenHarmony", "leak-detection", "utils-scan"],
+  "constraints": [
+    "必须兼容 ArkTS 编译规则",
+    "分析结果输出为纯 JSON 格式",
+    "覆盖目标库所有源文件"
+  ],
+  "techStack": ["ArkTS", "OpenHarmony", "鸿蒙 SDK"],
+  "complexity": "high",
+  "estimatedSteps": 7,
+  "acceptanceCriteria": [
+    {
+      "id": "ac1",
+      "criterion": "内存泄漏分析报告 JSON 文件已生成且可解析",
+      "type": "output",
+      "verification": "检查 {workDir}/leak-analysis.json 存在，JSON.parse 成功"
+    },
+    {
+      "id": "ac2",
+      "criterion": "报告包含 intent、domain、keywords、techStack 字段且均非空",
+      "type": "quality",
+      "verification": "读取 JSON，逐字段检查存在性和非空"
+    },
+    {
+      "id": "ac3",
+      "criterion": "扫描覆盖目标库所有源文件含 utils/ 目录（覆盖率 100%）",
+      "type": "performance",
+      "verification": "执行 find {srcDir} -name '*.ets' | wc -l 对比扫描结果条数，确认无遗漏"
+    },
+    {
+      "id": "ac4",
+      "criterion": "每个疑似泄漏点包含位置、类型、严重等级、修复建议信息",
+      "type": "quality",
+      "verification": "读取报告中 leakPoints 数组，每条含 file/line/level/suggestion 字段"
+    },
+    {
+      "id": "ac5",
+      "criterion": "分析结果符合 JSON 输出规范（纯 JSON、字段完整）",
+      "type": "compliance",
+      "verification": "运行 validate-output.sh 校验脚本，检查通过"
+    },
+    {
+      "id": "ac6",
+      "criterion": "utils/ 目录单独扫描且结果纳入主报告",
+      "type": "output",
+      "verification": "检查报告中 leakPoints 含 utils/ 路径下的条目"
+    }
+  ],
+  "failureAnalysis": "上一轮共 2 条标准未通过：ac3 失败原因：扫描未覆盖 utils/ 目录，estimatedSteps=3 过低未包含该目录扫描步骤 → 执行问题（步骤遗漏）；ac4 失败原因：泄漏点缺少 suggestion 字段 → 标准问题（验证方式不够明确）。根因：首轮 estimatedSteps 过低，未覆盖全部源目录。",
+  "adjustmentStrategy": "1. ac3 重写 verification 为具体 find 命令对比；2. ac4 补充 suggestion 字段要求；3. estimatedSteps 从 3 调整为 7；4. 新增 ac6 覆盖 utils/ 目录扫描；5. keywords 补充 'utils-scan'；6. complexity 从 medium 提升为 high。"
+}
+```
+
+---
+
+## 3. 简单任务输出示例
+
+以"更新 README 文档"任务为例：
+
+```json
+{
+  "intent": "更新项目 README 文档，补充安装说明和使用示例",
+  "domain": "documentation",
+  "keywords": ["README", "documentation", "markdown"],
+  "constraints": [
+    "保持原有文档结构",
+    "使用中文"
+  ],
+  "techStack": ["Markdown"],
+  "complexity": "low",
+  "estimatedSteps": 2,
+  "acceptanceCriteria": [
+    {
+      "id": "ac1",
+      "criterion": "README.md 文件已更新且包含安装说明章节",
+      "type": "output",
+      "verification": "检查 README.md 中存在 ## 安装 或 ## Installation 标题"
+    },
+    {
+      "id": "ac2",
+      "criterion": "README.md 包含至少 2 个使用示例",
+      "type": "quality",
+      "verification": "统计 README.md 中代码块数量 ≥ 2"
+    },
+    {
+      "id": "ac3",
+      "criterion": "文档使用中文编写",
+      "type": "compliance",
+      "verification": "检查 README.md 正文为中文"
+    }
+  ]
+}
+```