scene-capability-engine 3.6.15 → 3.6.17

package/CHANGELOG.md

@@ -7,10 +7,27 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.17] - 2026-03-06
+
+### Added
+- Capability catalog/list/search/show/match/use payloads now expose `ontology_core_ui` for direct UI badge rendering.
+- Magicball capability library guide now documents direct triad badge fields for list and match views.
+
+## [3.6.16] - 2026-03-06
+
+### Added
+- Capability registry validation now enforces ontology core triads for all capability templates.
+- Capability catalog, match, and use payloads now expose `ontology_core` for direct UI rendering.
+- Capability extract now reports triad readiness in candidate summaries.
+
 ## [3.6.15] - 2026-03-06
 
 ### Added
 - Capability plan apply result now includes preview lines + skipped titles for UI feedback.
+- Capability iteration now enforces ontology core triads by default and exposes triad readiness in catalog/match/use payloads:
+  - entity + relation
+  - business rule
+  - decision strategy
 
 ## [3.6.14] - 2026-03-06
 

package/README.md

@@ -218,5 +218,5 @@ MIT. See [LICENSE](LICENSE).
 
 ---
 
-**Version**: 3.6.15  
+**Version**: 3.6.17  
 **Last Updated**: 2026-03-05

package/README.zh.md

@@ -218,5 +218,5 @@ MIT，见 [LICENSE](LICENSE)。
 
 ---
 
-**版本**：3.6.15  
+**版本**：3.6.17  
 **最后更新**：2026-03-05

package/docs/command-reference.md

@@ -1869,6 +1869,12 @@ sce scene template-render --package scene-erp --values '{"entity_name":"Order"}'
 
 ### Capability Iteration (scene -> template -> ontology)
 
+Capability candidates are now evaluated against the ontology core triad by default:
+- entity + relation
+- business rule
+- decision strategy
+
+
 ```bash
 # 1) Extract capability candidate from scene history
 sce capability extract --scene scene.customer-order --json
@@ -1890,6 +1896,8 @@ Schema references:
 
 ### Capability Library Reuse (query -> match -> use)
 
+`catalog/list/search/show/match/use` responses now include `ontology_core` and `ontology_core_ui` so UI can render triad readiness directly.
+
 ```bash
 # List capability templates
 sce capability catalog list --json

package/docs/magicball-capability-library.md

@@ -4,6 +4,12 @@
 
 ## 1. 能力库复用流程
 
+能力模板进入能力库前，默认要求补齐本体三项核心能力：
+- 实体关系
+- 业务规则
+- 决策策略
+
+
 1. **查询**能力库（列表/搜索）
 2. **匹配**当前 spec 的问题域（基于 problem-domain-chain 里的 ontology）
 3. **使用**能力模板（生成可执行的 usage plan）
@@ -72,10 +78,10 @@ sce capability use --template <template-id> --spec <spec-id> --apply --json
 
 ### 4.2 能力库列表
 - 支持筛选：category / risk / source
-- 展示关键信息：`name` / `description` / `ontology_scope`
+- 展示关键信息：`name` / `description` / `ontology_scope` / `ontology_core`
 
 ### 4.3 匹配结果
-- 展示 `score` + `score_components`
+- 展示 `score` + `score_components` + `ontology_core.ready`
 - 支持一键生成 usage plan
 
 ### 4.4 使用计划
@@ -84,6 +90,14 @@ sce capability use --template <template-id> --spec <spec-id> --apply --json
 
 ## 5. 输出结构（关键字段）
 
