名称：模式创建器描述：为技能、代理、钩子、工作流和数据结构创建 JSON Schema 验证文件。确保整个框架中的类型安全和输入验证。版本：2.1.0 模型：sonnet 调用者：双方用户可调用：true 工具：[Read, Write, Edit, Bash, Glob, Grep]

阶段 1 集成：模式根据 .claude/config/tool-manifest.json 验证工具

代理/技能模式从清单中引用可用工具

单一事实来源：.claude/config/tool-manifest.json

最佳实践：

使用 JSON Schema draft-07 或更高版本
为所有属性包含描述
明确定义必需与可选字段
在模式中添加示例
使用 $ref 实现可重用定义
保存前验证模式错误处理：优雅流式处理：支持输出位置：.claude/schemas/ 已验证：false 最后验证时间：2026-02-19T05:29:09.098Z

模式创建器技能

警告：请勿直接写入 .claude/schemas/

模式文件受 unified-creator-guard.cjs 保护（CLAUDE.md 中的 Gate 4）。直接写入会绕过创建后步骤（目录更新、消费者分配、集成验证）。始终使用 模式创建器 技能工作流来创建模式。直接写入会创建“不可见工件”，任何验证器或代理都无法发现。

为 Claude 代码企业框架创建 JSON Schema 验证文件。模式确保技能、代理、钩子、工作流和自定义数据结构之间的类型安全、输入验证和结构一致性。

系统影响分析（关键 - 请勿跳过）

创建任何模式后，您必须：

在适当位置注册（全局 vs 技能本地）
更新相关验证器以使用新模式
如果具有全局重要性，将模式引用添加到 CLAUDE.md

验证：

# 验证模式是有效的 JSON
node -e "JSON.parse(require('fs').readFileSync('.claude/schemas/<模式名称>.json'))"

# 检查模式是否存在
ls .claude/schemas/<模式名称>.json || ls .claude/skills/<技能>/schemas/<模式名称>.json

原因：无效模式会导致静默验证失败。未注册的模式永远不会被使用。

目的

模式为以下提供结构化验证：

技能输入/输出 - 验证传递给技能和从技能返回的数据
代理定义 - 验证代理 YAML 前项和结构
钩子定义 - 验证钩子配置和注册
工作流定义 - 验证工作流步骤和配置
自定义数据结构 - 验证项目特定数据格式

模式类型

类型	位置	目的
技能输入	`.claude/skills/{名称}/schemas/input.schema.json`	验证技能调用输入
技能输出	`.claude/skills/{名称}/schemas/output.schema.json`	验证技能执行输出
代理定义	`.claude/schemas/agent-definition.schema.json`	验证代理 YAML 前项
技能定义	`.claude/schemas/skill-definition.schema.json`	验证技能 YAML 前项
钩子定义	`.claude/schemas/hook-definition.schema.json`	验证钩子配置
工作流定义	`.claude/schemas/workflow-definition.schema.json`	验证工作流结构
自定义	`.claude/schemas/{名称}.schema.json`	项目特定验证

参考模式

使用 .claude/schemas/agent-definition.schema.json 作为规范参考模式。

在最终确定任何模式前，与参考进行比较：

[ ] 遵循 JSON Schema draft-07 或更高版本（首选 draft-2020-12）
[ ] 包含 $schema、$id、标题、描述、类型字段
[ ] 必需字段记录在“required”数组中
[ ] 所有属性都有描述字段
[ ] 在有用处包含示例
[ ] 使用正确的模式（烤肉串大小写名称、semver 版本）

CLAUDE.md 注册（强制）

创建模式后，如果该模式启用新功能，请更新 CLAUDE.md：

新工件类型模式 - 添加到相关部分（第 3 节用于代理，第 8.5 节用于技能）
代理/技能/工作流验证模式 - 在第 4 节（自我进化）中记录
框架范围模式 - 添加到本技能中的现有模式参考表中

验证：

grep "模式名称" .claude/CLAUDE.md || echo "警告：模式未在 CLAUDE.md 中注册"

阻塞：没有文档的模式可能不会被其他代理发现。

工作流

步骤 0：研究合成（强制 - 始终优先）

在创建任何模式之前，调用研究合成：

Skill({ skill: 'research-synthesis' });

研究要求：

