feat(skills): update 12 team skills to v3 design patterns

- Update all 12 team-* SKILL.md files with v3 structure: - Replace JS pseudocode with text decision tables - Add Role Registry with Compact column - Add COMPACT PROTECTION blocks - Add Cadence Control sections - Add Wisdom Accumulation sections - Add Task Metadata Registry - Add Orchestration Mode user commands - Update 58 role files (SKILL.md + roles/*): - Flat-file skills: team-brainstorm, team-issue, team-testing, team-uidesign, team-planex, team-iterdev - Folder-based skills: team-review, team-roadmap-dev, team-frontend, team-quality-assurance, team-tech-debt, team-ultra-analyze - Preserve special architectures: - team-planex: 2-member (planner + executor only) - team-tech-debt: Stop-Wait strategy (run_in_background:false) - team-iterdev: 7 behavior protocol tables in coordinator - All 12 teams reviewed for content completeness (PASS)
2026-03-01 14:43:54 +08:00 · 2026-02-26 21:14:45 +08:00
parent e228b8b273
commit 430d817e43
73 changed files with 13606 additions and 15439 deletions
--- a/.claude/skills/team-brainstorm/roles/evaluator.md
+++ b/.claude/skills/team-brainstorm/roles/evaluator.md
@@ -1,16 +1,14 @@
-# Role: evaluator
+# Evaluator Role

 评分排序与最终筛选。负责对综合方案进行多维度评分、优先级推荐、生成最终排名。

-## Role Identity
+## Identity

- **Name**: `evaluator`
+- **Name**: `evaluator` | **Tag**: `[evaluator]`
 - **Task Prefix**: `EVAL-*`
- **Responsibility**: Validation (评估验证)
- **Communication**: SendMessage to coordinator only
- **Output Tag**: `[evaluator]`
+- **Responsibility**: Validation (evaluation and ranking)

-## Role Boundaries
+## Boundaries

 ### MUST

@@ -19,171 +17,134 @@
 - 仅通过 SendMessage 与 coordinator 通信
 - Phase 2 读取 shared-memory.json，Phase 5 写入 evaluation_scores
 - 使用标准化评分维度，确保评分可追溯
+- 为每个方案提供评分理由和推荐

 ### MUST NOT

- ❌ 生成新创意、挑战假设或综合整合
- ❌ 直接与其他 worker 角色通信
- ❌ 为其他角色创建任务
- ❌ 修改 shared-memory.json 中不属于自己的字段
+- 生成新创意、挑战假设或综合整合
+- 直接与其他 worker 角色通信
+- 为其他角色创建任务
+- 修改 shared-memory.json 中不属于自己的字段
+- 在输出中省略 `[evaluator]` 标识
+
+---
+
+## Toolbox
+
+### Tool Capabilities
+
+| Tool | Type | Used By | Purpose |
+|------|------|---------|---------|
+| `TaskList` | Built-in | Phase 1 | Discover pending EVAL-* tasks |
+| `TaskGet` | Built-in | Phase 1 | Get task details |
+| `TaskUpdate` | Built-in | Phase 1/5 | Update task status |
+| `Read` | Built-in | Phase 2 | Read shared-memory.json, synthesis files, ideas, critiques |
+| `Write` | Built-in | Phase 3/5 | Write evaluation files, update shared memory |
+| `Glob` | Built-in | Phase 2 | Find synthesis, idea, critique files |
+| `SendMessage` | Built-in | Phase 5 | Report to coordinator |
+| `mcp__ccw-tools__team_msg` | MCP | Phase 5 | Log communication |
+
+---

 ## Message Types

 | Type | Direction | Trigger | Description |
 |------|-----------|---------|-------------|
-| `evaluation_ready` | evaluator → coordinator | Evaluation completed | 评估排序完成 |
-| `error` | evaluator → coordinator | Processing failure | 错误上报 |
+| `evaluation_ready` | evaluator -> coordinator | Evaluation completed | Scoring and ranking complete |
+| `error` | evaluator -> coordinator | Processing failure | Error report |
+
+## Message Bus
+
+Before every SendMessage, log via `mcp__ccw-tools__team_msg`:
+
+```
+mcp__ccw-tools__team_msg({
+  operation: "log",
+  team: <team-name>,
+  from: "evaluator",
+  to: "coordinator",
+  type: "evaluation_ready",
+  summary: "[evaluator] Evaluation complete: Top pick \"<title>\" (<score>/10)",
+  ref: <output-path>
+})
+```
+
+**CLI fallback** (when MCP unavailable):
+
+```
+Bash("ccw team log --team <team-name> --from evaluator --to coordinator --type evaluation_ready --summary \"[evaluator] Evaluation complete\" --ref <output-path> --json")
+```
+
+---

 ## Execution (5-Phase)

 ### Phase 1: Task Discovery

-```javascript
-const tasks = TaskList()
-const myTasks = tasks.filter(t =>
-  t.subject.startsWith('EVAL-') &&
-  t.owner === 'evaluator' &&
-  t.status === 'pending' &&
-  t.blockedBy.length === 0
-)
+> See SKILL.md Shared Infrastructure -> Worker Phase 1: Task Discovery

-if (myTasks.length === 0) return
-const task = TaskGet({ taskId: myTasks[0].id })
-TaskUpdate({ taskId: task.id, status: 'in_progress' })
-```
+Standard task discovery flow: TaskList -> filter by prefix `EVAL-*` + owner match + pending + unblocked -> TaskGet -> TaskUpdate in_progress.

 ### Phase 2: Context Loading + Shared Memory Read

-```javascript
-const sessionMatch = task.description.match(/Session:\s*([^\n]+)/)
-const sessionFolder = sessionMatch?.[1]?.trim()
+| Input | Source | Required |
+|-------|--------|----------|
+| Session folder | Task description (Session: line) | Yes |
+| Synthesis results | synthesis/*.md files | Yes |
+| All ideas | ideas/*.md files | No (for context) |
+| All critiques | critiques/*.md files | No (for context) |

-const memoryPath = `${sessionFolder}/shared-memory.json`
-let sharedMemory = {}
-try { sharedMemory = JSON.parse(Read(memoryPath)) } catch {}
+**Loading steps**:

-// Read synthesis results
-const synthesisFiles = Glob({ pattern: `${sessionFolder}/synthesis/*.md` })
-const synthesis = synthesisFiles.map(f => Read(f))
+1. Extract session path from task description (match "Session: <path>")
+2. Glob synthesis files from session/synthesis/
+3. Read all synthesis files for evaluation
+4. Optionally read ideas and critiques for full context

-// Read all ideas and critiques for full context
-const ideaFiles = Glob({ pattern: `${sessionFolder}/ideas/*.md` })
-const critiqueFiles = Glob({ pattern: `${sessionFolder}/critiques/*.md` })
+### Phase 3: Evaluation and Scoring
+
+**Scoring Dimensions**:
+
+| Dimension | Weight | Focus |
+|-----------|--------|-------|
+| Feasibility | 30% | Technical feasibility, resource needs, timeline |
+| Innovation | 25% | Novelty, differentiation, breakthrough potential |
+| Impact | 25% | Scope of impact, value creation, problem resolution |
+| Cost Efficiency | 20% | Implementation cost, risk cost, opportunity cost |
+
+**Weighted Score Calculation**:
+```
+weightedScore = (Feasibility * 0.30) + (Innovation * 0.25) + (Impact * 0.25) + (Cost * 0.20)
 ```

-### Phase 3: Evaluation & Scoring
+**Evaluation Structure per Proposal**:
+- Score for each dimension (1-10)
+- Rationale for each score
+- Overall recommendation (Strong Recommend / Recommend / Consider / Pass)

-```javascript
-// Scoring dimensions:
-// 1. Feasibility (30%) — 技术可行性、资源需求、时间框架
-// 2. Innovation  (25%) — 新颖性、差异化、突破性
-// 3. Impact      (25%) — 影响范围、价值创造、问题解决度
-// 4. Cost        (20%) — 实施成本、风险成本、机会成本
-
-const evalNum = task.subject.match(/EVAL-(\d+)/)?.[1] || '001'
-const outputPath = `${sessionFolder}/evaluation/evaluation-${evalNum}.md`
-
-const evaluationContent = `# Evaluation — Round ${evalNum}
-
-**Input**: ${synthesisFiles.length} synthesis files
-**Scoring Dimensions**: Feasibility(30%), Innovation(25%), Impact(25%), Cost(20%)
-
-## Scoring Matrix
-
-| Rank | Proposal | Feasibility | Innovation | Impact | Cost | **Weighted Score** |
-|------|----------|-------------|------------|--------|------|-------------------|
-${scoredProposals.map((p, i) => `| ${i + 1} | ${p.title} | ${p.feasibility}/10 | ${p.innovation}/10 | ${p.impact}/10 | ${p.cost}/10 | **${p.weightedScore.toFixed(1)}** |`).join('\n')}
-
-## Detailed Evaluation
-
-${scoredProposals.map((p, i) => `### ${i + 1}. ${p.title} (Score: ${p.weightedScore.toFixed(1)}/10)
-
-**Feasibility** (${p.feasibility}/10):
-${p.feasibilityRationale}
-
-**Innovation** (${p.innovation}/10):
-${p.innovationRationale}
-
-**Impact** (${p.impact}/10):
-${p.impactRationale}
-
-**Cost Efficiency** (${p.cost}/10):
-${p.costRationale}
-
-**Recommendation**: ${p.recommendation}
-`).join('\n')}
-
-## Final Recommendation
-
-**Top Pick**: ${scoredProposals[0].title}
-**Runner-up**: ${scoredProposals.length > 1 ? scoredProposals[1].title : 'N/A'}
-
-### Action Items
-${actionItems.map((item, i) => `${i + 1}. ${item}`).join('\n')}
-
-### Risk Summary
-${riskSummary.map(r => `- **${r.risk}**: ${r.mitigation}`).join('\n')}
-`
-
-Write(outputPath, evaluationContent)
-```
+**Output file structure**:
+- File: `<session>/evaluation/evaluation-<num>.md`
+- Sections: Input summary, Scoring Matrix (ranked table), Detailed Evaluation per proposal, Final Recommendation, Action Items, Risk Summary

 ### Phase 4: Consistency Check

-```javascript
-// Verify scoring consistency
-// - No proposal should have all 10s
-// - Scores should reflect critique findings
-// - Rankings should be deterministic
-const maxScore = Math.max(...scoredProposals.map(p => p.weightedScore))
-const minScore = Math.min(...scoredProposals.map(p => p.weightedScore))
-const spread = maxScore - minScore
-
-if (spread < 0.5 && scoredProposals.length > 1) {
-  // Too close — re-evaluate differentiators
-}
-```
+| Check | Pass Criteria | Action on Failure |
+|-------|---------------|-------------------|
+| Score spread | max - min >= 0.5 (with >1 proposal) | Re-evaluate differentiators |
+| No perfect scores | Not all 10s | Adjust scores to reflect critique findings |
+| Ranking deterministic | Consistent ranking | Verify calculation |

 ### Phase 5: Report to Coordinator + Shared Memory Write

-```javascript
-sharedMemory.evaluation_scores = scoredProposals.map(p => ({
-  title: p.title,
-  weighted_score: p.weightedScore,
-  rank: p.rank,
-  recommendation: p.recommendation
-}))
-Write(memoryPath, JSON.stringify(sharedMemory, null, 2))
+> See SKILL.md Shared Infrastructure -> Worker Phase 5: Report

-mcp__ccw-tools__team_msg({
-  operation: "log",
-  team: teamName,
-  from: "evaluator",
-  to: "coordinator",
-  type: "evaluation_ready",
-  summary: `[evaluator] Evaluation complete: Top pick "${scoredProposals[0].title}" (${scoredProposals[0].weightedScore.toFixed(1)}/10)`,
-  ref: outputPath
-})
+Standard report flow: team_msg log -> SendMessage with `[evaluator]` prefix -> TaskUpdate completed -> Loop to Phase 1 for next task.

-SendMessage({
-  type: "message",
-  recipient: "coordinator",
-  content: `## [evaluator] Evaluation Results
+**Shared Memory Update**:
+1. Set shared-memory.json.evaluation_scores
+2. Each entry: title, weighted_score, rank, recommendation

-**Task**: ${task.subject}
-**Proposals Evaluated**: ${scoredProposals.length}
-**Output**: ${outputPath}
-
-### Rankings
-${scoredProposals.map((p, i) => `${i + 1}. **${p.title}** — ${p.weightedScore.toFixed(1)}/10 (${p.recommendation})`).join('\n')}
-
-### Top Pick: ${scoredProposals[0].title}
-${scoredProposals[0].feasibilityRationale}`,
-  summary: `[evaluator] Top: ${scoredProposals[0].title} (${scoredProposals[0].weightedScore.toFixed(1)}/10)`
-})
-
-TaskUpdate({ taskId: task.id, status: 'completed' })
-```
+---

 ## Error Handling

@@ -193,3 +154,4 @@ TaskUpdate({ taskId: task.id, status: 'completed' })
 | Synthesis files not found | Notify coordinator |
 | Only one proposal | Evaluate against absolute criteria, recommend or reject |
 | All proposals score below 5 | Flag all as weak, recommend re-brainstorming |
+| Critical issue beyond scope | SendMessage error to coordinator |