@givolt/i3-composer-agent 2.3.7 → 3.1.0

package/skills/i3-ui-demo/references/resources.md

@@ -0,0 +1,142 @@
+# 资源与实例约定
+
+<!-- i3:zh-guide:start -->
+## 中文使用说明
+
+按下文完整工程步骤、检查项与验证条件执行。根据任务选择适用步骤，保留证据、风险和退出条件；正文示例中的英文标签在面向用户输出时译为中文。
+
+默认使用简体中文解释、追问及生成报告；用户明确要求其他语言时可切换。原方法正文、引用、阈值和审批条件完整保留。代码标识、路径、命令、工具参数、JSON 键/枚举与原文引用保持原样。
+<!-- i3:zh-guide:end -->
+
+进入模板选择、初始化或接续实例时读取本文件。
+
+## 定位资源
+
+用本次实际加载的技能绝对目录执行 `scripts/resources.cjs`。它只读返回模板、生成配置、设计规则、独立 starter 与固定版本配置的位置。
+源目录为 `skills/i3-ui-demo`，发行目录为 `skills/i3-ui-demo`；脚本按当前目录识别源或发行名称。
+企业后台模板由本技能独立持有，保存在 `assets/templates/enterprise-admin/`，生成配置、设计规则、参考页面及其资源均从本技能目录读取。
+不读取其他技能的模板，不使用跨技能链接或缺失时回退。缺少本技能模板时报告缺项，修复本技能资源后继续，不静默改用简易模板。
+保留导入来源、版权和历史资料；来源记录只用于溯源，不是运行时读取路径。专业技能和固定工具仍按依赖流程准备。
+
+## 生成与检查共用的自有资源
+
+| 文件 | 用途 |
+| --- | --- |
+| `generation.json` | 布局、风格、密度候选与页面模式；当前选择先于设计查询 |
+| `capability-definition.json` | 26 类能力、10 种页面模式、参数约束、原生组件映射、应用职责及验收场景的统一依据 |
+| `template-inventory.json` | 页面、路由、HTML 功能节点、事件、组件来源和资源摘要 |
+| `component-inventory.json` | 原参考组件的归类与说明，辅助理解映射 |
+| `preset.json`、`design-system.md` | 原模板配色、字体、间距、圆角与设计规则 |
+| `reference/` | 本技能持有的原页面 HTML、行为与状态脚本、样式、历史测试和截图；不是外部 Skill 链接 |
+
+能力和组件映射已经整合进一个能力定义，不再加载其他技能的规则、执行器或验收文件。来源记录仅用于追溯。模板索引覆盖 35 个参考页面、44 条路由；这些数字表示参考资料范围，不代表业务页面已经实现。
+
+将 `<skill-root>` 替换为本次实际加载的技能绝对目录：
+
+```text
+node <skill-root>/scripts/resources.cjs
+node <skill-root>/scripts/resources.cjs --page models-page
+node <skill-root>/scripts/resources.cjs --page models-page --fragment reference/src/models/ModelTable.html
+node <skill-root>/scripts/resources.cjs --capability pagination
+node <skill-root>/scripts/resources.cjs --plan <业务范围JSON绝对路径>
+```
+
+无参数输出包含可用 `referencePages`、资源绝对路径、视觉参数和模板摘要。`--page app-shell` 读取公共壳层；其他标识来自 `referencePages`，不猜测文件名。页面输出列出关联 HTML、行为文件及其相对导入、样式和功能节点数。`--fragment` 只接受该页实际包含的片段，返回原文和节点；随后实际读取相关行为及样式文件，不能仅凭节点数量推断功能。
+
+`--capability` 返回所选能力的参数、场景、原生组件及应用职责，组件 API 再由 `antdv` 和固定 CLI 核对。`--plan` 读取业务范围，计算必需能力、节点映射和检查场景；全部入口只读，不安装、不生成业务代码、不启动浏览器、不填写通过状态。
+资源缺失或摘要不一致时失败，不借用其他技能补齐。`templateDigest` 绑定本技能的模板清单、资源摘要和节点索引；它不是业务完成或浏览器执行的证明。
+
+## 从业务范围形成模板合同
+
+需求来源沿用现有记录；新实例可以在 `inputs/scope.json` 整理如下最小结构，不凭模板示例发明业务需求：
+
+```json
+{
+  "pages": [{
+    "id": "assets", "title": "资产台账", "referencePage": "models-page",
+    "regions": [{
+      "id": "list", "pattern": "management-list",
+      "fields": [{"id": "name", "label": "资产名称", "type": "text", "requirementId": "ASSET-01"}],
+      "actions": [{"id": "query", "label": "查询", "target": "page", "outcome": "显示匹配资产并回到第一页", "requirementId": "ASSET-01"}]
+    }]
+  }],
+  "requirements": [{
+    "id": "ASSET-01", "text": "按名称查询资产", "pages": ["assets"],
+    "source": {"type": "user", "reference": "用户提示词", "statement": "按名称查询资产"}
+  }]
+}
+```
+
+这是结构示例，不是完整业务范围。实际需求包括详情、编辑或删除时，增加相应区域、字段和操作。编辑展示形式写在区域 `parameters.edit.presentation`；整页表单、向导和权限页采用 page，编辑区域采用 drawer 或 modal。分页参数等按 `--capability` 返回的规则补充。没有字段或操作的区域要填写具体 `emptyReason`；不以空数组冒充完整业务设计。
+
+选择写在 `generation.presentation`，与已确认的 `prototype-config.json.presentation` 一致。运行 `--plan` 后将 JSON 输出保存为实例 `inputs/template-contract.json`，不再维护另一套独立能力清单：
+
+- `bindings` 对应页面/区域的能力、业务字段和操作，`scenarios` 给出其检查预期。
+- `referenceCoverage` 给出所选页面及壳层的实际功能节点、事件和参考文件。
+- `pendingDecisions` 中的额外参考能力，在范围的 `generation.decisions` 按 pageId、capabilityId、requirementId、reason 记录 adopted 或 not-applicable；采用时提供 regionId 和必要 parameters。必需能力不能排除。
+- `pendingReferenceElements` 在 `generation.referenceDecisions` 按 pageId、nodeIds、requirementId、reason 逐项映射。mapped 还需同页或公共壳层的 bindingIds，必须匹配节点能力；事件须绑定业务 action 或写明可观察的 behavior。不适用用 not-applicable 并说明业务理由，不填写实现绑定。相同处理可合并一组真实节点。
+- `pendingBusinessDetails` 表示业务字段或操作尚缺。补充后重新计算合同，保留用户决定，不自动把未决项标为完成。
+
+节点映射会生成独立参考检查场景，避免只检查一个通用按钮便声称整页覆盖。合同始终返回 `pending-implementation` 和 `executionVerified=false`；源码、构建、浏览器结果及用户认可分别记录。剩余缺项可以交付说明，但不能宣称完整实现或全部验收通过。
+
+## 保留原模板效果
+
+默认侧栏布局、商务风格、标准密度与 `preset.json` 对齐：主色 #1677ff、页面底色 #f5f5f5、白色面板、正文 14px、内容间距 24px、面板圆角 8px、控件圆角 6px、侧栏 224px、顶栏 64px。当前 starter 的默认主题与尺度遵循这些输入；其他主题和变体仍是可选项，不自动替换已确认风格。
+
+HTML 是结构与交互参考，目标使用真实 Vue 与 antdv-next 1.6.0 组件。读取表格、筛选、列设置、批量、编辑、详情等关联片段和状态脚本，保留适用功能，再替换实际业务字段与数据。不要直接注入参考运行时、复制旧版组件 CSS，或把 EASEL 示例业务当成已确认需求。树列表、树表等声明的模式仍需实际业务实现，不是已有完整 Vue 页面。
+
+`ui-ux-pro-max` 的查询必须带入选定模板和视觉基准；冲突建议先作取舍。检查阶段复用同一合同及本技能参考，在相同视口、主题和状态下对照页面结构、功能、颜色与尺度。历史截图保留来源用途，不作为当前构建证据。复制 starter、拥有某组件或通过构建均不能证明交付效果一致。
+
+## 设计系统一致性
+
+`ui-ux-pro-max` 的查询结果先作为候选。业务分类、页面模式或视觉方向不适合时，调整关键词或补充相关领域查询，保留实际返回和取舍理由；不能只在对话中否决，再将同一结果原样持久化为 Master。
+确认后使用原生 Master 与页面覆盖结构保存设计，读回实际文件，核对分类、页面模式、配色、风格、密度和动效是否符合模板与用户选择。
+生成内容有冲突时，先修正查询或根据确认的模板和设计决定整理有效规则，并注明哪些来自查询、模板或用户选择；原始未采用结果可以作为历史资料，不作为当前规范。
+例如已选浅色商务后台时，Master 不能仍要求暗色玻璃风格和营销落地页结构；也不能依靠每页覆盖来掩盖全局规范错误。已有人工规则按增量约定保护，不用 `--force` 重写。
+
+## 设计系统目录约定
+
+`ui-ux-pro-max` 2.15.0 的 `--output-dir` 是设计系统目录的父目录。对本技能，传入本次原型根目录的绝对路径，通常为 `<业务项目>/prototypes/<id>`，不是其中的 `design-system/` 或 `app/`。用户指定其他实例位置时使用该位置。
+脚本自行生成 `<原型根目录>/design-system/<project-slug>/`；`<project-slug>` 来自 `--project-name`，默认采用原型 ID，已有实例沿用现有标识，不随页面或会话重新命名。
+
+在实际加载的 `ui-ux-pro-max` 技能目录定位 scripts/search.py。设计确认且原型目录已建立后，按原生入口持久化，例如：
+
+```bash
+python3 "<ui-ux-pro-max技能绝对目录>/scripts/search.py" "<业务与设计关键词>" \
+  --design-system --persist --project-name "project-initiation" \
+  --output-dir "<业务项目绝对路径>/prototypes/project-initiation" --json
+```
+
+此例应产生 `prototypes/project-initiation/design-system/project-initiation/MASTER.md`，以及同级 pages/ 目录。保留项目 slug 这一层；传入 `.../design-system` 会导致错误的 `design-system/design-system/...` 嵌套。
+全局规则保存在 MASTER.md；只有实际页面需要偏离全局规则时才使用 `--page "<页面标识>"`。`--page global` 仅创建名为 global 的页面文件，没有自动应用到全部页面的含义。
+
+读取 JSON 返回的 `persistence.status`、`design_system_dir`、`master_file` 和 `created_files`，核对路径属于本次实例，且目录结构与以上约定一致，再读回实际文件。
+`skipped_exists` 表示已有文件受到保护，不代表本次查询已写入；先读取现有 Master 和相关页面规则。新页面覆盖仍按原生行为处理，不能据此重写 Master 或擅自加 `--force`。
+发现重复嵌套或落在错误实例时，保留现场并修正调用参数，检查已有内容和引用后再处理；不靠生成后自动搬目录掩盖错误。
+实例初始化前的设计查询留在准备区，不带 `--persist`，避免提前创建要求不存在的目标目录。
+
+## 创建实例
+
+1. 明确业务项目、原型 ID、需求来源、用户的模板和设计选择。
+2. 实际完成固定依赖检查。初始化目标不存在时，把准备查询留在 `prototypes/.preparation/<id>/` 或已授权的独立准备区。
+3. 核对目标目录用途；新建只复制本技能 `assets/starter/` 到实例 `app/`，不覆盖已有目录。
+4. 根据本次需求适配 app/src，替换“业务页面待实现”的骨架，使用实际字段、状态和模拟数据。
+   将用户确认的布局、风格和密度同时写入业务范围的 generation.presentation 和 prototype-config.json 的 presentation；动效选择落实到主题或样式，并尊重系统减少动效设置。不能只改标题和 pages 就当作完成模板适配。
+5. 在 app/ 执行其 package.json 声明的 install、typecheck、test、build 和 preview 命令。组件与锁文件固定，不能复制旧 starter 的锁文件覆盖本技能锁文件。
+
+推荐实例资料：
+- `inputs/`：来源文件或引用、范围与版本，以及 `template-contract.json` 中的模板能力、节点映射和场景。
+- `requirements-map.json`：原文需求到页面、操作、状态、实施文件及验证场景的对应。
+- `design-system/<project-slug>/MASTER.md` 与 pages/：ui-ux-pro-max 的原生设计系统与页面覆盖。
+- `qa/`：对应当前代码和构建的真实检查结果、截图及未完成项。
+- `HANDOFF.md`：本次完成范围、用户选择、版本、启动与预览入口、缺项和下一步。
+
+这些名称用于新实例约定；已有原型沿用现有资料，不为了统一格式自动迁移。
+只维护一份任务状态。需求映射保存来源和对应关系，不再创建第二份独立任务勾选清单。
+记录当前源码与实际构建的身份或摘要，检查后修改代码时复测相关内容；不声称本技能提供不可伪造的执行证明。
+
+## 增量接续
+
+先读取真实代码、用户手改、全局设计和页面规则，再修改本次相关内容。
+新增页面沿用全局规则；仅需局部设计时不重写 Master。模板、组件或整体风格变化先明确影响范围。
+保留其他页面、模拟数据、旧证据和确认记录；旧证据作为历史保留，不自动作为当前通过状态。