至少进行 3 次 Exa 搜索 JSON Schema 最佳实践
查看 .claude/schemas/ 中的现有模式以获取模式
检查模式目录：.claude/context/artifacts/catalogs/schema-catalog.md
识别可作为引用的类似模式
在继续之前记录研究发现

原因：研究合成确保模式遵循行业最佳实践并与现有框架模式保持一致。

步骤 1：存在检查和更新器委托（强制 - 第二步）

在创建任何模式文件之前，检查是否已存在：

检查模式是否已存在：

test -f .claude/schemas/<模式名称>.json && echo "存在" || echo "新建"

如果模式存在：

请勿继续创建

改为调用工件更新器工作流：

Skill({
  skill: 'artifact-updater',
  args: {
    name: '<模式名称>',
    changes: '<请求更改的描述>',
    justification: '通过模式创建器请求更新',
  },
});

返回更新器结果并停止

如果模式是新建：
- 继续以下步骤 1.5

步骤 1.5：伴随检查

在继续创建之前，运行生态系统伴随检查：

使用 .claude/lib/creators/companion-check.cjs 中的 companion-check.cjs
调用 checkCompanions("schema", "{模式名称}") 以识别伴随工件
查看伴随清单 — 记录缺少哪些必需/推荐的伴随
计划在此工件完成后创建或验证缺少的伴随
在创建后集成笔记中包含伴随发现

此步骤是信息性的（不阻止创建），但确保考虑完整的工件生态系统。

步骤 2：收集模式要求

创建模式前，了解：

1. 您验证的是什么数据结构？
   - 技能输入/输出
   - 代理/技能/钩子/工作流定义
   - 自定义数据格式

2. 模式应位于何处？
   - 全局：.claude/schemas/（框架范围）
   - 本地：.claude/skills/{技能}/schemas/（技能特定）

3. 什么是必需与可选字段？
   - 必需：必须存在以有效数据
   - 可选：增强但不是必需

4. 什么是验证规则？
   - 类型（字符串、数字、布尔值、对象、数组）
   - 模式（字符串的正则表达式）
   - 范围（数字的最小/最大）
   - 枚举（允许的值）
   - 长度（字符串/数组的最小/最大）

步骤 3：确定模式类型和位置

创建对象	模式位置	示例
新技能输入	`.claude/skills/{技能}/schemas/input.schema.json`	`tdd` 技能参数
新技能输出	`.claude/skills/{技能}/schemas/output.schema.json`	`tdd` 技能结果
全局定义	`.claude/schemas/{名称}.schema.json`	`test-results.schema.json`
可重用组件	`.claude/schemas/components/{名称}.schema.json`	`task-status.schema.json`

步骤 4：分析数据结构

检查现有数据或指定预期结构：

// 示例：分析技能输出结构
const exampleOutput = {
  success: true,
  result: {
    filesCreated: ['src/test.ts'],
    testsGenerated: 5,
    coverage: 85.2,
  },
  metadata: {
    duration: 1234,
    skill: 'test-generator',
  },
};

// 从示例提取模式：
// - success: 布尔值（必需）
// - result: 对象（可选）
// - metadata: 对象（可选）

步骤 5：生成 JSON Schema

使用模式模板并进行自定义：

{
  "$schema": "https://json-schema.org/draft-07/schema#",
  "$id": "https://claude.ai/schemas/{模式名称}",
  "title": "{模式标题}",
  "description": "{此模式验证什么}",
  "type": "object",
  "required": ["字段1", "字段2"],
  "properties": {
    "字段1": {
      "type": "string",
      "description": "字段1的描述",
      "minLength": 1,
      "maxLength": 100
    },
    "字段2": {
      "type": "number",
      "description": "字段2的描述",
      "minimum": 0,
      "maximum": 100
    },
    "可选字段": {
      "type": "boolean",
      "description": "可选布尔字段",
      "default": false
    }
  },
  "additionalProperties": false
}

步骤 6：添加描述和示例

每个属性必须有描述：

{
  "properties": {
    "name": {
      "type": "string",
      "description": "资源的唯一标识符，采用小写带连字符格式",
      "pattern": "^[a-z][a-z0-9-]*$",
      "examples": ["my-skill", "test-generator", "code-reviewer"]
    }
  }
}

添加顶级示例：

{
  "examples": [
    {
      "name": "example-skill",
      "description": "一个用于演示的示例技能",
      "version": "1.0.0"
    }
  ]
}

步骤 7：创建验证测试