+列表、详情、匹配、使用计划里的模板对象都应直接消费：
+- `ontology_core`
+- `ontology_core_ui.ready`
+- `ontology_core_ui.coverage_percent`
+- `ontology_core_ui.missing`
+- `ontology_core_ui.triads.entity_relation|business_rules|decision_strategy`
+
+
 ### capability-match
 ```json
 {
@@ -94,6 +108,16 @@ sce capability use --template <template-id> --spec <spec-id> --apply --json
   "matches": [
     {
       "template_id": "customer-order-core",
+      "ontology_core_ui": {
+        "ready": true,
+        "coverage_percent": 100,
+        "missing": [],
+        "triads": {
+          "entity_relation": true,
+          "business_rules": true,
+          "decision_strategy": true
+        }
+      },
       "score": 82,
       "score_components": {
         "ontology": 0.72,

package/lib/commands/capability.js

@@ -330,6 +330,115 @@ async function loadSpecDomainChain(projectPath, specId, fileSystem) {
   }
 }
 
+function createEmptyOntologyScope() {
+  return {
+    domains: [],
+    entities: [],
+    relations: [],
+    business_rules: [],
+    decisions: []
+  };
+}
+
+function normalizeOntologyScope(scope) {
+  const candidate = scope && typeof scope === 'object' ? scope : {};
+  return {
+    domains: normalizeStringArray(candidate.domains),
+    entities: normalizeStringArray(candidate.entities),
+    relations: normalizeStringArray(candidate.relations),
+    business_rules: normalizeStringArray(candidate.business_rules),
+    decisions: normalizeStringArray(candidate.decisions)
+  };
+}
+
+function mergeOntologyScopes(scopes) {
+  const merged = createEmptyOntologyScope();
+  for (const scope of Array.isArray(scopes) ? scopes : []) {
+    const normalized = normalizeOntologyScope(scope);
+    for (const field of Object.keys(merged)) {
+      const combined = new Set([...(merged[field] || []), ...(normalized[field] || [])]);
+      merged[field] = Array.from(combined);
+    }
+  }
+  return merged;
+}
+
+function buildCoreOntologySummary(scope) {
+  const normalized = normalizeOntologyScope(scope);
+  const triads = {
+    entity_relation: {
+      required_fields: ['entities', 'relations'],
+      entity_count: normalized.entities.length,
+      relation_count: normalized.relations.length,
+      passed: normalized.entities.length > 0 && normalized.relations.length > 0
+    },
+    business_rules: {
+      required_fields: ['business_rules'],
+      count: normalized.business_rules.length,
+      passed: normalized.business_rules.length > 0
+    },
+    decision_strategy: {
+      required_fields: ['decisions'],
+      count: normalized.decisions.length,
+      passed: normalized.decisions.length > 0
+    }
+  };
+  const passedCount = Object.values(triads).filter((item) => item.passed).length;
+  return {
+    ontology_scope: normalized,
+    triads,
+    passed_count: passedCount,
+    total_count: 3,
+    coverage_ratio: Number((passedCount / 3).toFixed(3)),
+    ready: passedCount === 3,
+    missing: Object.entries(triads)
+      .filter(([, value]) => !value.passed)
+      .map(([key]) => key)
+  };
+}
+
+function assertCoreOntologySummary(summary, contextLabel = 'capability template') {
+  const details = summary || buildCoreOntologySummary(createEmptyOntologyScope());
+  if (details.ready) {
+    return details;
+  }
+  throw new Error(
+    `${contextLabel} missing required ontology triads: ${details.missing.join(', ')}`
+  );
+}
+
+function buildOntologyCoreUiState(summary) {
+  const details = summary || buildCoreOntologySummary(createEmptyOntologyScope());
+  const labels = {
+    entity_relation: 'entity_relation',
+    business_rules: 'business_rules',
+    decision_strategy: 'decision_strategy'
+  };
+  return {
+    ready: details.ready === true,
+    coverage_ratio: Number(details.coverage_ratio || 0),
+    coverage_percent: Math.round(Number(details.coverage_ratio || 0) * 100),
+    missing: Array.isArray(details.missing) ? details.missing : [],
+    missing_labels: (Array.isArray(details.missing) ? details.missing : []).map((key) => labels[key] || key),
+    triads: {
+      entity_relation: Boolean(details.triads && details.triads.entity_relation && details.triads.entity_relation.passed),
+      business_rules: Boolean(details.triads && details.triads.business_rules && details.triads.business_rules.passed),
+      decision_strategy: Boolean(details.triads && details.triads.decision_strategy && details.triads.decision_strategy.passed)
+    }
+  };
+}
+
+function enrichCapabilityTemplateForUi(template) {
+  const ontologyCore = template && template.ontology_core
+    ? template.ontology_core
+    : buildCoreOntologySummary(template && template.ontology_scope ? template.ontology_scope : createEmptyOntologyScope());
+  return {
+    ...template,
+    ontology_core: ontologyCore,
+    ontology_core_ui: buildOntologyCoreUiState(ontologyCore)
+  };
+}
+
 async function loadSceneIndexFromFile(projectPath, fileSystem) {
   const indexPath = path.join(projectPath, '.sce', 'spec-governance', 'scene-index.json');
   if (!await fileSystem.pathExists(indexPath)) {
@@ -504,13 +613,22 @@ function buildScoreFromCandidate(candidate) {
   const reuseScore = Math.min(100, Math.round((specCount / 3) * 100));
   const stabilityScore = Math.round(completionRate * 100);
   const riskScore = Math.min(100, Math.round((1 - completionRate) * 100));
-  const valueScore = Math.round((stabilityScore * 0.5) + (reuseScore * 0.3) + ((100 - riskScore) * 0.2));
+  const ontologySummary = buildCoreOntologySummary(candidate && candidate.ontology_scope);
+  const ontologyCoreScore = Math.round(ontologySummary.coverage_ratio * 100);
+  const valueScore = Math.round(
+    (stabilityScore * 0.4) +
+    (reuseScore * 0.2) +
+    ((100 - riskScore) * 0.1) +
+    (ontologyCoreScore * 0.3)
+  );
 
   return {
     completion_rate: Number(completionRate.toFixed(3)),
     reuse_score: reuseScore,
     stability_score: stabilityScore,
     risk_score: riskScore,
+    ontology_core_score: ontologyCoreScore,
+    ontology_core: ontologySummary,
     value_score: valueScore
   };
 }
@@ -526,15 +644,12 @@ function buildTemplateCandidate(candidate, mapping, options) {
     || `Capability template derived from ${sceneId}`;
   const category = normalizeText(options && options.category) || 'capability';
   const tags = normalizeStringArray(options && options.tags);
-  const ontologyScope = (mapping && mapping.ontology_scope && typeof mapping.ontology_scope === 'object')
-    ? mapping.ontology_scope
-    : {
-        domains: [],
-        entities: [],
-        relations: [],
-        business_rules: [],
-        decisions: []
-      };
+  const ontologyScope = normalizeOntologyScope(
+    (mapping && mapping.ontology_scope && typeof mapping.ontology_scope === 'object')
+      ? mapping.ontology_scope
+      : candidate && candidate.ontology_scope
+  );
+  const ontologyCore = buildCoreOntologySummary(ontologyScope);
 
   return {
     mode: 'capability-template',
@@ -546,6 +661,7 @@ function buildTemplateCandidate(candidate, mapping, options) {
     scene_id: sceneId,
     source_candidate: candidate,
     ontology_scope: ontologyScope,
+    ontology_core: ontologyCore,
     tags,
     created_at: new Date().toISOString()
   };
@@ -599,6 +715,8 @@ async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
 
   const taskClaimer = new TaskClaimer();
   const specs = [];
+  const ontologyScopes = [];
+  const ontologyEvidence = [];
 
   for (const specId of specIds) {
     const tasksPath = path.join(projectPath, '.sce', 'specs', specId, 'tasks.md');
@@ -613,6 +731,16 @@ async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
     } else {
       taskError = 'tasks.md missing';
     }
+    const domainChain = await loadSpecDomainChain(projectPath, specId, fileSystem);
+    const specOntologyScope = domainChain.payload ? buildOntologyScopeFromChain(domainChain.payload) : createEmptyOntologyScope();
+    if (domainChain.payload) {
+      ontologyScopes.push(specOntologyScope);
+      ontologyEvidence.push({
+        spec_id: specId,
+        source: path.relative(projectPath, domainChain.path),
+        triads: buildCoreOntologySummary(specOntologyScope)
+      });
+    }
     const taskSummary = summarizeTasks(tasks);
     specs.push({
       spec_id: specId,
@@ -623,10 +751,15 @@ async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
         title: task.title,
         status: task.status
       })),
+      ontology_scope: specOntologyScope,
+      ontology_source: domainChain.exists ? path.relative(projectPath, domainChain.path) : null,
+      ontology_error: domainChain.error || null,
       task_error: taskError
     });
   }
 
+  const ontologyScope = mergeOntologyScopes(ontologyScopes);
+  const ontologyCore = buildCoreOntologySummary(ontologyScope);
   const payload = {
     mode: 'capability-extract',
     scene_id: sceneId,
@@ -636,7 +769,15 @@ async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
       spec_count: specIds.length
     },
     specs,
-    summary: buildCandidateSummary(specs)
+    ontology_scope: ontologyScope,
+    ontology_core: ontologyCore,
+    ontology_evidence: ontologyEvidence,
+    summary: {
+      ...buildCandidateSummary(specs),
+      ontology_triads_ready: ontologyCore.ready,
+      ontology_triads_coverage_ratio: ontologyCore.coverage_ratio,
+      ontology_missing_triads: ontologyCore.missing
+    }
   };
 
   const outputPath = normalizeText(options.out) || buildDefaultCandidatePath(sceneId);
@@ -754,6 +895,11 @@ async function runCapabilityRegisterCommand(options = {}, dependencies = {}) {
   if (!templateCandidate || !templateCandidate.template_id) {
     throw new Error('template_id missing in capability template candidate');
   }
+  const ontologySummary = assertCoreOntologySummary(
+    buildCoreOntologySummary(templateCandidate.ontology_scope),
+    'capability template'
+  );
+  templateCandidate.ontology_scope = ontologySummary.ontology_scope;
 
   const exportDir = normalizeText(options.out) || buildDefaultExportDir(templateCandidate.template_id);
   const outputDirAbs = path.join(projectPath, exportDir);
@@ -772,6 +918,7 @@ async function runCapabilityRegisterCommand(options = {}, dependencies = {}) {
     mode: 'capability-register',
     template_id: templateCandidate.template_id,
     output_dir: exportDir,
+    ontology_core: ontologySummary,
     files: [
       path.join(exportDir, 'capability-template.json'),
       path.join(exportDir, 'template-registry.json')
@@ -797,7 +944,8 @@ function displayCapabilityCatalog(templates, options = {}) {
     }
     return;
   }
-  templates.forEach((template) => {
+  templates.forEach((rawTemplate) => {
+    const template = enrichCapabilityTemplateForUi(rawTemplate);
     const sourcePrefix = template.source && template.source !== 'official'
       ? chalk.gray(`[${template.source}] `)
       : '';
@@ -811,13 +959,13 @@ function displayCapabilityCatalog(templates, options = {}) {
 
 async function listCapabilityCatalog(options = {}) {
   const manager = new TemplateManager();
-  const templates = await manager.listTemplates({
+  const templates = (await manager.listTemplates({
     category: options.category,
     source: options.source,
     templateType: 'capability-template',
     compatibleWith: options.compatibleWith,
     riskLevel: options.risk
-  });
+  })).map((template) => enrichCapabilityTemplateForUi(template));
   if (normalizeBoolean(options.json, false)) {
     return {
       mode: 'capability-catalog-list',
@@ -830,13 +978,13 @@ async function listCapabilityCatalog(options = {}) {
 
 async function searchCapabilityCatalog(keyword, options = {}) {
   const manager = new TemplateManager();
-  const templates = await manager.searchTemplates(keyword, {
+  const templates = (await manager.searchTemplates(keyword, {
     category: options.category,
     source: options.source,
     templateType: 'capability-template',
     compatibleWith: options.compatibleWith,
     riskLevel: options.risk
-  });
+  })).map((template) => enrichCapabilityTemplateForUi(template));
   if (normalizeBoolean(options.json, false)) {
     return {
       mode: 'capability-catalog-search',
@@ -850,7 +998,7 @@ async function searchCapabilityCatalog(keyword, options = {}) {
 
 async function showCapabilityTemplate(templatePath, options = {}) {
   const manager = new TemplateManager();
-  const template = await manager.showTemplate(templatePath);
+  const template = enrichCapabilityTemplateForUi(await manager.showTemplate(templatePath));
   const { sourceName, templateId } = parseTemplatePath(templatePath);
   await manager.ensureCached(sourceName);
   const sourcePath = manager.cacheManager.getSourceCachePath(sourceName);
@@ -922,6 +1070,8 @@ async function matchCapabilityTemplates(options = {}) {
       description: template.description,
       category: template.category,
       risk_level: template.risk_level,
+      ontology_core: template.ontology_core || buildCoreOntologySummary(template.ontology_scope || {}),
+      ontology_core_ui: buildOntologyCoreUiState(template.ontology_core || buildCoreOntologySummary(template.ontology_scope || {})),
       score: Math.round(totalScore * 100),
       score_components: {
         ontology: Number(overlap.score.toFixed(3)),
@@ -1006,7 +1156,9 @@ async function useCapabilityTemplate(options = {}) {
       name: template.name,
       source: template.source,
       description: template.description,
-      ontology_scope: template.ontology_scope || {}
+      ontology_scope: template.ontology_scope || {},
+      ontology_core: template.ontology_core || buildCoreOntologySummary(template.ontology_scope || {}),
+      ontology_core_ui: buildOntologyCoreUiState(template.ontology_core || buildCoreOntologySummary(template.ontology_scope || {}))
     },
     spec_id: specId,
     recommended_tasks: recommendedTasks

package/lib/templates/registry-parser.js

@@ -124,12 +124,16 @@ class RegistryParser {
    */
   normalizeTemplateEntry(template = {}) {
     const templateType = this._resolveTemplateType(template);
+    const ontologyScope = this._normalizeOntologyScope(template.ontology_scope);
     const normalized = {
       ...template,
       template_type: templateType,
       min_sce_version: template.min_sce_version ?? null,
       max_sce_version: template.max_sce_version ?? null,
-      ontology_scope: this._normalizeOntologyScope(template.ontology_scope),
+      ontology_scope: ontologyScope,
+      ontology_core: templateType === 'capability-template'
+        ? this._buildCapabilityOntologyCore(ontologyScope)
+        : null,
       risk_level: template.risk_level ?? null,
       rollback_contract: this._normalizeRollbackContract(template.rollback_contract),
       applicable_scenarios: Array.isArray(template.applicable_scenarios) ? template.applicable_scenarios : [],
@@ -235,10 +239,10 @@ class RegistryParser {
       if (!this._isPlainObject(ontologyScope)) {
         errors.push(`${prefix}: capability-template requires "ontology_scope" object`);
       } else {
-        const hasAnyScope = ['domains', 'entities', 'relations', 'business_rules', 'decisions']
-          .some((fieldName) => Array.isArray(ontologyScope[fieldName]) && ontologyScope[fieldName].length > 0);
-        if (!hasAnyScope) {
-          errors.push(`${prefix}: capability-template ontology_scope must include at least one non-empty scope array`);
+        const normalizedOntologyScope = this._normalizeOntologyScope(ontologyScope);
+        const ontologyCore = this._buildCapabilityOntologyCore(normalizedOntologyScope);
+        if (!ontologyCore.ready) {
+          errors.push(`${prefix}: capability-template missing required ontology triads: ${ontologyCore.missing.join(', ')}`);
         }
       }
     }
@@ -655,6 +659,42 @@ class RegistryParser {
     return Object.keys(normalized).length > 0 ? normalized : null;
   }
 
+  _buildCapabilityOntologyCore(ontologyScope) {
+    const normalized = this._normalizeOntologyScope(ontologyScope) || {};
+    const entities = Array.isArray(normalized.entities) ? normalized.entities : [];
+    const relations = Array.isArray(normalized.relations) ? normalized.relations : [];
+    const businessRules = Array.isArray(normalized.business_rules) ? normalized.business_rules : [];
+    const decisions = Array.isArray(normalized.decisions) ? normalized.decisions : [];
+    const triads = {
+      entity_relation: {
+        required_fields: ['entities', 'relations'],
+        entity_count: entities.length,
+        relation_count: relations.length,
+        passed: entities.length > 0 && relations.length > 0
+      },
+      business_rules: {
+        required_fields: ['business_rules'],
+        count: businessRules.length,
+        passed: businessRules.length > 0
+      },
+      decision_strategy: {
+        required_fields: ['decisions'],
+        count: decisions.length,
+        passed: decisions.length > 0
+      }
+    };
+    const missing = Object.entries(triads)
+      .filter(([, value]) => !value.passed)
+      .map(([key]) => key);
+
+    return {
+      triads,
+      ready: missing.length === 0,
+      missing,
+      coverage_ratio: Number(((3 - missing.length) / 3).toFixed(3))
+    };
+  }
+
   /**
    * Normalizes rollback contract
    *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "scene-capability-engine",
-  "version": "3.6.15",
+  "version": "3.6.17",
   "description": "SCE (Scene Capability Engine) - A CLI tool and npm package for spec-driven development with AI coding assistants.",
   "main": "index.js",
   "bin": {