scene-capability-engine 3.6.20 → 3.6.22

package/CHANGELOG.md

@@ -7,6 +7,19 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [3.6.22] - 2026-03-06
+
+### Added
+- New `sce capability inventory` command provides scene-level triad/readiness aggregation for homepage views.
+- Magicball capability iteration docs now define homepage inventory API and triage usage.
+
+## [3.6.21] - 2026-03-06
+
+### Added
+- New `sce capability inventory` command provides scene-level triad/readiness aggregation for homepage views.
+- Capability catalog list/search now supports `--release-ready` and `--missing-triad` filters for pre-publish triage.
+- Magicball capability library docs now show list-level triage filter examples.
+
 ## [3.6.20] - 2026-03-06
 
 ### Added

package/README.md

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

package/README.zh.md

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

package/docs/command-reference.md

@@ -1869,6 +1869,13 @@ sce scene template-render --package scene-erp --values '{"entity_name":"Order"}'
 
 ### Capability Iteration (scene -> template -> ontology)
 
+```bash
+# 0) Build scene-level homepage inventory
+sce capability inventory --json
+sce capability inventory --release-ready false --missing-triad decision_strategy --json
+```
+
+
 Capability candidates are now evaluated against the ontology core triad by default:
 - entity + relation
 - business rule
@@ -1903,6 +1910,8 @@ Catalog payloads also expose `release_readiness_ui` for pre-publish sorting and
 ```bash
 # List capability templates
 sce capability catalog list --json
+sce capability catalog list --release-ready true --json
+sce capability catalog list --missing-triad decision_strategy --json
 
 # Search capability templates
 sce capability catalog search "customer order" --json

package/docs/magicball-capability-iteration-api.md

@@ -15,7 +15,31 @@
 
 ## 2. 建议 API 列表
 
-### 2.1 Extract
+### 2.1 Inventory
+
+```
+POST /api/capability/inventory
+```
+
+请求：
+```json
+{
+  "release_ready": false,
+  "missing_triad": "decision_strategy"
+}
+```
+
+执行 CLI：
+```bash
+sce capability inventory --release-ready false --missing-triad decision_strategy --json
+```
+
+响应：
+- 返回 `capability-inventory` payload，重点消费 `scenes[].ontology_core_ui` 与 `scenes[].release_readiness_ui`
+
+---
+
+### 2.2 Extract
 
 ```
 POST /api/capability/extract
@@ -40,7 +64,7 @@ sce capability extract --scene <scene_id> --specs <specs> --sample-limit <n> --j
 
 ---
 
-### 2.2 Score
+### 2.3 Score
 
 ```
 POST /api/capability/score
@@ -63,7 +87,7 @@ sce capability score --input <candidate_file> --json
 
 ---
 
-### 2.3 Map
+### 2.4 Map
 
 ```
 POST /api/capability/map
@@ -91,7 +115,7 @@ sce capability map --input <candidate_file> --mapping <ontology_file> \
 
 ---
 
-### 2.4 Register
+### 2.5 Register
 
 ```
 POST /api/capability/register
@@ -147,8 +171,9 @@ sce capability register --input <template_file> --risk-level <level> --difficult
 
 ## 5. 推荐顺序
 
-1. `/api/capability/extract`
-2. `/api/capability/score`
-3. `/api/capability/map`
-4. `/api/capability/register`
+1. `/api/capability/inventory`
+2. `/api/capability/extract`
+3. `/api/capability/score`
+4. `/api/capability/map`
+5. `/api/capability/register`
 

package/docs/magicball-capability-iteration-ui.md

@@ -98,7 +98,13 @@
 
 ## 4. SCE 接口参数（CLI 可封装）
 
-### 4.1 提取候选能力
+### 4.1 Scene 盘点首页聚合
+```bash
+sce capability inventory --json
+sce capability inventory --release-ready false --missing-triad decision_strategy --json
+```
+
+### 4.2 提取候选能力
 ```bash
 sce capability extract --scene <sceneId> --json
 ```

package/docs/magicball-capability-library.md

@@ -20,7 +20,9 @@
 
 ```bash
 sce capability catalog list --json
