scene-capability-engine 3.6.29 → 3.6.32

package/lib/commands/capability.js

@@ -15,6 +15,24 @@ const { DOMAIN_CHAIN_RELATIVE_PATH } = require('../spec/domain-modeling');
 const { SceStateStore } = require('../state/sce-state-store');
 const TemplateManager = require('../templates/template-manager');
 const { TemplateError } = require('../templates/template-error');
+const { buildMagicballStatusLanguage } = require('../magicball/status-language');
+const {
+  buildCapabilityInventorySceneAdvice,
+  buildCapabilityInventorySummaryStats,
+  buildCapabilityInventorySummaryRecommendations,
+  buildCapabilityInventoryQuickFilters,
+  resolveCapabilityTriadPriority,
+  sortCapabilityInventoryEntries,
+  filterCapabilityInventoryEntries
+} = require('../magicball/capability-inventory-view-model');
+const { runCapabilityInventoryService } = require('../capability/inventory-service');
+const {
+  listCapabilityCatalogService,
+  searchCapabilityCatalogService,
+  showCapabilityTemplateService,
+  matchCapabilityTemplatesService,
+  useCapabilityTemplateService
+} = require('../capability/catalog-service');
 const packageJson = require('../../package.json');
 
 const DEFAULT_ITERATION_DIR = '.sce/reports/capability-iteration';
@@ -820,210 +838,8 @@ async function listCapabilityInventorySceneIds(options = {}, dependencies = {})
   return [];
 }
 
