技能作曲家
- 作者仓库星标 386
- 作者仓库 vexjoy-agent
- 领域
- 通用
- 作者声明的智能体
- 未找到明确声明;不据此推断已兼容或已测试
- 静态检查
- 88 / 100 · 启发式扫描,不代表运行安全
- 运行环境证据
- 未执行;当前没有隔离运行测试证据
- 作者 / 版本 / 许可证
- @notque · 未声明许可证
- 上下文用量评级
- 中等消耗
- 接入复杂程度
- 需简单配置
- 是否需要外部接口密钥
- 不需要
- 兼容的系统
- 未声明(默认跨平台)
- 运行环境要求
- 未检出明确要求
- 检测到的文件与系统行为
-
- 只读
- 允许写入 / 修改
- 命令执行
- 网络行为
- 仅限本地
- 安装命令数
- 无(仅作为资料)
需要注意: 未声明工具权限范围;实际权限由运行环境决定。
第一阶段:发现
目标:分析任务并找到适用的技能。步骤 1:分析用户的请求 确定: 主要目标(需要完成什么) 质量要求(测试、验证、文档)
第二阶段:计划
目标:构建经过验证的执行 DAG。步骤 1:构建 DAG 根据任务分析,将执行 DAG 构建为具有节点(技能)和边(依赖关系)的 JSON 结构: 步骤 2:验证 DAG(执行前强制) 在开始执行之前始终验证执行图是非循环的。验证检查:
第三阶段:执行
目标:按拓扑顺序运行技能,并在它们之间传递上下文。第 1 步:执行每个阶段 对于连续阶段:根据前一阶段的上下文调用技能 捕获输出
第四阶段:报告
目标:收集结果并清理。步骤 1:生成结果摘要 步骤 2:清理临时文件 在任务完成时删除临时文件。仅保留最终输出明确需要的文件:`/tmp/skill-index.json`
# Skill Composer
## Overview
Orchestrate complex workflows by chaining multiple skills into validated execution DAGs. This skill discovers applicable skills, resolves dependencies, validates compatibility, presents execution plans, and manages skill-to-skill context passing. Use when a task requires 2+ skills chained together, parallel skill execution, or conditional branching between skills. Invoke the single skill directly when it can handle the request alone, or for simple sequential invocation that needs no dependency management.
**Core principle**: Minimize composition overhead. Prefer simple 2-3 skill chains. Add only skills directly needed or "nice to have" additions without explicit user request.
## Reference Loading Table
| Signal | Load These Files | Why |
|---|---|---|
| tasks related to this reference | `compatibility-matrix.md` | Loads detailed guidance from `compatibility-matrix.md`. |
| implementation patterns | `composition-patterns.md` | Loads detailed guidance from `composition-patterns.md`. |
| example-driven tasks | `examples.md` | Loads detailed guidance from `examples.md`. |
| implementation patterns | `skill-patterns.md` | Loads detailed guidance from `skill-patterns.md`. |
## Instructions
### Phase 1: DISCOVER
**Goal**: Analyze the task and find applicable skills.
**Step 1: Analyze the user's request**
Identify:
- Primary goals (what needs to be accomplished)
- Quality requirements (testing, verification, documentation)
- Domain constraints (language, framework, standards)
- Execution constraints (sequential vs parallel, conditionals)
**Step 2: Discover available skills**
Before building any DAG, scan skills/*/SKILL.md for available skills:
```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/discover_skills.py ./skills
```
Review the discovered skills. Categorize by type (workflow, testing, quality, documentation, code-analysis, debugging) with dependency metadata.
**Step 3: Select skills (Apply minimum-skills principle)**
Choose only skills directly needed for the stated goals. This prevents over-composition and unnecessary failure points:
- Can a single skill handle this? If yes, invoke it directly. Invoke it directly.
- Can 2 skills handle this? Prefer that over 3+.
- Is a skill being added "for quality" or "just in case"? Remove it.
Cross-reference selections against `references/compatibility-matrix.md` to confirm chaining is valid before proceeding.
**Gate**: Task goals identified. Available skills indexed. Selected skills directly address stated goals with no extras. Proceed only when gate passes.
### Phase 2: PLAN
**Goal**: Build a validated execution DAG.
**Step 1: Build the DAG**
Construct the execution DAG as a JSON structure with nodes (skills) and edges (dependencies) based on the task analysis:
```bash
python3 ${CLAUDE_SKILL_DIR}/scripts/build_dag.py skill-index.json task-description.json
```
**Step 2: Validate the DAG (MANDATORY before execution)**
ALWAYS validate the execution graph is acyclic before moving to execution. Validation checks:
- **Acyclic**: No circular dependencies exist between skills
- **Compatibility**: Output types from each skill match input requirements of downstream skills (consult `references/compatibility-matrix.md`)
- **Availability**: All referenced skills exist in the skill index
- **Ordering**: Dependencies satisfy topological ordering
If validation fails, fix the issue and re-validate. Common fixes:
- Circular dependency: Remove one edge or split into two independent compositions
- Type mismatch: Choose different skill or add transformation step
- Missing skill: Check spelling, re-run discovery
- Ordering violation: Reorder phases to satisfy dependencies
**Step 3: Present the execution plan (Dry run is MANDATORY)**
ALWAYS show the execution plan and get user confirmation before running skills. This prevents wasting time on composition errors:
```
=== Execution Plan ===
Phase 1 (Sequential):
-> skill-name
Purpose: [what it does in this context]
Output: [what it produces]
Phase 2 (Parallel):
-> skill-a
Purpose: [what it does]
Input: [from Phase 1]
-> skill-b
Purpose: [what it does]
Input: [from Phase 1]
Phase 3 (Sequential):
-> skill-c
Purpose: [what it does]
Input: [from Phase 2]
Skills: N | Phases: N | Parallel phases: N
Proceed? [Y/n]
```
**Gate**: DAG is acyclic. All skills exist. Input/output types are compatible. Topological ordering is valid. User has seen the plan. Proceed only when gate passes.
### Phase 3: EXECUTE
**Goal**: Run skills in topological order, passing context between them.
**Step 1: Execute each phase**
For sequential phases:
1. Invoke skill with context from previous phases
2. Capture output
3. Verify output/input compatibility between chained skills
4. Proceed to next phase
For parallel phases:
1. Launch all independent skills using Task tool (execute independent skills concurrently when no shared resources or dependencies exist)
2. Wait for all to complete
3. Aggregate results for next phase
**Step 2: Pass context between skills**
ALWAYS verify output/input compatibility between chained skills before passing context:
1. Capture output from completed skill
2. Transform to format expected by next skill (validate using `references/compatibility-matrix.md`)
3. Inject as context when invoking next skill
4. Verify transformation succeeded
**Step 3: Report progress**
After each phase completes, report:
- Phase number and skills completed
- Output summary
- Overall progress (e.g., "Phase 2/3 complete")
Show command output rather than describing it. Be concise but informative.
**Step 4: Handle failures during execution**
ALWAYS catch skill failures and determine if remaining chain can continue. If a skill fails mid-chain:
1. **Assess impact**: Does this block downstream skills?
- Critical (blocks all downstream): Stop chain, report what completed
- Isolated (blocks one branch): Continue other branches
- Recoverable (transient failure): Retry with adjusted parameters (max 2 attempts)
2. **Report failure context**:
```
Skill failed: [skill-name]
Phase: N
Error: [error message]
Downstream impact: [list blocked skills]
Continuing branches: [list unaffected skills]
Recovery options:
1. Fix error and retry
2. Skip skill and continue (if non-critical)
3. Abort entire workflow
```
3. **Execute recovery**: Based on user selection or automatic policy (if auto-retry enabled)
**Gate**: All phases executed. All skill outputs captured. Context passed successfully between all transitions. Proceed only when gate passes.
### Phase 4: REPORT
**Goal**: Collect results and clean up.
**Step 1: Generate results summary**
```
=== Composition Results ===
Execution Summary:
Total phases: N
Skills executed: N
Duration: X minutes
Phase Results:
Phase 1: [skill-name] - [status]
Output: [summary]
Phase 2: [skill-a] - [status]
[skill-b] - [status]
Output: [summary]
Phase 3: [skill-c] - [status]
Output: [summary]
Final Output:
[Key deliverables with file paths]
```
**Step 2: Clean up temporary files**
Remove temporary files at task completion. Keep only files explicitly needed for final output:
- `/tmp/skill-index.json`
- `/tmp/execution-dag.json`
- Any intermediate output files created during composition
**Gate**: Results reported. Temporary files cleaned up. Composition complete.
---
## Error Handling
### Error: "Circular dependency detected"
Cause: Skills reference each other cyclically in the DAG
Solution:
1. Review dependency graph for cycles
2. Remove or reorder the problematic dependency
3. Consider splitting into independent compositions
4. Re-validate DAG before proceeding
### Error: "Skill output incompatible with next skill input"
Cause: Output type from one skill does not match expected input of the next
Solution:
1. Consult `references/compatibility-matrix.md` for valid chains
2. Add an intermediate transformation skill if one exists
3. Choose a different skill combination that has compatible types
4. Re-validate after changes
### Error: "Skill failed during execution"
Cause: A skill in the chain encountered an error
Solution:
1. Determine failure impact: critical (blocks downstream), isolated (one branch), or recoverable
2. If isolated: continue other branches, report partial results
3. If recoverable: retry with adjusted parameters (max 2 attempts)
4. If critical: abort chain, report what completed, suggest recovery options
### Error: "Skill not found in index"
Cause: Referenced skill does not exist or name is misspelled
Solution:
1. Check spelling against skill index output
2. Re-run discovery script to refresh the index
3. Verify the skill directory exists under skills/
4. Use the suggested alternative from the discovery output if the name was close
## References
- `${CLAUDE_SKILL_DIR}/references/composition-patterns.md`: Proven multi-skill composition patterns with duration estimates
- `${CLAUDE_SKILL_DIR}/references/compatibility-matrix.md`: Skill input/output compatibility and valid chains
- `${CLAUDE_SKILL_DIR}/references/skill-patterns.md`: Common skill patterns with sequential/parallel decision trees
章节与文件索引
按说明文件中的顺序排列。
概述
参考装载表
第一阶段:发现
第二阶段:计划
第三阶段:执行
文件/命令 -> compatibility-matrix.md · composition-patterns.md · examples.md · skill-patterns.md · references/compatibility-matrix.md · /tmp/skill-index.json · /tmp/execution-dag.json · ${CLAUDE_SKILL_DIR}/references/composition-patterns.md
内容校验值 -> b138348655db
当前原文的自动摘译,尚未人工审校。
概述
通过将多种技能链接到经过验证的执行 DAG 中来编排复杂的工作流程。该技能发现适用的技能、解决依赖性、验证兼容性、呈现执行计划以及管理技能到技能的上下文传递。当任务需要 2 个以上技能链接在一起、并行技能执行或技能之间的条件分支时使用。当单个技能可以单独处理请求时,或者不需要依赖管理的简单顺序调用时,可以直接调用该技能。
参考装载表
信号 · 加载这些文件 · 为什么任务与此参考相关 ·
compatibility-matrix.md· 从compatibility-matrix.md加载详细指导。实施模式 ·composition-patterns.md· 从composition-patterns.md加载详细指导。示例驱动的任务 ·examples.md· 从examples.md加载详细指导。实施模式 ·skill-patterns.md· 从skill-patterns.md加载详细指导。