-sce capability catalog search "customer order" --json
+sce capability catalog list --release-ready true --json
+sce capability catalog list --missing-triad decision_strategy --json
+sce capability catalog search "customer order" --release-ready false --json
 sce capability catalog show <template-id> --json
 ```
 

package/lib/commands/capability.js

@@ -723,46 +723,10 @@ function buildTemplateCandidate(candidate, mapping, options) {
   };
 }
 
-function buildRegistryEntry(templateCandidate, options) {
-  const riskLevel = normalizeText(options && options.risk_level) || 'medium';
-  const difficulty = normalizeText(options && options.difficulty) || 'intermediate';
-  const applicable = normalizeStringArray(options && options.applicable_scenarios);
-  const tags = normalizeStringArray(options && options.tags);
-  const sceneId = buildSceneIdFromCandidate(templateCandidate);
-  const safeTags = tags.length > 0 ? tags : ['capability', sceneId];
-  const safeApplicable = applicable.length > 0 ? applicable : [sceneId];
-
-  return {
-    id: templateCandidate.template_id,
-    name: templateCandidate.name,
-    category: templateCandidate.category,
-    description: templateCandidate.description,
-    difficulty,
-    tags: safeTags,
-    applicable_scenarios: safeApplicable,
-    files: ['capability-template.json'],
-    template_type: 'capability-template',
-    min_sce_version: packageJson.version,
-    max_sce_version: null,
-    risk_level: riskLevel,
-    rollback_contract: {
-      supported: false,
-      strategy: 'n/a'
-    },
-    ontology_scope: templateCandidate.ontology_scope
-  };
-}
-
-async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
+async function buildCapabilityCandidatePayload(sceneId, options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
   const env = dependencies.env || process.env;
-  const sceneId = normalizeText(options.scene || options.sceneId || options.scene_id);
-  const writeOutput = normalizeBoolean(options.write, true);
-
-  if (!sceneId) {
-    throw new Error('scene is required for capability extract');
-  }
 
   const specResolution = await resolveSceneSpecs(sceneId, {
     specs: options.specs
@@ -816,7 +780,7 @@ async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
 
   const ontologyScope = mergeOntologyScopes(ontologyScopes);
   const ontologyCore = buildCoreOntologySummary(ontologyScope);
-  const payload = {
+  return {
     mode: 'capability-extract',
     scene_id: sceneId,
     generated_at: new Date().toISOString(),
@@ -835,7 +799,138 @@ async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
       ontology_missing_triads: ontologyCore.missing
     }
   };
+}
+
+async function listCapabilityInventorySceneIds(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const env = dependencies.env || process.env;
+  const explicitScene = normalizeText(options.scene || options.sceneId || options.scene_id);
+  if (explicitScene) {
+    return [explicitScene];
+  }
+  const fromFile = await loadSceneIndexFromFile(projectPath, fileSystem);
+  if (fromFile && fromFile.data && fromFile.data.scenes) {
+    return Object.keys(fromFile.data.scenes).sort();
+  }
+  const fromState = await loadSceneIndexFromState(projectPath, fileSystem, env);
+  if (fromState && fromState.data && fromState.data.scenes) {
+    return Object.keys(fromState.data.scenes).sort();
+  }
+  return [];
+}
+
+function filterCapabilityInventoryEntries(entries, options = {}) {
+  const normalizedMissingTriad = normalizeText(options.missingTriad || options.missing_triad).toLowerCase();
+  const releaseReadyFilter = normalizeText(options.releaseReady || options.release_ready).toLowerCase();
+  return (Array.isArray(entries) ? entries : []).filter((entry) => {
+    if (releaseReadyFilter) {
+      const expected = ['1', 'true', 'yes', 'ready'].includes(releaseReadyFilter);
+      if (Boolean(entry.release_readiness_ui && entry.release_readiness_ui.publish_ready) !== expected) {
+        return false;
+      }
+    }
+    if (normalizedMissingTriad) {
+      const missing = Array.isArray(entry.release_readiness_ui && entry.release_readiness_ui.blocking_missing)
+        ? entry.release_readiness_ui.blocking_missing
+        : [];
+      if (!missing.includes(normalizedMissingTriad)) {
+        return false;
+      }
+    }
+    return true;
+  });
+}
+
+async function runCapabilityInventoryCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const env = dependencies.env || process.env;
+  const sceneIds = await listCapabilityInventorySceneIds(options, { projectPath, fileSystem, env });
+  const limit = toPositiveInteger(options.limit, sceneIds.length || 20);
+  const scenes = [];
+
+  for (const sceneId of sceneIds.slice(0, limit)) {
+    const candidate = await buildCapabilityCandidatePayload(sceneId, {
+      specs: options.specs,
+      sample_limit: options.sample_limit
+    }, dependencies);
+    const score = buildScoreFromCandidate(candidate);
+    const releaseReadiness = buildCapabilityReleaseReadiness({
+      scene_id: sceneId,
+      ontology_scope: candidate.ontology_scope,
+      ontology_core: candidate.ontology_core
+    });
+    scenes.push({
+      scene_id: sceneId,
+      summary: candidate.summary,
+      source: candidate.source,
+      ontology_scope: candidate.ontology_scope,
+      ontology_core: candidate.ontology_core,
+      ontology_core_ui: buildOntologyCoreUiState(candidate.ontology_core),
+      release_readiness: releaseReadiness,
+      release_readiness_ui: buildCapabilityReleaseReadinessUi(releaseReadiness),
+      score_preview: score
+    });
+  }
+
+  const filteredScenes = filterCapabilityInventoryEntries(scenes, options);
+  const payload = {
+    mode: 'capability-inventory',
+    generated_at: new Date().toISOString(),
+    scene_count: filteredScenes.length,
+    scenes: filteredScenes
+  };
+
+  if (normalizeBoolean(options.json, false)) {
+    return payload;
+  }
+  console.log(chalk.green('✅ Capability inventory generated'));
+  console.log(chalk.gray('  Scenes: ' + filteredScenes.length));
+  return payload;
+}
+
+function buildRegistryEntry(templateCandidate, options) {
+  const riskLevel = normalizeText(options && options.risk_level) || 'medium';
+  const difficulty = normalizeText(options && options.difficulty) || 'intermediate';
+  const applicable = normalizeStringArray(options && options.applicable_scenarios);
+  const tags = normalizeStringArray(options && options.tags);
+  const sceneId = buildSceneIdFromCandidate(templateCandidate);
+  const safeTags = tags.length > 0 ? tags : ['capability', sceneId];
+  const safeApplicable = applicable.length > 0 ? applicable : [sceneId];
+
+  return {
+    id: templateCandidate.template_id,
+    name: templateCandidate.name,
+    category: templateCandidate.category,
+    description: templateCandidate.description,
+    difficulty,
+    tags: safeTags,
+    applicable_scenarios: safeApplicable,
+    files: ['capability-template.json'],
+    template_type: 'capability-template',
+    min_sce_version: packageJson.version,
+    max_sce_version: null,
+    risk_level: riskLevel,
+    rollback_contract: {
+      supported: false,
+      strategy: 'n/a'
+    },
+    ontology_scope: templateCandidate.ontology_scope
+  };
+}
+
+async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
+  const projectPath = dependencies.projectPath || process.cwd();
+  const fileSystem = dependencies.fileSystem || fs;
+  const sceneId = normalizeText(options.scene || options.sceneId || options.scene_id);
+  const writeOutput = normalizeBoolean(options.write, true);
+
+  if (!sceneId) {
+    throw new Error('scene is required for capability extract');
+  }
 
+  const payload = await buildCapabilityCandidatePayload(sceneId, options, dependencies);
   const outputPath = normalizeText(options.out) || buildDefaultCandidatePath(sceneId);
   if (writeOutput) {
     await fileSystem.ensureDir(path.dirname(path.join(projectPath, outputPath)));
@@ -845,17 +940,16 @@ async function runCapabilityExtractCommand(options = {}, dependencies = {}) {
 
   if (!normalizeBoolean(options.json, false)) {
     console.log(chalk.green('✅ Capability candidate extracted'));
-    console.log(chalk.gray(`  Scene: ${sceneId}`));
-    console.log(chalk.gray(`  Specs: ${payload.summary.spec_count}`));
-    console.log(chalk.gray(`  Tasks: ${payload.summary.task_total}`));
+    console.log(chalk.gray('  Scene: ' + sceneId));
+    console.log(chalk.gray('  Specs: ' + payload.summary.spec_count));
+    console.log(chalk.gray('  Tasks: ' + payload.summary.task_total));
     if (payload.output_file) {
-      console.log(chalk.gray(`  Output: ${payload.output_file}`));
+      console.log(chalk.gray('  Output: ' + payload.output_file));
     }
   }
 
   return payload;
 }
-
 async function runCapabilityScoreCommand(options = {}, dependencies = {}) {
   const projectPath = dependencies.projectPath || process.cwd();
   const fileSystem = dependencies.fileSystem || fs;
@@ -1001,6 +1095,34 @@ async function runCapabilityRegisterCommand(options = {}, dependencies = {}) {
   return result;
 }
 
+function filterCapabilityCatalogEntries(templates, options = {}) {
+  const entries = Array.isArray(templates) ? templates : [];
+  const normalizedMissingTriad = normalizeText(options.missingTriad || options.missing_triad).toLowerCase();
+  const releaseReadyFilter = normalizeText(options.releaseReady || options.release_ready).toLowerCase();
+
+  return entries.filter((entry) => {
+    const template = enrichCapabilityTemplateForUi(entry);
+
+    if (releaseReadyFilter) {
+      const expected = ['1', 'true', 'yes', 'ready'].includes(releaseReadyFilter);
+      if (template.release_readiness_ui.publish_ready !== expected) {
+        return false;
+      }
+    }
+
+    if (normalizedMissingTriad) {
+      const missing = Array.isArray(template.release_readiness_ui.blocking_missing)
+        ? template.release_readiness_ui.blocking_missing
+        : [];
+      if (!missing.includes(normalizedMissingTriad)) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+}
+
 function displayCapabilityCatalog(templates, options = {}) {
   const total = Array.isArray(templates) ? templates.length : 0;
   console.log(chalk.red('🔥') + ' Capability Library');
@@ -1026,13 +1148,13 @@ function displayCapabilityCatalog(templates, options = {}) {
 
 async function listCapabilityCatalog(options = {}) {
   const manager = new TemplateManager();
-  const templates = (await manager.listTemplates({
+  const templates = filterCapabilityCatalogEntries((await manager.listTemplates({
     category: options.category,
     source: options.source,
     templateType: 'capability-template',
     compatibleWith: options.compatibleWith,
     riskLevel: options.risk
-  })).map((template) => enrichCapabilityTemplateForUi(template));
+  })).map((template) => enrichCapabilityTemplateForUi(template)), options);
   if (normalizeBoolean(options.json, false)) {
     return {
       mode: 'capability-catalog-list',
@@ -1045,13 +1167,13 @@ async function listCapabilityCatalog(options = {}) {
 
 async function searchCapabilityCatalog(keyword, options = {}) {
   const manager = new TemplateManager();
-  const templates = (await manager.searchTemplates(keyword, {
+  const templates = filterCapabilityCatalogEntries((await manager.searchTemplates(keyword, {
     category: options.category,
     source: options.source,
     templateType: 'capability-template',
     compatibleWith: options.compatibleWith,
     riskLevel: options.risk
-  })).map((template) => enrichCapabilityTemplateForUi(template));
+  })).map((template) => enrichCapabilityTemplateForUi(template)), options);
   if (normalizeBoolean(options.json, false)) {
     return {
       mode: 'capability-catalog-search',
@@ -1291,6 +1413,34 @@ function registerCapabilityCommands(program) {
       });
     });
 
+  capabilityCmd
+    .command('inventory')
+    .description('Build scene-level capability inventory for homepage views')
+    .option('--scene <scene-id>', 'Single scene identifier')
+    .option('--sample-limit <n>', 'Max tasks per spec in sample', '5')
+    .option('--limit <n>', 'Max scenes to include')
+    .option('--release-ready <bool>', 'Filter by publish readiness')
+    .option('--missing-triad <name>', 'Filter by missing triad (entity_relation|business_rules|decision_strategy)')
+    .option('--json', 'Output JSON to stdout')
+    .action(async (options) => {
+      try {
+        const payload = await runCapabilityInventoryCommand({
+          scene: options.scene,
+          sample_limit: options.sampleLimit,
+          limit: options.limit,
+          releaseReady: options.releaseReady,
+          missingTriad: options.missingTriad,
+          json: options.json
+        });
+        if (options.json) {
+          console.log(JSON.stringify(payload, null, 2));
+        }
+      } catch (error) {
+        console.log();
+        console.log(chalk.red('❌ Error:'), error.message);
+        process.exit(1);
+      }
+    });
   capabilityCmd
     .command('score')
     .description('Score a capability candidate')
@@ -1361,6 +1511,8 @@ function registerCapabilityCommands(program) {
     .option('--category <name>', 'Template category filter')
     .option('--compatible-with <semver>', 'SCE version compatibility')
     .option('--risk <level>', 'Risk level filter')
+    .option('--release-ready <bool>', 'Filter by publish readiness')
+    .option('--missing-triad <name>', 'Filter by missing triad (entity_relation|business_rules|decision_strategy)')
     .option('--json', 'Output JSON to stdout')
     .action(async (options) => {
       try {
@@ -1369,6 +1521,8 @@ function registerCapabilityCommands(program) {
           category: options.category,
           compatibleWith: options.compatibleWith,
           risk: options.risk,
+          releaseReady: options.releaseReady,
+          missingTriad: options.missingTriad,
           json: options.json
         });
         if (options.json) {
@@ -1393,6 +1547,8 @@ function registerCapabilityCommands(program) {
     .option('--category <name>', 'Template category filter')
     .option('--compatible-with <semver>', 'SCE version compatibility')
     .option('--risk <level>', 'Risk level filter')
+    .option('--release-ready <bool>', 'Filter by publish readiness')
+    .option('--missing-triad <name>', 'Filter by missing triad (entity_relation|business_rules|decision_strategy)')
     .option('--json', 'Output JSON to stdout')
     .action(async (keyword, options) => {
       try {
@@ -1401,6 +1557,8 @@ function registerCapabilityCommands(program) {
           category: options.category,
           compatibleWith: options.compatibleWith,
           risk: options.risk,
+          releaseReady: options.releaseReady,
+          missingTriad: options.missingTriad,
           json: options.json
         });
         if (options.json) {
@@ -1494,11 +1652,14 @@ module.exports = {
   runCapabilityScoreCommand,
   runCapabilityMapCommand,
   runCapabilityRegisterCommand,
+  runCapabilityInventoryCommand,
   listCapabilityCatalog,
   searchCapabilityCatalog,
   showCapabilityTemplate,
   matchCapabilityTemplates,
   useCapabilityTemplate,
   enrichCapabilityTemplateForUi,
-  buildCapabilityReleaseReadinessUi
+  buildCapabilityReleaseReadinessUi,
+  filterCapabilityCatalogEntries,
+  filterCapabilityInventoryEntries
 };

package/package.json

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