-function resolveCapabilityTriadPriority(entry) {
-  const missing = Array.isArray(entry && entry.release_readiness_ui && entry.release_readiness_ui.blocking_missing)
-    ? entry.release_readiness_ui.blocking_missing
-    : [];
-  if (missing.includes('decision_strategy')) {
-    return 0;
-  }
-  if (missing.includes('business_rules')) {
-    return 1;
-  }
-  if (missing.includes('entity_relation')) {
-    return 2;
-  }
-  return 3;
-}
-
 function buildCapabilityMagicballStatus(input = {}) {
-  const attention = normalizeText(input.attention_level) || 'medium';
-  return {
-    attention_level: attention,
-    status_tone: attention === 'critical' ? 'danger' : (attention === 'high' ? 'warning' : (attention === 'low' ? 'success' : 'info')),
-    status_label: normalizeText(input.status_label) || null,
-    blocking_summary: normalizeText(input.blocking_summary) || null,
-    recommended_action: normalizeText(input.recommended_action) || null
-  };
-}
-
-function buildCapabilityInventorySceneAdvice(entry) {
-  const sceneId = String(entry && entry.scene_id || 'scene.unknown');
-  const releaseUi = entry && entry.release_readiness_ui ? entry.release_readiness_ui : { publish_ready: true, blocking_missing: [] };
-  const missing = Array.isArray(releaseUi.blocking_missing) ? releaseUi.blocking_missing : [];
-  const valueScore = Number(entry && entry.score_preview && entry.score_preview.value_score || 0);
-
-  let attentionLevel = 'low';
-  let recommendedAction = '可直接发布';
-  let blockingSummary = '已满足发布前置条件';
-  let nextAction = 'publish';
-
-  if (!releaseUi.publish_ready) {
-    if (missing.includes('decision_strategy')) {
-      attentionLevel = 'critical';
-      recommendedAction = '补齐决策策略';
-      blockingSummary = '缺决策策略，暂不可发布';
-      nextAction = 'fill_decision_strategy';
-    } else if (missing.includes('business_rules')) {
-      attentionLevel = 'high';
-      recommendedAction = '补齐业务规则';
-      blockingSummary = '缺业务规则，暂不可发布';
-      nextAction = 'fill_business_rules';
-    } else if (missing.includes('entity_relation')) {
-      attentionLevel = 'medium';
-      recommendedAction = '补齐实体关系';
-      blockingSummary = '缺实体关系，暂不可发布';
-      nextAction = 'fill_entity_relation';
-    } else {
-      attentionLevel = 'medium';
-      recommendedAction = '补齐本体能力';
-      blockingSummary = '本体能力不完整，暂不可发布';
-      nextAction = 'repair_ontology_core';
-    }
-  } else if (valueScore >= 70) {
-    attentionLevel = 'low';
-    recommendedAction = '进入模板构建';
-    blockingSummary = '能力成熟度较高，可进入模板构建/发布';
-    nextAction = 'build_template';
-  } else {
-    attentionLevel = 'medium';
-    recommendedAction = '继续补充任务证据';
-    blockingSummary = '已可发布，但建议先补强任务与验证证据';
-    nextAction = 'strengthen_evidence';
-  }
-
-  return {
-    attention_level: attentionLevel,
-    recommended_action: recommendedAction,
-    blocking_summary: blockingSummary,
-    next_action: nextAction,
-    next_command: 'sce capability extract --scene ' + sceneId + ' --json',
-    mb_status: buildCapabilityMagicballStatus({
-      attention_level: attentionLevel,
-      status_label: releaseUi.publish_ready ? 'publish_ready' : 'blocked',
-      blocking_summary: blockingSummary,
-      recommended_action: recommendedAction
-    })
-  };
-}
-
-function buildCapabilityInventorySummaryStats(entries) {
-  const items = Array.isArray(entries) ? entries : [];
-  const summary = {
-    publish_ready_count: 0,
-    blocked_count: 0,
-    missing_triads: {
-      decision_strategy: 0,
-      business_rules: 0,
-      entity_relation: 0
-    }
-  };
-
-  for (const entry of items) {
-    const ready = Boolean(entry && entry.release_readiness_ui && entry.release_readiness_ui.publish_ready);
-    if (ready) {
-      summary.publish_ready_count += 1;
-    } else {
-      summary.blocked_count += 1;
-    }
-
-    const missing = Array.isArray(entry && entry.release_readiness_ui && entry.release_readiness_ui.blocking_missing)
-      ? entry.release_readiness_ui.blocking_missing
-      : [];
-    for (const triad of Object.keys(summary.missing_triads)) {
-      if (missing.includes(triad)) {
-        summary.missing_triads[triad] += 1;
-      }
-    }
-  }
-
-  return summary;
-}
-
-function buildCapabilityInventorySummaryRecommendations(entries) {
-  const items = Array.isArray(entries) ? entries : [];
-  const recommendations = [];
-  const blocked = items.filter((item) => !(item && item.release_readiness_ui && item.release_readiness_ui.publish_ready));
-  const missingDecision = blocked.filter((item) => Array.isArray(item.release_readiness_ui && item.release_readiness_ui.blocking_missing) && item.release_readiness_ui.blocking_missing.includes('decision_strategy'));
-  const missingRules = blocked.filter((item) => Array.isArray(item.release_readiness_ui && item.release_readiness_ui.blocking_missing) && item.release_readiness_ui.blocking_missing.includes('business_rules'));
-  const readyScenes = items.filter((item) => item && item.release_readiness_ui && item.release_readiness_ui.publish_ready);
-
-  if (missingDecision.length > 0) {
-    recommendations.push('优先处理缺决策策略的 scene（' + missingDecision.length + '）');
-  }
-  if (missingRules.length > 0) {
-    recommendations.push('其次处理缺业务规则的 scene（' + missingRules.length + '）');
-  }
-  if (readyScenes.length > 0) {
-    recommendations.push('可优先推进可发布 scene 进入模板构建（' + readyScenes.length + '）');
-  }
-  if (blocked.length === 0 && readyScenes.length === 0 && items.length > 0) {
-    recommendations.push('当前 scene 已基本稳定，可继续补强验证证据');
-  }
-
-  return recommendations;
-}
-
-function buildCapabilityInventoryQuickFilters(summaryStats) {
-  const stats = summaryStats || { blocked_count: 0, missing_triads: {} };
-  const filters = [];
-  if (Number(stats.blocked_count || 0) > 0) {
-    filters.push({ id: 'blocked', label: '不可发布', query: { release_ready: false, missing_triad: null } });
-  }
-  for (const triad of ['decision_strategy', 'business_rules', 'entity_relation']) {
-    if (Number(stats.missing_triads && stats.missing_triads[triad] || 0) > 0) {
-      filters.push({ id: 'missing_' + triad, label: '缺' + triad, query: { release_ready: false, missing_triad: triad } });
-    }
-  }
-  if (Number(stats.publish_ready_count || 0) > 0) {
-    filters.push({ id: 'ready', label: '可发布', query: { release_ready: true, missing_triad: null } });
-  }
-  return filters;
-}
-
-function sortCapabilityInventoryEntries(entries) {
-  return [...(Array.isArray(entries) ? entries : [])].sort((left, right) => {
-    const leftReady = Boolean(left && left.release_readiness_ui && left.release_readiness_ui.publish_ready);
-    const rightReady = Boolean(right && right.release_readiness_ui && right.release_readiness_ui.publish_ready);
-    if (leftReady !== rightReady) {
-      return leftReady ? 1 : -1;
-    }
-
-    const triadDelta = resolveCapabilityTriadPriority(left) - resolveCapabilityTriadPriority(right);
-    if (triadDelta !== 0) {
-      return triadDelta;
-    }
-
-    const leftValue = Number(left && left.score_preview && left.score_preview.value_score || 0);
-    const rightValue = Number(right && right.score_preview && right.score_preview.value_score || 0);
-    if (leftValue !== rightValue) {
-      return rightValue - leftValue;
-    }
-
-    return String(left && left.scene_id || '').localeCompare(String(right && right.scene_id || ''));
-  });
-}
-
-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;
-  });
+  return buildMagicballStatusLanguage(input);
 }
 
 async function runCapabilityInventoryCommand(options = {}, dependencies = {}) {
@@ -1031,70 +847,27 @@ async function runCapabilityInventoryCommand(options = {}, dependencies = {}) {
   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
-    });
-    const sceneEntry = {
-      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
-    };
-    scenes.push({
-      ...sceneEntry,
-      ...buildCapabilityInventorySceneAdvice(sceneEntry)
-    });
-  }
-
-  const filteredScenes = sortCapabilityInventoryEntries(filterCapabilityInventoryEntries(scenes, options));
-  const summaryStats = buildCapabilityInventorySummaryStats(filteredScenes);
-  const releaseReadyFilterRaw = normalizeText(options.releaseReady || options.release_ready).toLowerCase();
-  const payload = {
-    mode: 'capability-inventory',
-    generated_at: new Date().toISOString(),
-    query: {
-      protocol_version: '1.0',
-      scene_id: normalizeText(options.scene || options.sceneId || options.scene_id) || null,
-      limit: limit,
-      sample_limit: toPositiveInteger(options.sample_limit, 5),
-      filters: {
-        release_ready: releaseReadyFilterRaw ? ['1', 'true', 'yes', 'ready'].includes(releaseReadyFilterRaw) : null,
-        missing_triad: normalizeText(options.missingTriad || options.missing_triad) || null
-      }
-    },
-    scene_total: scenes.length,
-    scene_count: filteredScenes.length,
-    summary_stats: summaryStats,
-    summary_recommendations: buildCapabilityInventorySummaryRecommendations(filteredScenes),
-    quick_filters: buildCapabilityInventoryQuickFilters(summaryStats),
-    sort: {
-      strategy: 'publish_ready -> missing_triad_priority -> value_score_desc -> scene_id',
-      triad_priority: ['decision_strategy', 'business_rules', 'entity_relation']
-    },
-    scenes: filteredScenes
-  };
+  const payload = await runCapabilityInventoryService(options, {
+    sceneIds,
+    buildCandidatePayload: buildCapabilityCandidatePayload,
+    buildScoreFromCandidate,
+    buildCapabilityReleaseReadiness,
+    buildOntologyCoreUiState,
+    buildCapabilityReleaseReadinessUi,
+    buildCapabilityInventorySceneAdvice,
+    buildCapabilityInventorySummaryStats,
+    buildCapabilityInventorySummaryRecommendations,
+    buildCapabilityInventoryQuickFilters,
+    sortCapabilityInventoryEntries,
+    filterCapabilityInventoryEntries,
+    runtime: dependencies
+  });
 
   if (normalizeBoolean(options.json, false)) {
     return payload;
   }
   console.log(chalk.green('✅ Capability inventory generated'));