package/skills/i3-ui-demo/scripts/dependencies.cjs

@@ -0,0 +1,364 @@
+#!/usr/bin/env node
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const assert = require('node:assert/strict');
+const { spawnSync } = require('node:child_process');
+const resources = require('./resources.cjs');
+const { safe } = require('./mcp.cjs');
+const pinned = resources.versions;
+const sourceFiles = require('../assets/official-files.json');
+const hash = data => crypto.createHash('sha256').update(data).digest('hex');
+const json = file => JSON.parse(fs.readFileSync(file, 'utf8'));
+const { resolveLocations } = require('./locations.cjs');
+const { checkDesignProvider, queryProvider } = require('./design-provider.cjs');
+function versionRelation(actual, required) {
+  const parse = value => typeof value === 'string' && value.match(/^(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)(?:-([0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*))?(?:\+[0-9A-Za-z.-]+)?$/);
+  const a = parse(actual), b = parse(required);
+  if (!a || !b) return 'unknown';
+  for (let i = 1; i <= 3; i++) if (BigInt(a[i]) !== BigInt(b[i])) return BigInt(a[i]) > BigInt(b[i]) ? 'higher' : 'lower';
+  if (a[4] === b[4]) return 'same';
+  if (!a[4] || !b[4]) return !a[4] ? 'higher' : 'lower';
+  const ap = a[4].split('.'), bp = b[4].split('.');
+  for (let i = 0; i < Math.max(ap.length, bp.length); i++) {
+    if (ap[i] === bp[i]) continue;
+    if (ap[i] === undefined || bp[i] === undefined) return ap[i] === undefined ? 'lower' : 'higher';
+    const an = /^\d+$/.test(ap[i]), bn = /^\d+$/.test(bp[i]);
+    if (an !== bn) return an ? 'lower' : 'higher';
+    return (an ? BigInt(ap[i]) > BigInt(bp[i]) : ap[i] > bp[i]) ? 'higher' : 'lower';
+  }
+  return 'same';
+}
+function run(command, args, cwd, env = process.env, timeout = 180000) {
+  const result = spawnSync(command, args, { cwd, env: { ...env, ANTDV_NO_AUTO_REPORT: '1', npm_config_update_notifier: 'false' }, encoding: 'utf8', timeout, maxBuffer: 8 * 1024 * 1024, shell: false });
+  if (result.error || result.status !== 0) {
+    const output = (result.stderr || result.stdout || '').trim();
+    const diagnostic = output.length > 1800 ? `${output.slice(0, 900)}\n...\n${output.slice(-800)}` : output;
+    throw new Error(`${path.basename(command)} failed: ${result.error?.message || diagnostic}`);
+  }
+  return result.stdout;
+}
+function verifyFile(root, file, expected) {
+  const absolute = safe(path.join(root, file));
+  assert.equal(hash(fs.readFileSync(absolute)), expected, `Fixed snapshot checksum differs: ${file}`);
+}
+function infoMatches(result, component) {
+  assert.equal(result.name, component.name, 'CLI query returned a different component');
+  for (const [field, source] of [['props', 'properties'], ['events', 'events'], ['slots', 'slots'], ['methods', 'methods']]) {
+    assert.deepEqual(result[field], component.props[source], `CLI query does not match fixed knowledge data: ${field}`);
+  }
+}
+function inspectOfficial(root, options = {}) {
+  const expected = options.expected || pinned.official;
+  if (!root || !fs.existsSync(root)) return { availability: 'missing', root, invocationVerified: false };
+  let cliVersion, relation;
+  try {
+    safe(root);
+    const pkg = json(path.join(root, 'package.json'));
+    assert.equal(pkg.name, expected.package, 'Unexpected official CLI package');
+    cliVersion = pkg.version; relation = versionRelation(cliVersion, expected.version);
+    assert.notEqual(relation, 'unknown', 'Cannot determine official CLI version');
+    if (relation === 'lower') return { availability: 'upgrade-required', root, cliVersion, versionRelation: relation, requiredVersion: expected.version, invocationVerified: false };
+    const receiptFile = path.join(root, '../UPSTREAM-ORIGIN.json');
+    const receipt = fs.existsSync(receiptFile) ? json(receiptFile) : null;
+    // Managed baseline snapshots retain their exact source/build checks. A
+    // customer's newer official CLI instead proves the fixed data and API.
+    if (relation === 'same' && (receipt || options.sourceFiles)) {
+      for (const [file, digest] of Object.entries(options.sourceFiles || sourceFiles)) verifyFile(root, file, digest);
+      verifyFile(root, 'data/versions.json', expected.versionIndexSha256);
+      assert.equal(receipt?.commit, expected.commit, 'Snapshot commit differs');
+      assert.equal(receipt?.archiveSha256, expected.archiveSha256, 'Source archive differs');
+      verifyFile(root, 'dist/index.mjs', receipt.distSha256);
+    }
+    verifyFile(root, expected.knowledgeFile, expected.knowledgeSha256);
+    const index = json(path.join(root, 'data/versions.json'));
+    assert.ok(Object.values(index.v1 || {}).includes(expected.knowledgeVersion), 'Requested knowledge version missing from index');
+    assert.ok(typeof pkg.bin?.antdv === 'string', 'CLI entry missing');
+    const entry = path.resolve(root, pkg.bin.antdv);
+    assert.ok(!path.relative(root, entry).startsWith('..') && !path.isAbsolute(path.relative(root, entry)), 'CLI entry escapes snapshot');
+    const data = json(path.join(root, expected.knowledgeFile));
+    const table = data.components.find(item => item.name === 'Table');
+    assert.ok(table, 'Fixed Table knowledge missing');
+    const result = JSON.parse(run(process.execPath, [entry, 'info', 'Table', '--ver', expected.knowledgeVersion, '--format', 'json'], root, options.env, 20000));
+    infoMatches(result, table);
+    return { availability: 'available', root, entry, cliVersion, versionRelation: relation, snapshot: relation === 'same' ? receipt?.commit || null : null,
+      knowledgeVersion: expected.knowledgeVersion, knowledgeSha256: expected.knowledgeSha256, exactKnowledgeMatch: true, invocationVerified: false };
+  } catch (error) { return { availability: 'unusable', root, cliVersion, versionRelation: relation, reason: error.message, invocationVerified: false }; }
+}
+function context(options) {
+  assert.ok(options.host, 'Specify the actual current --host; do not guess a host');
+  return resolveLocations(options);
+}
+function toolDirectory(location) { return path.join(path.dirname(location.toolsDirectory), 'i3-ui-demo', `antdv-${pinned.official.commit.slice(0, 12)}`); }
+function resolveOfficial(location, options = {}) {
+  if (options.tool) return inspectOfficial(path.resolve(options.tool), { env: options.env });
+  const bases = location.scope === 'global' ? [location.globalBase] : [location.projectToolsBase, location.globalBase];
+  const candidates = [path.join(toolDirectory(location), 'source')];
+  for (const base of bases.filter(Boolean)) {
+    const directory = path.join(base, 'tools/i3-ui-demo');
+    if (fs.existsSync(directory)) for (const name of fs.readdirSync(directory).sort()) {
+      if (name.startsWith('antdv-')) candidates.push(path.join(directory, name, 'source'));
+    }
+    // Read the old install's version; a required upgrade is prepared in the
+    // new owned directory without deleting the old tool or its user files.
+    candidates.push(path.join(base, 'tools/i3-prototype/antdv-cli/node_modules/@antdv-next/cli'));
+  }
+  candidates.push(path.join(location.project, 'node_modules/@antdv-next/cli'), path.resolve(path.dirname(process.execPath), '../lib/node_modules/@antdv-next/cli'));
+  const env = options.env || process.env;
+  for (const folder of (env.NODE_PATH || '').split(path.delimiter).filter(Boolean)) candidates.push(path.join(folder, '@antdv-next/cli'));
+  for (const folder of (env.PATH || '').split(path.delimiter).filter(Boolean)) {
+    const entry = path.join(folder, 'antdv');
+    if (!fs.existsSync(entry)) continue;
+    let directory = path.dirname(fs.realpathSync(entry));
+    for (let depth = 0; depth < 4; depth++, directory = path.dirname(directory)) {
+      const file = path.join(directory, 'package.json');
+      try { if (json(file).name === pinned.official.package) { candidates.push(directory); break; } } catch {}
+    }
+  }
+  const root = [...new Set(candidates)].find(candidate => fs.existsSync(candidate));
+  return inspectOfficial(root, { env: options.env });
+}
+function officialSkill(location, options, tool) {
+  const roots = options.officialSkill ? [path.resolve(options.officialSkill)] : (location.scope === 'global' ? [location.globalSkills] : [location.projectSkills, location.globalSkills]).filter(Boolean).map(base => path.join(base, 'antdv'));
+  const root = roots.find(item => fs.existsSync(path.join(item, 'SKILL.md')));
+  if (!root) return { availability: 'missing', searched: roots, invocationVerified: false };
+  try {
+    const digest = hash(fs.readFileSync(path.join(root, 'SKILL.md')));
+    const exact = digest === pinned.official.skillSha256;
+    const shipped = tool.availability === 'available' && path.join(tool.root, 'skills/antdv/SKILL.md');
+    assert.ok(exact || (shipped && fs.existsSync(shipped) && digest === hash(fs.readFileSync(shipped))), 'Installed antDv Skill differs from both the fixed and selected official CLI Skill');
+    assert.match(fs.readFileSync(path.join(root, 'SKILL.md'), 'utf8'), /^name:\s*["']?antdv["']?\s*$/m, 'Official Skill identity differs');
+    return { availability: 'available', root, contentMatchesSnapshot: exact, matchesSelectedCli: !exact, invocationVerified: false };
+  }
+  catch (error) { return { availability: 'unusable', root, reason: error.message, invocationVerified: false }; }
+}
+function check(options = {}) {
+  const location = context(options);
+  const nativeRoots = (location.scope === 'global' ? [location.globalSkills] : [location.projectSkills, location.globalSkills]).filter(Boolean).map(base => path.join(base, pinned.design.skill));
+  const native = !options.provider && !options.providerRoots && nativeRoots.find(root => fs.existsSync(path.join(root, 'SKILL.md')));
+  const design = checkDesignProvider({ ...options, ...(native ? { provider: native } : {}), project: location.scope === 'global' ? location.home : location.project, host: location.host });
+  if (native) design.source = native === path.join(location.projectSkills, pinned.design.skill) && location.scope === 'project' ? 'project-skill' : 'global-skill';
+  if (design.availability === 'needs-context' && !options.provider && !options.providerRoots) {
+    Object.assign(design, checkDesignProvider({ ...options, providerRoots: (location.scope === 'global' ? [location.globalSkills] : [location.projectSkills, location.globalSkills]).filter(Boolean).map(base => path.join(base, pinned.design.skill)) }));
+  }
+  if (design.availability === 'available') {
+    design.versionRelation = versionRelation(design.version, pinned.design.version);
+    if (['lower', 'unknown'].includes(design.versionRelation)) Object.assign(design, { availability: design.versionRelation === 'lower' ? 'upgrade-required' : 'unusable', reason: `Required ui-ux-pro-max >= ${pinned.design.version}; found ${design.version}` });
+    else if (design.versionRelation === 'higher') {
+      try {
+        for (const mode of [{ designSystem: true }, { stack: 'vue' }]) {
+          const result = queryProvider(design.root, mode.stack ? 'ref reactive' : 'enterprise dashboard accessible forms', { ...mode, python: options.python });
+          assert.ok(result && !result.error && !result.errors, 'Higher UI/UX Pro Max version is not compatible');
+          if (mode.designSystem) assert.ok(result.design_system?.style && result.design_system.colors && result.design_system.typography, 'Higher UI/UX Pro Max design-system result is incompatible');
+          else assert.ok(result.domain === 'stack' && result.stack === 'vue' && result.results?.length, 'Higher UI/UX Pro Max Vue query has no usable results');
+        }
+      } catch (error) { Object.assign(design, { availability: 'unusable', reason: error.message }); }
+    }
+  }
+  const tool = resolveOfficial(location, options);
+  const official = officialSkill(location, options, tool);
+  const ready = [design, official, tool].every(item => item.availability === 'available');
+  const notices = [[pinned.design.skill, design, pinned.design.version, design.version], ['@antdv-next/cli', tool, pinned.official.version, tool.cliVersion]]
+    .filter(([, item]) => ['lower', 'higher'].includes(item.versionRelation)).map(([name, item, required, actual]) =>
+      `${name} ${actual} ${item.versionRelation === 'higher' ? `高于约定版本 ${required}，保留现有版本${item.availability === 'available' ? '，兼容性检查通过' : '；兼容性检查未通过'}` : `低于约定版本 ${required}，本次安装将升级至 ${required}`}。`);
+  return { status: ready ? 'ready' : 'needs-dependencies', ready, location, design, official, tool, notices, invocationVerified: false,
+    note: 'Dependency preparation only. Explicitly load the required Skills, implement the business scope and obtain current-browser evidence separately.' };
+}
+function query(options) {
+  const location = context(options), tool = resolveOfficial(location, options), root = tool.root;
+  assert.equal(tool.availability, 'available', tool.reason || 'Fixed official snapshot is not prepared');
+  assert.ok(['info', 'demo', 'doc', 'token', 'semantic', 'list', 'design.md'].includes(options.kind), 'Only read-only official queries are supported');
+  const args = [tool.entry, options.kind];
+  if (!['list', 'design.md'].includes(options.kind)) {
+    assert.match(options.component || '', /^[A-Za-z][A-Za-z0-9]*$/, 'Supply a component name');
+    args.push(options.component);
+  }
+  if (options.kind === 'demo') { assert.match(options.demo || '', /^[\w-]+$/, 'Supply a demo name'); args.push(options.demo); }
+  args.push('--ver', pinned.official.knowledgeVersion, '--format', 'json');
+  const data = JSON.parse(run(process.execPath, args, root, options.env, 20000));
+  assert.ok(data && !data.error && !data.errors, 'Official query returned an error');
+  if (options.kind === 'info') {
+    const component = json(path.join(root, pinned.official.knowledgeFile)).components.find(item => item.name === options.component);
+    assert.ok(component, 'Component missing from fixed data'); infoMatches(data, component);
+  }
+  return { status: 'queried', snapshot: tool.snapshot, cliVersion: tool.cliVersion, knowledgeVersion: pinned.official.knowledgeVersion, componentVersion: pinned.component.version, data, invocationVerified: false };
+}
+function npmEntry() {
+  const candidates = [process.env.npm_execpath, path.join(path.dirname(process.execPath), '../lib/node_modules/npm/bin/npm-cli.js')];
+  for (const folder of (process.env.PATH || '').split(path.delimiter)) {
+    const entry = path.join(folder, process.platform === 'win32' ? 'npm.cmd' : 'npm');
+    if (fs.existsSync(entry)) { const real = fs.realpathSync(entry); if (real.endsWith('npm-cli.js')) candidates.push(real); }
+  }
+  const result = candidates.find(file => file && file.endsWith('npm-cli.js') && fs.existsSync(file));
+  assert.ok(result, 'A standard Node.js/npm installation is required'); return result;
+}
+function supportsBuild(version) {
+  const parts = typeof version === 'string' && version.match(/^v?(\d+)\.(\d+)\.(\d+)$/);
+  if (!parts) return false;
+  const major = Number(parts[1]), minor = Number(parts[2]);
+  return major === 22 && minor >= 18 || major === 24 && minor >= 11 || major > 24;
+}
+function buildRuntime(env = process.env) {
+  if (supportsBuild(process.version)) return { entry: process.execPath, version: process.version };
+  const binary = process.platform === 'win32' ? 'node.exe' : 'node';
+  const candidates = (env.PATH || '').split(path.delimiter).filter(Boolean).map(folder => path.resolve(folder, binary));
+  for (const entry of [...new Set(candidates)]) {
+    if (entry === process.execPath || !fs.existsSync(entry)) continue;
+    const probe = spawnSync(entry, ['--version'], { encoding: 'utf8', timeout: 5000, maxBuffer: 65536, shell: false });
+    if (!probe.error && probe.status === 0 && supportsBuild(probe.stdout.trim())) return { entry, version: probe.stdout.trim() };
+  }
+  throw new Error('准备固定 antDv CLI 快照需要 Node.js 22.18.x 或 24.11+ 构建环境；请将本机兼容的 node 加入 PATH 后重试。已准备好的 CLI 可继续复用。');
+}
+async function prepareSnapshot(directory, options = {}) {
+  const runtime = buildRuntime(options.env || process.env);
+  const archive = options.archive ? fs.readFileSync(path.resolve(options.archive)) : Buffer.from(await (async () => {
+    const response = await fetch(pinned.official.archive, { signal: AbortSignal.timeout(60000) });
+    assert.ok(response.ok, `Official source download failed: ${response.status}`); return response.arrayBuffer();
+  })());
+  assert.equal(hash(archive), pinned.official.archiveSha256, 'Official source archive checksum differs');
+  fs.mkdirSync(directory, { recursive: false });
+  const file = path.join(directory, 'source.tgz'); fs.writeFileSync(file, archive);
+  const names = run('tar', ['-tzf', file], directory).split('\n').filter(Boolean);
+  const prefix = `cli-${pinned.official.commit}/`;
+  assert.ok(names.every(name => name === prefix.slice(0, -1) || (name.startsWith(prefix) && !name.split('/').includes('..'))), 'Official archive paths differ');
+  const unpacked = path.join(directory, 'unpacked'); fs.mkdirSync(unpacked);
+  run('tar', ['-xzf', file, '-C', unpacked], directory);
+  const root = path.join(directory, 'source'); fs.renameSync(path.join(unpacked, prefix.slice(0, -1)), root); fs.rmdirSync(unpacked);
+  for (const [relative, digest] of Object.entries(sourceFiles)) verifyFile(root, relative, digest);
+  const builder = path.join(resources.root, 'assets/antdv-build');
+  for (const name of ['package.json', 'package-lock.json']) fs.copyFileSync(path.join(builder, name), path.join(directory, name));
+  const cache = options.cache || path.join(path.dirname(directory), 'npm-cache');
+  run(runtime.entry, [npmEntry(), 'ci', '--ignore-scripts', '--no-audit', '--no-fund', '--cache', cache], directory, options.env);
+  const buildPackage = json(path.join(directory, 'node_modules/tsdown/package.json'));
+  const buildBin = typeof buildPackage.bin === 'string' ? buildPackage.bin : buildPackage.bin.tsdown;
+  run(runtime.entry, [path.join(directory, 'node_modules/tsdown', buildBin), '--config', path.join(root, 'tsdown.config.ts')], root, options.env);
+  const receipt = { commit: pinned.official.commit, archiveSha256: pinned.official.archiveSha256,
+    distSha256: hash(fs.readFileSync(path.join(root, 'dist/index.mjs'))), buildLockSha256: hash(fs.readFileSync(path.join(directory, 'package-lock.json'))),
+    source: pinned.official.archive, installer: 'i3-ui-demo fixed official snapshot preparation', buildNodeVersion: runtime.version, preparedAt: new Date().toISOString() };
+  fs.writeFileSync(path.join(directory, 'UPSTREAM-ORIGIN.json'), JSON.stringify(receipt, null, 2) + '\n');
+  const inspected = inspectOfficial(root, { env: options.env }); assert.equal(inspected.availability, 'available', inspected.reason);
+  return root;
+}
+function parameterizeDesign(root, location, destination) {
+  const receiptFile = path.join(root, 'UPSTREAM-ORIGIN.json'), receipt = json(receiptFile);
+  const previous = receipt.pathParameters;
+  assert.ok(previous?.command, 'Official design path parameters are missing');
+  const entry = path.join(destination, 'scripts/search.py');
+  const script = (location.scope === 'global' ? entry : path.relative(location.project, entry)).split(path.sep).join('/');
+  const command = /^[a-zA-Z0-9_./:-]+$/.test(script) ? script : process.platform === 'win32'
+    ? "'" + script.replaceAll("'", "''") + "'" : "'" + script.replaceAll("'", "'\\''") + "'";
+  const file = path.join(root, 'SKILL.md'), content = fs.readFileSync(file, 'utf8');
+  assert.ok(content.includes(previous.command), 'Official design script placeholder was not found');
+  fs.writeFileSync(file, content.split(previous.command).join(command));
+  receipt.pathParameters = { ...previous, script, command };
+  fs.writeFileSync(receiptFile, JSON.stringify(receipt, null, 2) + '\n');
+}
+async function prepareDesign(location, options = {}) {
+  const destination = safe(path.join(location.skillsDirectory, pinned.design.skill));
+  const upgrade = options.upgrade?.availability === 'upgrade-required' && path.resolve(options.upgrade.root) === destination;
+  assert.ok(!fs.existsSync(destination) || upgrade, `Existing design Skill preserved: ${destination}`);
+  const fingerprint = root => {
+    const items = [];
+    function visit(folder) {
+      for (const entry of fs.readdirSync(folder, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name))) {
+        const file = safe(path.join(folder, entry.name)), stat = fs.lstatSync(file);
+        assert.ok(entry.isFile() || entry.isDirectory(), 'Existing design Skill contains unsupported files; preserved');
+        items.push([path.relative(root, file), stat.mode, entry.isFile() ? hash(fs.readFileSync(file)) : 'directory']);
+        if (entry.isDirectory()) visit(file);
+      }
+    }
+    visit(root); return hash(JSON.stringify(items));
+  };
+  const previous = upgrade ? fingerprint(destination) : null;
+  const base = safe(path.dirname(toolDirectory(location))); fs.mkdirSync(base, { recursive: true });
+  const stage = fs.mkdtempSync(path.join(base, '.ui-demo-design-'));
+  try {
+    const project = path.join(stage, 'project'), home = path.join(stage, 'home');
+    fs.mkdirSync(project); fs.mkdirSync(home);
+    // Prepare the fixed official CLI in an empty scope. Existing providers
+    // cannot make it skip the requested project installation.
+    const isolated = { project, home, host: location.host, scope: 'project', env: {}, skills: 'uiux' };
+    const installed = context(isolated);
+    const prepared = await require('./design-install.cjs').prepare(path.join(stage, 'official'), { ...installed, destination: path.join(installed.skillsDirectory, pinned.design.skill) });
+    const root = prepared.skill;
+    const probe = checkDesignProvider({ ...isolated, provider: root, python: options.python });
+    assert.equal(probe.availability, 'available', probe.reason);
+    assert.equal(probe.version, pinned.design.version, 'Prepared design version differs');
+    parameterizeDesign(root, location, destination);
+    safe(destination);
+    let backup;
+    if (upgrade) {
+      assert.equal(fingerprint(destination), previous, 'Design Skill changed during preparation; preserved');
+      const backups = safe(path.join(base, 'backups')); fs.mkdirSync(backups, { recursive: true });
+      backup = path.join(backups, `ui-ux-pro-max-${options.upgrade.version}-${crypto.randomBytes(8).toString('hex')}`);
+      fs.renameSync(destination, backup);
+    } else assert.ok(!fs.existsSync(destination), 'Design destination appeared during preparation; preserved');
+    try { fs.mkdirSync(path.dirname(destination), { recursive: true }); fs.renameSync(root, destination); }
+    catch (error) { if (backup && !fs.existsSync(destination)) fs.renameSync(backup, destination); throw error; }
+    return { root: destination, backup };
+  } finally { fs.rmSync(stage, { recursive: true, force: true }); }
+}
+async function prepare(options = {}) {
+  if (options.decision === 'decline') return { status: 'declined', continue: false, wrote: false };
+  const before = check(options);
+  if (before.ready) return { status: 'reused', continue: true, detection: before };
+  if (options.accept !== true) return { status: 'needs-confirmation', continue: false, wrote: false, detection: before };
+  assertPreparable(before, options);
+  assert.ok(!options.tool && !options.officialSkill, 'Explicit existing paths are read-only; select a clean install scope to prepare tools');
+  assert.ok(!options.provider || before.design.availability === 'available', 'Explicit design provider is unusable; correct its path or select a clean install scope without --provider');
+  const location = before.location, destination = safe(toolDirectory(location));
+  const skillDestination = safe(path.join(location.skillsDirectory, 'antdv'));
+  if (before.official.availability === 'unusable') throw new Error('Existing official Skill preserved; select a clean scope or repair it explicitly');
+  if (fs.existsSync(destination) && before.tool.availability !== 'available') throw new Error(`Existing tool preserved: ${destination}`);
+  let stage, designPreparation;
+  try {
+    if (before.tool.availability !== 'available') {
+      const base = path.dirname(destination); safe(base); fs.mkdirSync(base, { recursive: true });
+      stage = path.join(base, '.ui-demo-stage-' + crypto.randomBytes(8).toString('hex'));
+      const root = await prepareSnapshot(stage, options);
+      if (fs.existsSync(destination)) throw new Error('Tool destination appeared during preparation; preserved');
+      if (before.official.availability !== 'available' && fs.existsSync(skillDestination)) throw new Error('Skill destination appeared during preparation; preserved');
+      if (before.official.availability !== 'available') {
+        fs.mkdirSync(path.dirname(skillDestination), { recursive: true });
+        fs.cpSync(path.join(root, 'skills/antdv'), skillDestination, { recursive: true, errorOnExist: true, force: false });
+        fs.copyFileSync(path.join(root, 'LICENSE'), path.join(skillDestination, 'LICENSE'));
+      }
+      fs.renameSync(stage, destination); stage = null;
+    } else if (before.official.availability !== 'available') {
+      fs.mkdirSync(path.dirname(skillDestination), { recursive: true });
+      fs.cpSync(path.join(before.tool.root, 'skills/antdv'), skillDestination, { recursive: true, errorOnExist: true, force: false });
+      fs.copyFileSync(path.join(before.tool.root, 'LICENSE'), path.join(skillDestination, 'LICENSE'));
+    }
+    if (before.design.availability !== 'available') {
+      designPreparation = await prepareDesign(location, { ...options, upgrade: before.design });
+    }
+    const detection = check(options);
+    assert.ok(detection.ready, 'Required combination is still incomplete; preserve successful preparation and report the remaining gap');
+    return { status: 'prepared', continue: true, detection, ...(designPreparation?.backup ? { backups: [designPreparation.backup] } : {}), note: 'Reload the selected host when needed. Preparation does not prove actual Skill invocation or browser execution.' };
+  } finally { if (stage && fs.existsSync(stage)) fs.rmSync(stage, { recursive: true, force: true }); }
+}
+function assertPreparable(detection, options = {}) {
+  for (const [name, item] of [['ui-ux-pro-max', detection.design], ['antdv', detection.official], ['@antdv-next/cli', detection.tool]]) {
+    assert.ok(['available', 'missing', 'upgrade-required'].includes(item.availability), `${name} 检查未通过，已保留现有安装：${item.reason || item.availability}`);
+  }
+  if (['missing', 'upgrade-required'].includes(detection.tool.availability)) buildRuntime(options.env || process.env);
+}
+function parse(argv) {
+  const operation = argv.shift() || 'check', options = {};
+  assert.ok(['check', 'prepare', 'query'].includes(operation), 'Use check, prepare or query');
+  const flags = ['project', 'host', 'scope', 'home', 'provider', 'python', 'tool', 'official-skill', 'kind', 'component', 'demo', 'decision', 'archive', 'cache'];
+  while (argv.length) {
+    const flag = argv.shift();
+    if (flag === '--accept') { options.accept = true; continue; }
+    assert.ok(flag.startsWith('--') && flags.includes(flag.slice(2)) && argv.length, `Invalid option: ${flag}`);
+    const key = flag.slice(2).replace(/-([a-z])/g, (_, letter) => letter.toUpperCase()); options[key] = argv.shift();
+  }
+  return { operation, options };
+}
+module.exports = { versionRelation, inspectOfficial, resolveOfficial, assertPreparable, infoMatches, check, query, prepare, prepareDesign, parameterizeDesign, prepareSnapshot, supportsBuild, buildRuntime, context, toolDirectory };
+if (require.main === module) {
+  Promise.resolve().then(() => { const { operation, options } = parse(process.argv.slice(2)); return operation === 'prepare' ? prepare(options) : operation === 'query' ? query(options) : check(options); })
+    .then(result => { process.stdout.write(JSON.stringify(result, null, 2) + '\n'); })
+    .catch(error => { process.stderr.write(JSON.stringify({ status: 'failed', errors: [error.message] }) + '\n'); process.exitCode = 1; });
+}

package/skills/i3-ui-demo/scripts/design-install.cjs

@@ -0,0 +1,105 @@
+'use strict';
+const fs = require('node:fs');
+const path = require('node:path');
+const crypto = require('node:crypto');
+const { spawn } = require('node:child_process');
+const source = require('../assets/design-source.json');
+const required = require('../assets/versions.json').design;
+if (source.version !== required.version || source.skillName !== required.skill) throw new Error('Fixed UI/UX Pro Max source differs from the required version');
+
+function verify(data, expected, algorithm = 'sha256', encoding = 'hex') {
+  if (crypto.createHash(algorithm).update(data).digest(encoding) !== expected) throw new Error('Official download integrity mismatch');
+  return data;
+}
+async function download(url, expected, algorithm, encoding) {
+  const response = await fetch(url, { signal: AbortSignal.timeout(60000) });
+  if (!response.ok) throw new Error(`Official download failed: HTTP ${response.status}`);
+  const data = Buffer.from(await response.arrayBuffer());
+  if (data.length > 50 * 1024 * 1024) throw new Error('Official download exceeds size limit');
+  return verify(data, expected, algorithm, encoding);
+}
+function npmEntry() {
+  const directory = path.dirname(process.execPath);
+  const candidates = [process.env.npm_execpath, path.join(directory, '../lib/node_modules/npm/bin/npm-cli.js'), path.join(directory, 'node_modules/npm/bin/npm-cli.js')];
+  for (const folder of (process.env.PATH || '').split(path.delimiter)) {
+    const entry = path.join(folder, 'npm');
+    if (fs.existsSync(entry)) candidates.push(fs.realpathSync(entry));
+  }
+  const found = candidates.find(file => file && path.basename(file) === 'npm-cli.js' && fs.existsSync(file));
+  if (!found) throw new Error('Cannot locate npm-cli.js; use a standard Node.js/npm installation');
+  return found;
+}
+function run(entry, args, cwd, env) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [entry, ...args], { cwd, env, stdio: ['ignore', 'pipe', 'pipe'] });
+    let output = '', failed = false;
+    const timer = setTimeout(() => { failed = true; child.kill(); reject(new Error('Official installer timed out')); }, 180000);
+    for (const stream of [child.stdout, child.stderr]) stream.on('data', chunk => {
+      output += chunk;
+      if (output.length > 5 * 1024 * 1024) { failed = true; child.kill(); reject(new Error('Official installer output exceeds limit')); }
+    });
+    child.once('error', error => { clearTimeout(timer); failed = true; reject(error); });
+    child.once('close', code => { clearTimeout(timer); if (!failed) code === 0 ? resolve() : reject(new Error(`Official installer failed (${code}): ${output.slice(-1500)}`)); });
+  });
+}
+function validateSkill(folder, name) {
+  const entry = fs.readFileSync(path.join(folder, 'SKILL.md'), 'utf8');
+  if (!new RegExp(`^name:\\s*["']?${name}["']?\\s*$`, 'm').test(entry)) throw new Error(`Official Skill identity mismatch: ${name}`);
+  function visit(directory) {
+    for (const item of fs.readdirSync(directory, { withFileTypes: true })) {
+      if (item.isSymbolicLink()) throw new Error('Official Skill contains a symbolic link');
+      if (item.isDirectory()) visit(path.join(directory, item.name));
+      else if (!item.isFile()) throw new Error('Official Skill contains an unsupported file');
+    }
+  }
+  visit(folder);
+  if (name === 'ui-ux-pro-max') for (const file of ['scripts/search.py', 'scripts/core.py', 'scripts/design_system.py', 'data/ux-guidelines.csv']) {
+    if (!fs.existsSync(path.join(folder, file))) throw new Error(`Incomplete UIUX resources: ${file}`);
+  }
+}
+function uiuxPaths(packageRoot, skill, context, platform) {
+  const templates = path.join(packageRoot, 'assets/templates');
+  const config = JSON.parse(fs.readFileSync(path.join(templates, 'platforms', `${platform}.json`), 'utf8'));
+  const template = fs.readFileSync(path.join(templates, 'base/skill-content.md'), 'utf8');
+  const scriptFile = path.join(context.destination, 'scripts/search.py');
+  const script = (context.scope === 'global' ? scriptFile : path.relative(context.project, scriptFile)).split(path.sep).join('/');
+  const command = /^[a-zA-Z0-9_./:-]+$/.test(script) ? script : process.platform === 'win32' ? "'" + script.replaceAll("'", "''") + "'" : "'" + script.replaceAll("'", "'\\''") + "'";
+  const parameters = { TITLE: config.title, DESCRIPTION: config.description, SCRIPT_PATH: command, SKILL_OR_WORKFLOW: config.skillOrWorkflow,
+    QUICK_REFERENCE: config.sections.quickReference ? '\n' + fs.readFileSync(path.join(templates, 'base/quick-reference.md'), 'utf8') : '' };
+  const file = path.join(skill, 'SKILL.md'), original = fs.readFileSync(file, 'utf8');
+  const header = original.match(/^---\r?\n[\s\S]*?\r?\n---\r?\n/)?.[0];
+  if (!header) throw new Error('Official UIUX frontmatter is missing');
+  // Only official template placeholders are parameterized. The downloaded
+  // template and CLI code remain unchanged; paths work in every supported host.
+  const body = template.replace(/\{\{([A-Z_]+)\}\}/g, (match, key) => {
+    if (!Object.hasOwn(parameters, key)) throw new Error(`Unknown official UIUX placeholder: ${key}`);
+    return parameters[key];
+  });
+  fs.writeFileSync(file, header + body);
+  return { platform, script, command, templateSha256: crypto.createHash('sha256').update(template).digest('hex') };
+}
+async function prepare(stage, context) {
+  const tool = path.join(stage, 'tool'), workspace = path.join(stage, 'workspace');
+  fs.mkdirSync(tool, { recursive: true }); fs.mkdirSync(workspace);
+  const archive = await download(source.tarball, source.integrity.slice(7), 'sha512', 'base64');
+  fs.writeFileSync(path.join(tool, 'source.tgz'), archive);
+  const env = { ...process.env, npm_config_cache: path.join(stage, 'npm-cache'), npm_config_offline: 'false', NPM_CONFIG_OFFLINE: 'false', npm_config_update_notifier: 'false', ANTDV_NO_AUTO_REPORT: '1' };
+  await run(npmEntry(), ['install', '--ignore-scripts', '--no-audit', '--no-fund', '--package-lock', './source.tgz'], tool, env);
+  const packageRoot = path.join(tool, 'node_modules', source.packageName), pkg = JSON.parse(fs.readFileSync(path.join(packageRoot, 'package.json'), 'utf8'));
+  if (pkg.name !== source.packageName || pkg.version !== source.version) throw new Error('Official CLI version mismatch');
+  let skill, pathParameters;
+  {
+    const platform = ['codebuddy', 'workbuddy'].includes(context.host) ? 'codebuddy' : context.host === 'codex' ? 'codex' : context.host === 'claude-code' ? 'claude' : 'universal';
+    await run(path.join(packageRoot, pkg.bin.uipro), ['init', '--ai', platform, '--offline'], workspace, env);
+    const config = JSON.parse(fs.readFileSync(path.join(packageRoot, 'assets/templates/platforms', `${platform}.json`), 'utf8'));
+    skill = path.join(workspace, config.folderStructure.root, config.folderStructure.skillPath);
+    pathParameters = uiuxPaths(packageRoot, skill, context, platform);
+  }
+  fs.writeFileSync(path.join(skill, 'LICENSE'), await download(source.licenseUrl, source.licenseSha256));
+  const receipt = JSON.stringify({ ...source, installedAt: new Date().toISOString(), installer: 'i3 required UI Demo dependency preparation; official templates retained',
+    ...(pathParameters ? { pathParameters } : {}) }, null, 2) + '\n';
+  fs.writeFileSync(path.join(skill, 'UPSTREAM-ORIGIN.json'), receipt);
+  validateSkill(skill, source.skillName);
+  return { skill, tool };
+}
+module.exports = { prepare, validateSkill };