create-yss-spec 2.2.8 → 2.2.10

package/template/docs/user-guide//347/224/250/346/210/267/346/211/213/345/206/214/347/264/242/345/274/225.md

@@ -0,0 +1,21 @@
+# 用户手册索引
+
+这里集中放置 YSS 模板和生命周期的入门手册。第一次使用时，先看总览，再进入与你当前工作阶段对应的子项目手册。
+
+## 推荐阅读顺序
+
+1. [YSS 用户手册](./用户手册.md)：了解仓库身份、生命周期主链和 Agent 使用模式。
+2. [战略设计子项目用户手册](../../submodules/yss-strategic-design-harness/docs/user-guide/战略设计子项目用户手册.md)：从模糊想法形成 Strategic Design Handoff。
+3. [战术设计子项目用户手册](./战术设计子项目用户手册.md)：把交接包细化为 Tactical Design，供研发实现和评审。
+
+## 按任务查找
+
+| 你现在要做什么 | 推荐手册 |
+|---|---|
+| 创建、接管或更新 YSS 项目 | [YSS 用户手册](./用户手册.md) |
+| 澄清需求、确定用户和范围 | [战略设计子项目用户手册](../../submodules/yss-strategic-design-harness/docs/user-guide/战略设计子项目用户手册.md) |
+| 设计聚合、状态、不变量和领域事件 | [战术设计子项目用户手册](./战术设计子项目用户手册.md) |
+| 了解完整生命周期和阶段门禁 | [产品生命周期工作流](../../submodules/yss-strategic-design-harness/docs/user-guide/产品生命周期工作流.md) |
+| 查找长期协作习惯和反模式 | [生命周期最佳实践](../../submodules/yss-strategic-design-harness/docs/user-guide/生命周期最佳实践.md) |
+
+> 本仓库是 `template-source`。手册中的业务名称和示例只用于教学；真实产品资料应在 `project-instance` 中建立，并遵守对应的生命周期门禁。

package/template/scripts/lib/digital-human-roles.mjs