编写简单测试以验证模式是否有效：

// validate-schema-test.cjs
const Ajv = require('ajv');
const schema = require('./.claude/schemas/my-schema.schema.json');

const ajv = new Ajv({ allErrors: true });
const validate = ajv.compile(schema);

// 测试有效数据
const validData = {
  /* 有效示例 */
};
console.log('有效:', validate(validData));

// 测试无效数据
const invalidData = {
  /* 无效示例 */
};
console.log('无效:', validate(invalidData));
console.log('错误:', validate.errors);

步骤 8：创建后模式注册（阶段 1 集成）

此步骤是关键。 创建模式工件后，必须在模式发现系统中注册它。

阶段 1 上下文： 阶段 1 负责发现和目录化验证模式。未注册创建的模式对验证器和其他需要它们进行数据验证的系统是不可见的。

模式文件写入和验证后：

在适当位置创建/更新模式注册条目：

如果注册表不存在，创建 .claude/context/artifacts/schema-catalog.md：

{
  "schemas": [
    {
      "name": "{模式名称}",
      "id": "{模式名称}",
      "$id": "https://claude.ai/schemas/{模式名称}",
      "type": "{input|output|definition|global|component}",
      "description": "{此模式验证什么}",
      "version": "1.0.0",
      "filePath": ".claude/schemas/{模式名称}.schema.json",
      "validatesFor": ["{工件类型-1}", "{工件类型-2}"],
      "relatedSchemas": [],
      "usedBy": ["{验证器-钩子}", "{创建器-技能}"]
    }
  ]
}

向验证器注册：

更新应使用此模式的任何验证钩子：

检查 .claude/hooks/validation/ 以查找相关验证器
将模式添加到需要它的验证器中的 schemaMap

示例：

const schemaMap = {
  '.claude/agents/': '.claude/schemas/agent-definition.schema.json',
  '.claude/schemas/{模式名称}.schema.json': require('./.claude/schemas/{模式名称}.schema.json'),
};

记录在 .claude/context/artifacts/catalogs/schema-catalog.md 中：

将条目添加到模式目录：

### {模式标题} (`{模式名称}.schema.json`)

**$id:** `https://claude.ai/schemas/{模式名称}`

**目的：** {此模式验证什么的详细描述}

**使用者：**

- {验证器/钩子 1}
- {创建器技能 1}

**根属性：**

- {属性-1}: {描述}
- {属性-2}: {描述}

**示例有效数据：**

```json
{
  "example": "value"
}
```

必需字段： {列出必需字段}

验证： 当数据匹配此模式时，{描述验证内容}

如果模式启用新功能，更新 .claude/CLAUDE.md：

如果此模式支持新工件类型或验证：
- 添加到相关部分（第 4.1 节用于创建器模式，第 9.7 节用于模式目录）
- 添加到此技能步骤 7 中的“现有模式参考”表
示例条目：
```
| `{模式名称}` | `.claude/schemas/` | {目的} |
```

更新记忆：

附加到 .claude/context/memory/learnings.md：

## 模式：{模式名称}

- **类型：** {input|output|definition|global|component}
- **验证：** {什么工件/数据类型}
- **目的：** {详细目的}
- **$id：** https://claude.ai/schemas/{模式名称}
- **验证器：** {哪些钩子/验证器使用它}
- **相关模式：** {任何 $ref 引用}

为什么重要： 如果没有模式注册：

验证器无法发现和使用模式
系统范围内的数据验证不会发生
无效工件未经检测就被创建
出现“不可见工件”模式

阶段 1 集成： 模式注册表是阶段 1 的发现机制，使验证器能够在整个系统中一致地找到和应用模式。

步骤 9：系统影响分析（强制）

在标记模式创建完成前，验证所有项目：

[ ] 模式文件在正确位置创建
[ ] 模式是有效的 JSON（可解析）
[ ] 模式有 $schema、$id、标题、描述
[ ] 所有必需字段在“required”数组中定义
[ ] 所有属性都有描述
[ ] 复杂模式包含示例
[ ] 模式注册条目已创建（步骤 7）
[ ] 验证器已向模式注册（如果适用）
[ ] SCHEMA_CATALOG.md 已更新（步骤 7）
[ ] 相关文档已更新

验证命令：

# 验证 JSON 语法
node -e "JSON.parse(require('fs').readFileSync('.claude/schemas/{名称}.schema.json'))"