-  console.log(chalk.gray('  Scenes: ' + filteredScenes.length));
+  console.log(chalk.gray('  Scenes: ' + payload.scene_count));
   return payload;
 }
 
@@ -1355,242 +1128,84 @@ function displayCapabilityCatalog(templates, options = {}) {
 }
 
 async function listCapabilityCatalog(options = {}) {
-  const manager = new TemplateManager();
-  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)), options);
+  const payload = await listCapabilityCatalogService(options, {
+    filterCapabilityCatalogEntries,
+    enrichCapabilityTemplateForUi
+  });
   if (normalizeBoolean(options.json, false)) {
-    return {
-      mode: 'capability-catalog-list',
-      templates
-    };
+    return payload;
   }
-  displayCapabilityCatalog(templates, options);
-  return { templates };
+  displayCapabilityCatalog(payload.templates, options);
+  return { templates: payload.templates };
 }
 
 async function searchCapabilityCatalog(keyword, options = {}) {
-  const manager = new TemplateManager();
-  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)), options);
+  const payload = await searchCapabilityCatalogService(keyword, {
+    filterCapabilityCatalogEntries,
+    enrichCapabilityTemplateForUi
+  });
   if (normalizeBoolean(options.json, false)) {
-    return {
-      mode: 'capability-catalog-search',
-      keyword,
-      templates
-    };
+    return payload;
   }