@@ -12,7 +12,6 @@ const RUNTIME_ID = /^runtime\.[a-z0-9][a-z0-9-]*$/;
 const REQUIRED_ROLES = [
   "role.requirements-manager",
   "role.product-manager",
-  "role.business",
   "role.project-manager",
   "role.frontend-engineer",
   "role.backend-engineer",

package/template/scripts/lib/scenario-checks.mjs

@@ -46,7 +46,7 @@ function validateInvocationBoundary(data) {
   ensure(JSON.stringify(boundary?.lifecycle_managed_user_entries) === JSON.stringify(["setup-matt-pocock-skills", "grill-with-docs", "to-spec", "to-tickets", "implement"]), "生命周期管理的显式用户入口清单不完整");
   ensure(boundary?.lifecycle_may_invoke_user_invoked === false && boundary?.formal_artifact_owner === "explicit-user-entry", "生命周期仍可能自动调用 user-invoked skill 或产出其正式资产");
   ensure(JSON.stringify(boundary?.model_invoked_skills) === JSON.stringify(expectedModelInvoked) && JSON.stringify(boundary?.lifecycle_allowed_model_invoked_skills) === JSON.stringify(expectedLifecycleModelInvoked) && boundary?.continuous_orchestration === "compatibility-prepare-and-validate-only", "Matt invocation inventory 或生命周期 model-invoked 白名单不完整");
-  ensure(JSON.stringify(data.skill_source_contract?.source_revisions_required) === JSON.stringify(["mattpocock/skills"]) && data.skill_source_contract?.adaptation_ref_required_when_effective_diff === true && data.skill_source_contract?.retired_shared_skills?.includes("batch-grill-me"), "上游来源或退役 skill 供应链契约不完整");
+  ensure(JSON.stringify(data.skill_source_contract?.source_revisions_required) === JSON.stringify(["mattpocock/skills", "iloveZzz/yss-ui"]) && data.skill_source_contract?.adaptation_ref_required_when_effective_diff === true && data.skill_source_contract?.retired_shared_skills?.includes("batch-grill-me"), "上游来源或退役 skill 供应链契约不完整");
   validateInvocationMetadata(boundary, (skill) => read(`.agents/skills/${skill}/SKILL.md`));
   const setup = data.setup_readiness;
   ensure(setup?.missing_action === "needs-human" && setup?.requested_skill === "setup-matt-pocock-skills" && setup?.resume_route === "setup-readiness" && setup?.preserves?.includes("lifecycle.status"), "readiness=missing 未形成显式用户 setup 的结构化暂停");
@@ -60,9 +60,9 @@ function validateInvocationBoundary(data) {
   const routes = data.work_unit_routes;
   ensure(routes?.["work-unit.discovery-requirements"]?.skills?.includes("grilling") && routes?.["work-unit.discovery-requirements"]?.skills?.includes("domain-modeling"), "需求分析工作单元缺少 grilling/domain-modeling");
   ensure(routes?.["work-unit.discovery-opportunity"]?.route_by?.market_or_competitor_fact === "competitive-intelligence" && routes["work-unit.discovery-opportunity"].route_by.technical_or_standard_fact === "research", "机会调研事实路由不准确");
-  ensure(routes?.["work-unit.slice-implementation"]?.skills?.includes("tdd") && routes?.["work-unit.slice-implementation"]?.skills?.includes("yss-ui"), "原生实现工作单元缺少 TDD 或 UI 路由");
+  ensure(routes?.["work-unit.slice-implementation"]?.skills?.includes("tdd") && routes?.["work-unit.slice-implementation"]?.skills?.includes("yss-ui") && routes?.["work-unit.slice-implementation"]?.skills?.includes("yss-ui-business-page-generation"), "原生实现工作单元缺少 TDD、UI 或业务页面生成路由");
   const frontendRoute = routes?.["work-unit.slice-implementation"]?.frontend_route;
-  ensure(frontendRoute?.primary_skill === "yss-ui" && frontendRoute?.page_orchestration_skill === "yss-page-module-development", "前端实现路由缺少 yss-ui 主入口或页面编排技能");
+  ensure(frontendRoute?.primary_skill === "yss-ui" && frontendRoute?.page_generation_skill === "yss-ui-business-page-generation" && frontendRoute?.page_orchestration_skill === "yss-page-module-development", "前端实现路由缺少 yss-ui 主入口、业务页面生成或页面编排技能");
   for (const impact of ["api_impact", "formily_impact", "table_impact", "tree_impact", "height_impact", "export_impact", "theme_impact"]) {
     ensure(Array.isArray(frontendRoute?.conditional_skills?.[impact]) && frontendRoute.conditional_skills[impact].length > 0 && typeof frontendRoute.not_applicable_reasons?.[impact] === "string", `前端条件专项路由缺少 ${impact}`);
   }

package/template/scripts/lib/skill-governance.mjs

@@ -2,6 +2,7 @@ import { existsSync, readFileSync } from "node:fs";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 import { loadSkillRegistry } from "./skill-registry.mjs";
+import { validateYssUiSkillManifest } from "./skill-supply-chain.mjs";
 
 export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 
@@ -27,10 +28,43 @@ export function validateSkillGovernance({ read = (relative) => readFileSync(path
     fail("页面模块 canonical 技能缺少条件化 toolbar-config 规则");
   }
 
+  const yssUiManifest = validateYssUiSkillManifest(JSON.parse(read(".agents/skills/.yss-skills-manifest.json")));
+  const lock = JSON.parse(read("skills-lock.json"));
+  for (const skill of yssUiManifest.skills) {
+    const skillPath = `.agents/skills/${skill.canonical}/SKILL.md`;
+    if (!exists(skillPath)) fail(`yss-ui 前端清单缺少 canonical skill: ${skill.canonical}`);
+    const item = lock.skills?.shared?.[skill.canonical];
+    if (!item || item.source !== yssUiManifest.source || item.sourceRevision !== yssUiManifest.source_revision) {
+      fail(`yss-ui skill 缺少一致的来源锁定: ${skill.canonical}`);
+    }
+    if (item.skillPath !== `${yssUiManifest.source_root}/${skill.upstream}/SKILL.md` || item.upstreamHash !== skill.upstream_hash) {
+      fail(`yss-ui skill 上游路径或 hash 不一致: ${skill.canonical}`);
+    }
+    const content = read(skillPath);
+    for (const match of content.matchAll(/\.\.\/([a-z0-9-]+)\/SKILL\.md/g)) {
+      if (!exists(`.agents/skills/${match[1]}/SKILL.md`)) fail(`${skill.canonical} 引用了不存在的本地 skill: ${match[1]}`);
+    }
+  }
+  const yssUiSkill = read(".agents/skills/yss-ui/SKILL.md");
+  if (!yssUiSkill.includes("`YFormily` 是新代码 canonical name")) fail("yss-ui 必须把 YFormily 声明为新代码 canonical name");
+  if (!yssUiSkill.includes("| 新建或改造完整业务页面 | `yss-ui-business-page-generation` |")) fail("yss-ui 缺少完整业务页面生成路由");
+  const expectedServer = { command: "npx", args: ["-y", "@yss-ui/mcp"] };
+  for (const config of yssUiManifest.mcp.project_configs) {
+    if (!exists(config.path)) fail(`缺少 yss-ui MCP 项目配置: ${config.path}`);
+    const document = JSON.parse(read(config.path));
+    if (JSON.stringify(document?.[config.container]?.[yssUiManifest.mcp.server_name]) !== JSON.stringify(expectedServer)) {
+      fail(`yss-ui MCP 配置不一致: ${config.path}`);
+    }
+  }
+  const mcpGuide = read(yssUiManifest.mcp.global_install_guide);
+  for (const marker of ["npx -y @yss-ui/mcp install codex", "不写用户主目录", "get_codegen_rules", "list_components"]) {
+    if (!mcpGuide.includes(marker)) fail(`YSS UI MCP 指南缺少边界或自检标记: ${marker}`);
+  }
+
   const registry = loadSkillRegistry();
   const canonicalIds = new Set(registry.skills.map((skill) => skill.id));
   const aliases = new Map(registry.skills.flatMap((skill) => skill.aliases.map((alias) => [alias, skill.id])));
-  const legacy = new Set(["api-integration", "page-module-development", "use-table-height", "use-tree-height", "yss-ui-business-page-generation"]);
+  const legacy = new Set(["api-integration", "page-module-development", "use-table-height", "use-tree-height"]);
   for (const alias of legacy) {
     if (exists(`.agents/skills/${alias}`)) fail(`legacy alias 不得存在独立 canonical 目录: ${alias}`);
     if (!aliases.has(alias)) fail(`legacy alias 未登记: ${alias}`);
@@ -65,5 +99,5 @@ export function validateSkillGovernance({ read = (relative) => readFileSync(path
       }
     }
   }
-  return { checked: true, legacy_aliases: legacy.size };
+  return { checked: true, legacy_aliases: legacy.size, yss_ui_skills: yssUiManifest.skills.length };
 }

package/template/scripts/lib/skill-registry.mjs

@@ -9,6 +9,7 @@ const ROUTER_CONTRACT = path.join(ROOT, ".agents/skills/yss-router/references/ro
 const LIFECYCLE_CONTRACT = path.join(ROOT, ".agents/skills/yss-product-lifecycle/references/orchestration-contract.yaml");
 const LAYERS = new Set(["core", "specialist", "compatibility", "maintainer-only"]);
 const MATURITIES = new Set(["draft", "verified", "supported", "deprecated"]);
+const INVOCATION_MODES = new Set(["user", "model", "both"]);
 const ID_PATTERN = /^[a-z0-9][a-z0-9-]*$/;
 const PLATFORM_ALIAS_PATTERN = /^[a-z0-9][a-z0-9-]*(?::[a-z0-9][a-z0-9-]*)?$/;
 
@@ -51,6 +52,74 @@ function requireObject(value, field) {
   if (!value || typeof value !== "object" || Array.isArray(value)) fail(`${field} 必须是对象`);
 }
 
+function requireStringArray(value, field, { nonEmpty = false } = {}) {
+  if (!Array.isArray(value) || (nonEmpty && value.length === 0) || value.some((item) => typeof item !== "string" || !item.trim())) {
+    fail(`${field} 必须是${nonEmpty ? "非空" : ""}字符串数组`);
+  }
+}
+
+function validateInvocationContract(registry, skill) {
+  const contract = registry.invocation_contract;
+  requireObject(contract, "invocation_contract");
+  if (contract.schema_version !== 1) fail("invocation_contract.schema_version 必须为 1");
+  if (contract.scope !== "routing-and-dependencies-only") fail("invocation_contract.scope 必须限定为 routing-and-dependencies-only");
+  requireStringArray(contract.required_fields, "invocation_contract.required_fields", { nonEmpty: true });
+  const expected = ["invocation_mode", "trigger_conditions", "exclusion_conditions", "primary_output", "required_dependencies", "optional_dependencies"];
+  if (JSON.stringify(contract.required_fields) !== JSON.stringify(expected)) fail("invocation_contract.required_fields 顺序或字段不完整");
+  requireStringArray(contract.allowed_invocation_modes, "invocation_contract.allowed_invocation_modes", { nonEmpty: true });
+  if (![...INVOCATION_MODES].every((mode) => contract.allowed_invocation_modes.includes(mode))) {
+    fail("invocation_contract.allowed_invocation_modes 必须包含 user、model、both");
+  }
+  if (contract.trigger_source !== "impacts" || contract.trigger_encoding !== "impact:<impact>") {
+    fail("invocation_contract 必须从 impacts 生成 impact:<impact> 触发条件");
+  }
+  requireObject(contract.default, "invocation_contract.default");
+  requireObject(contract.layer_defaults, "invocation_contract.layer_defaults");
+  requireObject(contract.overrides, "invocation_contract.overrides");
+  for (const layer of LAYERS) {
+    const layerDefault = contract.layer_defaults[layer];
+    requireObject(layerDefault, `invocation_contract.layer_defaults.${layer}`);
+    if (!INVOCATION_MODES.has(layerDefault.invocation_mode)) fail(`${layer} 的 invocation_mode 无效`);
+    requireString(layerDefault.primary_output, `invocation_contract.layer_defaults.${layer}.primary_output`);
+  }
+  const defaultMode = contract.default.invocation_mode;
+  if (!INVOCATION_MODES.has(defaultMode)) fail("invocation_contract.default.invocation_mode 无效");
+  requireStringArray(contract.default.trigger_conditions, "invocation_contract.default.trigger_conditions", { nonEmpty: true });
+  requireStringArray(contract.default.exclusion_conditions, "invocation_contract.default.exclusion_conditions", { nonEmpty: true });
+  requireString(contract.default.primary_output, "invocation_contract.default.primary_output");
+  requireStringArray(contract.default.required_dependencies, "invocation_contract.default.required_dependencies");
+  requireStringArray(contract.default.optional_dependencies, "invocation_contract.default.optional_dependencies");
+  for (const [skillId, override] of Object.entries(contract.overrides)) {
+    requireObject(override, `invocation_contract.overrides.${skillId}`);
+    if (!ID_PATTERN.test(skillId)) fail(`invocation_contract.overrides id 非法: ${skillId}`);
+    if (override.invocation_mode && !INVOCATION_MODES.has(override.invocation_mode)) fail(`${skillId}.invocation_mode 无效`);
+    if (override.trigger_conditions) requireStringArray(override.trigger_conditions, `${skillId}.trigger_conditions`, { nonEmpty: true });
+    if (override.exclusion_conditions) requireStringArray(override.exclusion_conditions, `${skillId}.exclusion_conditions`, { nonEmpty: true });
+    if (override.primary_output) requireString(override.primary_output, `${skillId}.primary_output`);
+    if (override.required_dependencies) requireStringArray(override.required_dependencies, `${skillId}.required_dependencies`);
+    if (override.optional_dependencies) requireStringArray(override.optional_dependencies, `${skillId}.optional_dependencies`);
+  }
+  const overrideIds = Object.keys(contract.overrides);
+  const knownIds = new Set(registry.skills.map((item) => item?.id).filter(Boolean));
+  for (const skillId of overrideIds) if (!knownIds.has(skillId)) fail(`invocation_contract.overrides 引用了未登记技能: ${skillId}`);
+  const effective = {
+    ...contract.default,
+    ...contract.layer_defaults[skill.layer],
+    ...(contract.overrides[skill.id] ?? {})
+  };
+  effective.trigger_conditions = [...new Set([...(effective.trigger_conditions ?? []), ...skill.impacts.map((impact) => `impact:${impact}`)])];
+  if (!INVOCATION_MODES.has(effective.invocation_mode)) fail(`${skill.id}.invocation_mode 无效`);
+  requireStringArray(effective.trigger_conditions, `${skill.id}.trigger_conditions`, { nonEmpty: true });
+  requireStringArray(effective.exclusion_conditions, `${skill.id}.exclusion_conditions`, { nonEmpty: true });
+  requireString(effective.primary_output, `${skill.id}.primary_output`);
+  requireStringArray(effective.required_dependencies, `${skill.id}.required_dependencies`);
+  requireStringArray(effective.optional_dependencies, `${skill.id}.optional_dependencies`);
+  const impactTriggers = skill.impacts.map((impact) => `impact:${impact}`);
+  if (!impactTriggers.every((trigger) => effective.trigger_conditions.includes(trigger))) {
+    fail(`${skill.id} 的调用契约必须覆盖其 impacts 触发条件`);
+  }
+}
+
 function requireStringSet(value, expected, field) {
   if (!Array.isArray(value)) fail(`${field} 必须是数组`);
   const missing = expected.filter((item) => !value.includes(item));
@@ -209,6 +278,7 @@ export function validateSkillRegistry(registry, { lock, routerContract, lifecycl
     if (!Array.isArray(skill.impacts) || skill.impacts.length === 0 || skill.impacts.some((item) => typeof item !== "string" || !item.trim())) {
       fail(`${skill.id} impacts 不能为空`);
     }
+    validateInvocationContract(registry, skill);
   }
   for (const skill of skills) {
     if (skill.replaced_by && !ids.has(skill.replaced_by)) fail(`${skill.id}.replaced_by 引用了未登记技能: ${skill.replaced_by}`);
@@ -322,6 +392,7 @@ export function validateSkillRegistry(registry, { lock, routerContract, lifecycl
       }
       if (route.frontend_route) {
         requireString(route.frontend_route.primary_skill, `${routeId}.frontend_route.primary_skill`);
+        requireString(route.frontend_route.page_generation_skill, `${routeId}.frontend_route.page_generation_skill`);
         requireString(route.frontend_route.page_orchestration_skill, `${routeId}.frontend_route.page_orchestration_skill`);
         const conditional = route.frontend_route.conditional_skills;
         if (!conditional || typeof conditional !== "object" || Array.isArray(conditional)) fail(`${routeId}.frontend_route.conditional_skills 必须是对象`);
@@ -332,7 +403,7 @@ export function validateSkillRegistry(registry, { lock, routerContract, lifecycl
             fail(`${routeId}.frontend_route.not_applicable_reasons.${impact} 必须是字符串`);
           }
         }
-        if (!resolve(route.frontend_route.primary_skill) || !resolve(route.frontend_route.page_orchestration_skill)) {
+        if (!resolve(route.frontend_route.primary_skill) || !resolve(route.frontend_route.page_generation_skill) || !resolve(route.frontend_route.page_orchestration_skill)) {
           fail(`${routeId}.frontend_route 主入口引用了未登记技能`);
         }
       }

package/template/scripts/lib/skill-supply-chain.mjs

@@ -7,6 +7,7 @@ import { fileURLToPath } from "node:url";
 export const ROOT = path.resolve(path.dirname(fileURLToPath(import.meta.url)), "../..");
 const SOURCE_ROOT = path.join(ROOT, ".agents/skills");
 const LOCK_PATH = path.join(ROOT, "skills-lock.json");
+const YSS_UI_MANIFEST_PATH = path.join(SOURCE_ROOT, ".yss-skills-manifest.json");
 export const PROJECTION_ROOTS = [".claude/skills", ".codex/skills", ".cursor/skills", ".hermes/skills", ".pi/skills", ".qoder/skills", ".trae/skills"];
 export const OBSOLETE = new Set(["to-" + "prd", "to-" + "issues", "design-an-interface", "qa", "request-refactor-plan", "ubiquitous-language", "edit-article", "obsidian-vault", "writing-great-skills", "code-review-process", "yss-domain-modeling", "yss-dir", "yss-duckdb", "yss-file", "yss-filerunner", "yss-db2mybatis", "yss-mail", "yss-mapper-dynamic", "yss-quality", "yss-sql-condition", "yss-sql-tpl", "yss-valuation", "yss-variable", "yss-openapi", "web-design-engineer", "web-video-presentation", "wireframe-prototype", "wizard", "git-guardrails-claude-code", "claude-handoff", "batch-grill-me", "product-design-prototype", "yss-dictionary", "yss-jdbc", "yss-log", "yss-taskflow", "yss-backend-scaffold-application", "yss-backend-scaffold-domain", "yss-backend-scaffold-infrastructure", "yss-backend-scaffold-web"]);
 export function obsoleteCanonicalResidues(names, obsolete = OBSOLETE) {
@@ -33,6 +34,61 @@ export function treeHash(directory) {
   }
   return digest.digest("hex");
 }
+
+/**
+ * 校验并返回 YSS UI 前端 skills 与 MCP 的上游集成合同。
+ *
+ * @param {unknown} manifest 待校验的清单对象
+ * @returns {Record<string, any>} 已校验的清单
+ */
+export function validateYssUiSkillManifest(manifest) {
+  if (!manifest || typeof manifest !== "object" || Array.isArray(manifest)) throw new TypeError("yss-ui 清单必须是对象");
+  const requiredStrings = ["source", "source_type", "source_root", "source_category", "source_revision", "adaptation_ref"];
+  for (const field of requiredStrings) {
+    if (typeof manifest[field] !== "string" || !manifest[field].trim()) throw new TypeError(`yss-ui 清单缺少 ${field}`);
+  }
+  if (manifest.schema_version !== 2) throw new TypeError("yss-ui 清单 schema_version 必须为 2");
+  if (!/^[0-9a-f]{40}$/.test(manifest.source_revision)) throw new TypeError("yss-ui source_revision 必须是完整 Git SHA");
+  if (!manifest.package || typeof manifest.package.name !== "string" || typeof manifest.package.version !== "string") {
+    throw new TypeError("yss-ui 清单缺少 package name/version");
+  }
+  if (!Array.isArray(manifest.excluded_categories) || manifest.excluded_categories.some((item) => typeof item !== "string" || !item)) {
+    throw new TypeError("yss-ui 清单缺少有效 excluded_categories");
+  }
+  if (!Array.isArray(manifest.excluded_skills) || manifest.excluded_skills.some((item) => typeof item !== "string" || !item)) {
+    throw new TypeError("yss-ui 清单缺少有效 excluded_skills");
+  }
+  if (!Array.isArray(manifest.skills) || !manifest.skills.length) throw new TypeError("yss-ui 清单缺少 skills");
+  const upstreamNames = new Set();
+  const canonicalNames = new Set();
+  for (const skill of manifest.skills) {
+    if (!skill || typeof skill.upstream !== "string" || typeof skill.canonical !== "string") throw new TypeError("yss-ui skill 缺少 upstream/canonical");
+    if (skill.upstream === "java-backend-commit") throw new TypeError("yss-ui 前端清单不得包含 java-backend-commit");
+    if (manifest.excluded_skills.includes(skill.upstream)) throw new TypeError(`yss-ui 清单包含已排除 skill: ${skill.upstream}`);
+    if (upstreamNames.has(skill.upstream)) throw new TypeError(`upstream 重复: ${skill.upstream}`);
+    if (canonicalNames.has(skill.canonical)) throw new TypeError(`canonical 重复: ${skill.canonical}`);
+    if (!/^[0-9a-f]{64}$/.test(skill.upstream_hash ?? "")) throw new TypeError(`${skill.canonical} 缺少有效 upstream_hash`);
+    upstreamNames.add(skill.upstream);
+    canonicalNames.add(skill.canonical);
+  }
+  const mcp = manifest.mcp;
+  if (!mcp || typeof mcp.package !== "string" || typeof mcp.version !== "string" || typeof mcp.components_version !== "string" || typeof mcp.server_name !== "string") {
+    throw new TypeError("yss-ui 清单缺少 MCP package/version/server 信息");
+  }
+  if (!Array.isArray(mcp.project_configs) || !mcp.project_configs.length) throw new TypeError("yss-ui 清单缺少 MCP project_configs");
+  const configPaths = new Set();
+  for (const config of mcp.project_configs) {
+    if (!config || typeof config.path !== "string" || !["mcpServers", "servers"].includes(config.container)) throw new TypeError("yss-ui MCP project_config 无效");
+    if (configPaths.has(config.path)) throw new TypeError(`yss-ui MCP config path 重复: ${config.path}`);
+    configPaths.add(config.path);
+  }
+  if (typeof mcp.global_install_guide !== "string" || !mcp.global_install_guide) throw new TypeError("yss-ui MCP 缺少 global_install_guide");
+  return manifest;
+}
+
+function loadYssUiSkillManifest() {
+  return validateYssUiSkillManifest(JSON.parse(readFileSync(YSS_UI_MANIFEST_PATH, "utf8")));
+}
 function git(args) { return spawnSync("git", args, { cwd: ROOT, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }); }
 function tracked(relativePath) { return git(["ls-files", "-z", "--", relativePath]).stdout.length > 0; }
 function parseLock() { return existsSync(LOCK_PATH) ? JSON.parse(readFileSync(LOCK_PATH, "utf8")) : null; }
@@ -140,6 +196,9 @@ function metadata(name, skillPath, directory, previous, canonical = false, sourc
 }
 export function updateSkillLock(arguments_ = process.argv.slice(2)) {
   const oldLock = parseLock(); const previous = priorMetadata(oldLock); const sources = sourceRevisionMap(oldLock, arguments_); const upstreamRoot = option(arguments_, "upstream-root");
+  const yssUiManifest = loadYssUiSkillManifest();
+  sources[yssUiManifest.source] = { ...(sources[yssUiManifest.source] ?? {}), revision: yssUiManifest.source_revision };
+  const yssUiSkills = new Map(yssUiManifest.skills.map((skill) => [skill.canonical, skill]));
   if (upstreamRoot && !existsSync(upstreamRoot)) throw new TypeError(`--upstream-root 不存在: ${upstreamRoot}`);
   const additions = arguments_.filter((arg) => arg.startsWith("--add=")).map((arg) => arg.slice(6));
   const removals = new Set(arguments_.filter((arg) => arg.startsWith("--remove=")).map((arg) => arg.slice(9)));
@@ -152,7 +211,19 @@ export function updateSkillLock(arguments_ = process.argv.slice(2)) {
   if (unlocked.length) throw new TypeError(`发现未登记到 skills-lock.json 的已跟踪共享 skills: ${unlocked.join(", ")}\n确认新增后运行 scripts/update-skill-lock --add=<skill-name>`);
   const targets = [".agents/skills", ...PROJECTION_ROOTS];
   const shared = Object.fromEntries(sharedNames.map((name) => {
-    const item = metadata(name, `.agents/skills/${name}/SKILL.md`, path.join(SOURCE_ROOT, name), previous, true, sources, upstreamRoot); item.targets = targets; return [name, item];
+    const item = metadata(name, `.agents/skills/${name}/SKILL.md`, path.join(SOURCE_ROOT, name), previous, true, sources, upstreamRoot);
+    const yssUiSkill = yssUiSkills.get(name);
+    if (yssUiSkill) {
+      item.source = yssUiManifest.source;
+      item.sourceType = yssUiManifest.source_type;
+      item.skillPath = `${yssUiManifest.source_root}/${yssUiSkill.upstream}/SKILL.md`;
+      item.sourceRevision = yssUiManifest.source_revision;
+      item.upstreamHash = yssUiSkill.upstream_hash;
+      if (item.effectiveHash !== item.upstreamHash) item.adaptationRef = yssUiManifest.adaptation_ref;
+      else delete item.adaptationRef;
+    }
+    item.targets = targets;
+    return [name, item];
   }));
   const platform = {};
   for (const root of PROJECTION_ROOTS) {

package/template/scripts/verify-digital-human-roles-scenarios

@@ -54,7 +54,7 @@ const seven = [
   "role.lifecycle-orchestrator",
   "role.requirements-manager",
   "role.product-manager",
-  "role.business",
+  "role.project-manager",
   "role.frontend-engineer",
   "role.backend-engineer",
   "role.test-engineer"