# 检查必需字段
node -e "const s = require('.claude/schemas/{名称}.schema.json'); console.log('标题:', s.title); console.log('描述:', s.description);"

# 检查模式注册
grep "{模式名称}" .claude/context/artifacts/schema-catalog.md

# 列出所有模式
ls -la .claude/schemas/*.schema.json

阻塞：如果任何项目失败，模式创建是不完整的。所有项目必须通过。

系统影响分析（强制）

创建模式后，完成以下所有内容：

1. CLAUDE.md 更新

如果模式启用新功能，添加到适当部分
第 3 节用于代理相关模式
第 4.1 节用于创建器生态系统模式
第 8.5 节用于技能相关模式

2. 验证器集成

检查钩子是否应针对新模式进行验证
更新 .claude/hooks/ 如果模式影响验证
将模式添加到相关验证器中的 schemaMap

3. 相关模式

如果需要，更新相关模式（$ref 链接）
检查循环依赖
确保 $id 值是唯一的

4. 文档

如果模式记录新模式，更新 .claude/docs/
将模式添加到现有模式参考表
如果模式用于新技能，更新 skill-catalog.md

验证清单：

# 检查 CLAUDE.md 注册
grep "{模式名称}" .claude/CLAUDE.md

# 检查其他模式中的 $ref 使用
grep -r "{模式名称}" .claude/schemas/

# 验证无重复 $id
grep -h "\$id" .claude/schemas/*.json | sort | uniq -d

阻塞：模式创建未完成，直到所有影响分析项目已验证。

模式模板

基本输入模式

{
  "$schema": "https://json-schema.org/draft-07/schema#",
  "$id": "https://claude.ai/schemas/技能名称输入",
  "title": "技能名称输入模式",
  "description": "技能名称技能的输入验证模式",
  "type": "object",
  "required": [],
  "properties": {
    "target": {
      "type": "string",
      "description": "目标文件或目录路径"
    },
    "options": {
      "type": "object",
      "description": "可选配置",
      "properties": {
        "verbose": {
          "type": "boolean",
          "default": false
        }
      }
    }
  },
  "additionalProperties": false
}

基本输出模式

{
  "$schema": "https://json-schema.org/draft-07/schema#",
  "$id": "https://claude.ai/schemas/技能名称输出",
  "title": "技能名称输出模式",
  "description": "技能名称技能的输出验证模式",
  "type": "object",
  "required": ["success"],
  "properties": {
    "success": {
      "type": "boolean",
      "description": "技能是否成功执行"
    },
    "result": {
      "type": "object",
      "description": "技能执行结果",
      "additionalProperties": true
    },
    "error": {
      "type": "string",
      "description": "如果执行失败，错误消息"
    }
  },
  "additionalProperties": false
}

定义模式（用于代理、技能、钩子）

{
  "$schema": "https://json-schema.org/draft-07/schema#",
  "$id": "https://claude.ai/schemas/实体定义",
  "title": "实体定义模式",
  "description": "验证实体定义文件的模式",
  "type": "object",
  "required": ["name", "description"],
  "properties": {
    "name": {
      "type": "string",
      "pattern": "^[a-z][a-z0-9-]*$",
      "description": "实体名称，采用小写带连字符格式"
    },
    "description": {
      "type": "string",
      "minLength": 20,
      "maxLength": 500,
      "description": "实体目的的清晰描述"
    },
    "version": {
      "type": "string",
      "pattern": "^\\d+\\.\\d+(\\.\\d+)?$",
      "default": "1.0.0",
      "description": "语义版本号"
    }
  },
  "additionalProperties": true,
  "examples": [
    {
      "name": "my-entity",
      "description": "一个用于演示的示例实体",
      "version": "1.0.0"
    }
  ]
}

常见 JSON Schema 模式

字符串模式

{
  "kebab-case": {
    "type": "string",
    "pattern": "^[a-z][a-z0-9-]*$"
  },
  "semver": {
    "type": "string",
    "pattern": "^\\d+\\.\\d+(\\.\\d+)?$"
  },
  "file-path": {
    "type": "string",
    "pattern": "^[\\w./-]+$"
  },
  "email": {
    "type": "string",
    "format": "email"
  },
  "url": {
    "type": "string",
    "format": "uri"
  }
}

枚举模式

{
  "model": {
    "type": "string",
    "enum": ["sonnet", "opus", "haiku", "inherit"]
  },
  "priority": {
    "type": "string",
    "enum": ["lowest", "low", "medium", "high", "highest"]
  },
  "status": {
    "type": "string",
    "enum": ["pending", "in_progress", "completed", "failed", "blocked"]
  }
}

数组模式

{
  "tools": {
    "type": "array",
    "items": { "type": "string" },
    "minItems": 1,
    "uniqueItems": true,
    "description": "可用工具列表"
  },
  "skills": {
    "type": "array",
    "items": { "type": "string", "pattern": "^[a-z][a-z0-9-]*$" },
    "description": "技能名称列表"
  }
}

对象模式

{
  "config": {
    "type": "object",
    "additionalProperties": false,
    "properties": {
      "enabled": { "type": "boolean", "default": true },
      "timeout": { "type": "integer", "minimum": 0 }
    }
  },
  "metadata": {
    "type": "object",
    "additionalProperties": true,
    "description": "任意元数据"
  }
}

条件模式

{
  "if": {
    "properties": {
      "type": { "const": "mcp" }
    }
  },
  "then": {
    "required": ["server", "command"]
  },
  "else": {
    "required": ["handler"]
  }
}

使用 $ref 实现可重用性

{
  "$defs": {
    "namePattern": {
      "type": "string",
      "pattern": "^[a-z][a-z0-9-]*$",
      "description": "小写带连字符"
    },
    "toolsList": {
      "type": "array",
      "items": { "type": "string" },
      "minItems": 1
    }
  },
  "properties": {
    "name": { "$ref": "#/$defs/namePattern" },
    "tools": { "$ref": "#/$defs/toolsList" }
  }
}

CLI 使用

从模板创建模式

# 创建技能输入模式
node .claude/skills/schema-creator/scripts/main.cjs \
  --type input \
  --skill my-skill

# 创建技能输出模式
node .claude/skills/schema-creator/scripts/main.cjs \
  --type output \
  --skill my-skill

# 创建全局模式
node .claude/skills/schema-creator/scripts/main.cjs \
  --type global \
  --name my-data-format

# 创建定义模式
node .claude/skills/schema-creator/scripts/main.cjs \
  --type definition \
  --entity workflow

验证模式

# 验证模式文件
node .claude/skills/schema-creator/scripts/main.cjs \
  --validate .claude/schemas/my-schema.schema.json

# 验证数据针对模式
node .claude/skills/schema-creator/scripts/main.cjs \
  --validate-data data.json \
  --schema .claude/schemas/my-schema.schema.json

从示例生成模式

# 从 JSON 示例生成模式
node .claude/skills/schema-creator/scripts/main.cjs \
  --from-example example.json \
  --output .claude/schemas/generated.schema.json

与验证器集成

使用 Ajv 进行运行时验证

const Ajv = require('ajv');
const addFormats = require('ajv-formats');

const ajv = new Ajv({ allErrors: true });
addFormats(ajv);

// 加载并编译模式
const schema = require('./.claude/schemas/skill-definition.schema.json');
const validate = ajv.compile(schema);

// 验证数据
function validateSkillDefinition(data) {
  const valid = validate(data);
  if (!valid) {
    return {
      valid: false,
      errors: validate.errors.map(e => `${e.instancePath} ${e.message}`),
    };
  }
  return { valid: true };
}

预提交验证钩子

// .claude/hooks/schema-validator.js
const fs = require('fs');
const path = require('path');
const Ajv = require('ajv');

const schemaMap = {
  '.claude/agents/': '.claude/schemas/agent-definition.schema.json',
  '.claude/skills/': '.claude/schemas/skill-definition.schema.json',
  '.claude/hooks/': '.claude/schemas/hook-definition.schema.json',
};

function validateFile(filePath) {
  // 找到匹配模式
  for (const [pattern, schemaPath] of Object.entries(schemaMap)) {
    if (filePath.includes(pattern)) {
      const schema = JSON.parse(fs.readFileSync(schemaPath));
      const ajv = new Ajv();
      const validate = ajv.compile(schema);

      // 解析和验证文件
      // ...
    }
  }
}

工作流集成

此技能是统一工件生命周期的一部分。对于完整的多代理协调：

路由器决策： .claude/workflows/core/router-decision.md

路由器如何发现和调用此技能的工件

工件生命周期： .claude/workflows/core/skill-lifecycle.md

发现、创建、更新、弃用阶段
版本管理和注册表更新
CLAUDE.md 集成要求

外部集成： .claude/workflows/core/external-integration.md

安全集成外部工件
安全审查和验证阶段

交叉参考：创建器生态系统

此技能是创建器生态系统的一部分。对于相关工件，使用伴随创建器：

创建器	何时使用	调用
agent-creator	创建使用模式的代理	`Skill({ skill: 'agent-creator' })`
skill-creator	创建带有输入/输出模式的技能	`Skill({ skill: 'skill-creator' })`
hook-creator	创建带有验证的钩子	`Skill({ skill: 'hook-creator' })`
workflow-creator	创建带有步骤模式的工作流	`Skill({ skill: 'workflow-creator' })`
template-creator	创建带有数据模式的模板	`Skill({ skill: 'template-creator' })`

集成链

[SKILL-CREATOR] 创建具有验证的新技能...
  -> 调用 schema-creator 获取输入/输出模式
  -> 模式创建在 .claude/skills/{技能}/schemas/

[AGENT-CREATOR] 创建具有严格验证的代理...
  -> 代理使用 agent-definition.schema.json 进行自我验证
  -> 代理使用自定义模式验证输入

[WORKFLOW-CREATOR] 创建具有类型化步骤的工作流...
  -> 每个步骤输出根据模式验证
  -> 工作流使用 workflow-definition.schema.json

现有模式参考

总活动模式： 27（25 已归档 - 见 .claude/schemas/_archive/） 活动验证（Ajv）： 8 个具有运行时验证的模式 文档参考： 16 个作为结构模板的模式 可选验证： 3 个定义了路径但验证跳过的模式

完整目录： .claude/context/artifacts/catalogs/schema-catalog.md

按类别活动模式

代理模式（5）

模式	布线状态	消费者
`agent-capability-card`	WIRED	generate-agent-registry
`agent-config`	WIRED	agent-config.cjs
`agent-definition`	WIRED	agent-parser.cjs
`agent-identity`	WIRED	agent-parser.cjs
`agent-spawn-params`	DOCS ONLY	Spawn prompt reference

技能模式（4）

模式	布线状态	消费者
`skill-definition`	WIRED	skill-creator/create.cjs
`skill-diagram-generator-output`	SOFT-WIRED	diagram-generator skill
`skill-repo-rag-output`	SOFT-WIRED	repo-rag skill
`skill-test-generator-output`	SOFT-WIRED	test-generator skill

工作流和钩子模式（2）

模式	布线状态	消费者
`workflow-definition`	DOCS ONLY	No workflow-creator scripts
`hook-definition`	DOCS ONLY	No hook-creator scripts

进化和项目模式（2）

模式	布线状态	消费者
`evolution-state`	WIRED	self-healing/validator.cjs
`track-metadata`	DOCS ONLY	TaskCreate metadata field

工具和模板模式（3）

模式	布线状态	消费者
`tool-manifest`	WIRED	generate-tool-manifest.cjs
`presets`	WIRED	spawn/prompt-assembler.cjs
`adr-template`	DOCS ONLY	ADR 文档结构

规划模式（5）

模式	布线状态	消费者
`plan`	DOCS ONLY	Planning phase reference
`implementation-plan`	DOCS ONLY	Implementation planning
`phase-models`	DOCS ONLY	Phase planning reference
`product_requirements`	DOCS ONLY	Requirements gathering
`project_brief`	DOCS ONLY	Project initialization

测试模式（2）

模式	布线状态	消费者
`test_plan`	DOCS ONLY	Test planning reference
`test-results`	DOCS ONLY	Test execution output

架构模式（3）

模式	布线状态	消费者
`specification-template`	DOCS ONLY	Specification documents
`system_architecture`	DOCS ONLY	Architecture documentation
`ux_spec`	DOCS ONLY	UX specification documents

项目模式（1）

模式	布线状态	消费者
`project-analysis`	DOCS ONLY	Project analyzer output

注意： 除非另有指定，所有模式都位于 .claude/schemas/。有关消费者、验证方法和集成状态的完整详细信息，请参见模式目录。

文件放置和标准

输出位置规则

此技能输出到：.claude/schemas/

对于技能特定模式：.claude/skills/<技能名称>/schemas/

模式命名约定：

全局模式：<名称>.schema.json
技能输入：input.schema.json
技能输出：output.schema.json
组件：components/<名称>.schema.json

强制参考

文件放置： 见 .claude/docs/FILE_PLACEMENT_RULES.md
开发者工作流： 见 .claude/docs/DEVELOPER_WORKFLOW.md
工件命名： 见 .claude/docs/ARTIFACT_NAMING.md
工作区约定： 见 .claude/rules/workspace-conventions.md（输出放置、命名、来源）

执行

文件放置由 file-placement-guard.cjs 钩子执行。无效放置将在生产模式下被阻止。

记忆协议（强制）

开始前：

cat .claude/context/memory/learnings.md

检查：

先前创建的模式
已知验证问题
模式命名约定

完成后：

新模式创建 -> 附加到 .claude/context/memory/learnings.md
发现验证问题 -> 附加到 .claude/context/memory/issues.md
架构决策 -> 附加到 .claude/context/memory/decisions.md

假设中断：您的上下文可能重置。如果它不在记忆中，它就没有发生。

模式创建的钢铁法则

这些规则是不可违反的。违反会导致验证失败。

1. 无模式无 $schema 字段
   - 每个模式必须声明其 JSON Schema 版本
   - 使用 draft-07 或更高版本："$schema": "https://json-schema.org/draft-07/schema#"

2. 无模式无标题和描述
   - 每个模式必须是自文档化的
   - 标题：简短名称，描述其验证什么
   - 描述：目的的详细解释

3. 无属性无描述
   - 每个属性必须有描述
   - 读者应理解字段目的而无需外部文档

4. 无必需字段无定义
   - 如果字段在“required”数组中，它必须在“properties”中定义
   - 未定义的必需字段会导致静默验证失败

5. 无 additionalProperties: true 无原因
   - 默认使用 additionalProperties: false 进行严格验证
   - 仅在明确需要时允许额外属性

6. 无模式无验证测试
   - 用有效和无效示例测试模式
   - 通过所有内容的模式没有验证任何内容

7. 无创建无系统影响分析
   - 检查相关验证器是否需要更新
   - 检查文档是否需要更新
   - 检查相关模式是否需要交叉引用

8. 无模式无 CLAUDE.MD 注册
   - 如果模式启用新功能，更新 CLAUDE.md
   - 第 4 节（自我进化）用于代理/技能/工作流模式
   - 验证：grep "模式名称" .claude/CLAUDE.md

验证清单（每次创建后运行）

# 验证模式是有效的 JSON
node -e "JSON.parse(require('fs').readFileSync('.claude/schemas/{名称}.schema.json'))"

# 检查必需字段是否存在
node -e "const s = require('.claude/schemas/{名称}.schema.json'); console.log('有 $schema:', !!s.\$schema); console.log('有标题:', !!s.title); console.log('有描述:', !!s.description);"

# 检查所有必需属性是否已定义
node -e "const s = require('.claude/schemas/{名称}.schema.json'); const r = s.required || []; const p = Object.keys(s.properties || {}); console.log('缺失:', r.filter(x => !p.includes(x)));"

# 列出所有模式
ls -la .claude/schemas/*.schema.json

完成清单（所有必须检查）：

[ ] 模式文件已创建，扩展名为 .schema.json
[ ] $schema 字段存在（draft-07 或更高版本）
[ ] 标题和描述存在
[ ] 所有属性都有描述
[ ] required 数组匹配定义的属性
[ ] 复杂模式包含示例
[ ] 模式已用测试数据验证
[ ] 系统影响分析已完成
[ ] 如果模式启用新功能，CLAUDE.md 已更新
[ ] 如果需要，相关模式已更新（$ref 链接）

阻塞：如果任何项目失败，模式创建是不完整的。在继续之前所有项目必须通过。

创建后集成

创建完成后，运行生态系统集成清单：

从 .claude/lib/creators/creator-commons.cjs 调用 runIntegrationChecklist(artifactType, artifactPath)
从 .claude/lib/creators/creator-commons.cjs 调用 queueCrossCreatorReview(artifactType, artifactPath)
查看影响报告 — 在标记任务完成前解决所有 mustHave 项目
记录任何 shouldHave 项目作为后续任务

集成验证：

[ ] 模式已添加到 schema-catalog.md
[ ] 模式验证器已布线（如果适用）
[ ] 模式由消费工件引用
[ ] 模式有测试数据示例