-  displayCapabilityCatalog(templates, options);
-  return { templates };
+  displayCapabilityCatalog(payload.templates, options);
+  return { templates: payload.templates };
 }
 
 async function showCapabilityTemplate(templatePath, options = {}) {
-  const manager = new TemplateManager();
-  const template = enrichCapabilityTemplateForUi(await manager.showTemplate(templatePath));
-  const { sourceName, templateId } = parseTemplatePath(templatePath);
-  await manager.ensureCached(sourceName);
-  const sourcePath = manager.cacheManager.getSourceCachePath(sourceName);
-  const templateDir = path.join(sourcePath, templateId);
-  const capabilityFile = path.join(templateDir, 'capability-template.json');
-  let templatePayload = null;
-  if (await fs.pathExists(capabilityFile)) {
-    try {
-      templatePayload = await fs.readJson(capabilityFile);
-    } catch (_error) {
-      templatePayload = null;
-    }
-  }
-  const result = {
-    mode: 'capability-catalog-show',
-    template,
-    template_file: await fs.pathExists(capabilityFile) ? capabilityFile : null,
-    payload: templatePayload
-  };
+  const payload = await showCapabilityTemplateService(templatePath, {
+    parseTemplatePath,
+    enrichCapabilityTemplateForUi
+  });
   if (normalizeBoolean(options.json, false)) {
-    return result;
+    return payload;
   }
   console.log(chalk.green('✅ Capability template loaded'));
-  console.log(chalk.gray(`  ID: ${template.id}`));
-  console.log(chalk.gray(`  Name: ${template.name}`));
-  if (templatePayload) {
+  console.log(chalk.gray('  ID: ' + payload.template.id));
+  console.log(chalk.gray('  Name: ' + payload.template.name));
+  if (payload.payload) {
     console.log(chalk.gray('  Payload: capability-template.json loaded'));
   }
-  return result;
+  return payload;
 }
 
 async function matchCapabilityTemplates(options = {}) {
-  const projectPath = options.projectPath || process.cwd();
-  const fileSystem = options.fileSystem || fs;
-  const specId = normalizeText(options.spec || options.specId);
-  if (!specId) {
-    throw new Error('spec is required for capability match');
-  }
-  const chain = await loadSpecDomainChain(projectPath, specId, fileSystem);
-  if (!chain.exists && normalizeBoolean(options.strict, false)) {
-    throw new Error(`problem-domain-chain missing for spec ${specId}`);
-  }
-  if (chain.error && normalizeBoolean(options.strict, false)) {
-    throw new Error(`problem-domain-chain invalid: ${chain.error}`);
-  }
-  const domainChain = chain.payload || {};
-  const specScope = buildOntologyScopeFromChain(domainChain);
-  const queryTokens = normalizeTokenList(options.query)
-    .concat(normalizeTokenList(domainChain.problem && domainChain.problem.statement))
-    .concat(normalizeTokenList(domainChain.scene_id));
-  const manager = new TemplateManager();
-  const templates = await manager.listTemplates({
-    source: options.source,
-    templateType: 'capability-template',
-    compatibleWith: options.compatibleWith,
-    riskLevel: options.risk
+  const payload = await matchCapabilityTemplatesService(options, {
+    loadSpecDomainChain,
+    buildOntologyScopeFromChain,
+    normalizeTokenList,
+    buildOntologyOverlap,
+    buildKeywordScore,
+    buildCoreOntologySummary,
+    buildOntologyCoreUiState
   });
-  const matches = templates.map((template) => {
-    const overlap = buildOntologyOverlap(specScope, template.ontology_scope || {});
-    const scenarioScore = template.applicable_scenarios && domainChain.scene_id
-      ? (template.applicable_scenarios.includes(domainChain.scene_id) ? 1 : 0)
-      : 0;
-    const keywordScore = buildKeywordScore(template, queryTokens);
-    const totalScore = (overlap.score * 0.6) + (scenarioScore * 0.2) + (keywordScore * 0.2);
-    return {
-      template_id: template.id,
-      source: template.source,
-      name: template.name,
-      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)),
-        scenario: scenarioScore,
-        keyword: Number(keywordScore.toFixed(3))
-      },
-      overlap
-    };
-  }).sort((a, b) => b.score - a.score);
-
-  const limit = toPositiveInteger(options.limit, 10);
-  const payload = {
-    mode: 'capability-match',
-    spec_id: specId,
-    scene_id: domainChain.scene_id || null,
-    query: normalizeText(options.query) || null,
-    ontology_source: chain.exists ? chain.path : null,
-    match_count: matches.length,
-    matches: matches.slice(0, limit),
-    warnings: chain.exists ? [] : ['problem-domain-chain missing; ontology-based match unavailable']
-  };
   if (normalizeBoolean(options.json, false)) {
     return payload;
   }
   console.log(chalk.green('✅ Capability match completed'));
-  console.log(chalk.gray(`  Spec: ${specId}`));
-  console.log(chalk.gray(`  Matches: ${payload.matches.length}`));
+  console.log(chalk.gray('  Spec: ' + payload.spec_id));
+  console.log(chalk.gray('  Matches: ' + payload.matches.length));
   return payload;
 }
 
 async function useCapabilityTemplate(options = {}) {
-  const projectPath = options.projectPath || process.cwd();
-  const fileSystem = options.fileSystem || fs;
-  const templateId = normalizeText(options.template || options.id);
-  if (!templateId) {
-    throw new Error('template is required for capability use');
-  }
-  if (normalizeBoolean(options.apply, false) && normalizeBoolean(options.write, true) === false) {
-    throw new Error('cannot use --apply with --no-write');
-  }
-  const specId = normalizeText(options.spec || options.specId) || null;
-  const manager = new TemplateManager();
-  const template = await manager.showTemplate(templateId);
-  const { sourceName, templateId: parsedTemplateId } = parseTemplatePath(templateId);
-  await manager.ensureCached(sourceName);
-  const sourcePath = manager.cacheManager.getSourceCachePath(sourceName);
-  const templateDir = path.join(sourcePath, parsedTemplateId);
-  const capabilityFile = path.join(templateDir, 'capability-template.json');
-  let templatePayload = null;
-  if (await fileSystem.pathExists(capabilityFile)) {
-    try {
-      templatePayload = await fileSystem.readJson(capabilityFile);
-    } catch (_error) {
-      templatePayload = null;
-    }
-  }
-
-  const recommendedTasks = [];
-  if (templatePayload && templatePayload.source_candidate && Array.isArray(templatePayload.source_candidate.specs)) {
-    templatePayload.source_candidate.specs.forEach((spec) => {
-      const sample = Array.isArray(spec.task_sample) ? spec.task_sample : [];
-      sample.forEach((task) => {
-        if (task && task.title) {
-          recommendedTasks.push({
-            title: task.title,
-            source_spec_id: spec.spec_id || null,
-            source_task_id: task.id || null
-          });
-        }
-      });
-    });
-  }
-  if (recommendedTasks.length === 0) {
-    recommendedTasks.push({ title: `Implement capability scope: ${template.name || parsedTemplateId}` });
-  }
-
-  const plan = {
-    mode: 'capability-use-plan',
-    generated_at: new Date().toISOString(),
-    template: {
-      id: template.id,
-      name: template.name,
-      source: template.source,
-      description: template.description,
-      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
-  };
-
-  const outputPath = normalizeText(options.out) || buildDefaultUsePlanPath(specId || 'spec', template.id);
-  if (normalizeBoolean(options.write, true)) {
-    await fileSystem.ensureDir(path.dirname(path.join(projectPath, outputPath)));
-    await fileSystem.writeJson(path.join(projectPath, outputPath), plan, { spaces: 2 });
-    plan.output_file = outputPath;
-  }
-
-  if (normalizeBoolean(options.apply, false)) {
-    if (!specId) {
-      throw new Error('spec is required for --apply');
-    }
-    plan.apply = await appendCapabilityPlanToSpecTasks({
-      projectPath,
-      spec: specId,
-      sectionTitle: options.sectionTitle
-    }, plan, fileSystem);
-  }
-
+  const payload = await useCapabilityTemplateService(options, {
+    parseTemplatePath,
+    buildCoreOntologySummary,
+    buildOntologyCoreUiState,
+    buildDefaultUsePlanPath,
+    appendCapabilityPlanToSpecTasks
+  });
   if (!normalizeBoolean(options.json, false)) {
     console.log(chalk.green('✅ Capability use plan generated'));
-    console.log(chalk.gray(`  Template: ${template.id}`));
-    if (specId) {
-      console.log(chalk.gray(`  Spec: ${specId}`));
+    console.log(chalk.gray('  Template: ' + payload.template.id));
+    if (payload.spec_id) {
+      console.log(chalk.gray('  Spec: ' + payload.spec_id));
     }
-    if (plan.output_file) {
-      console.log(chalk.gray(`  Output: ${plan.output_file}`));
+    if (payload.output_file) {
+      console.log(chalk.gray('  Output: ' + payload.output_file));
     }
   }
-
-  return plan;
+  return payload;
 }
 
 function registerCapabilityCommands(program) {

package/lib/commands/scene.js

@@ -1,4 +1,4 @@
-const path = require('path');
+const path = require('path');
 const zlib = require('zlib');
 const crypto = require('crypto');
 const { spawnSync } = require('child_process');