scene-capability-engine 3.0.3 → 3.0.4

package/docs/command-reference.md

@@ -725,7 +725,11 @@ Close-loop controller session maintenance:
 Cross-archive autonomous governance maintenance:
 - `sce auto governance stats [--days <n>] [--status <csv>] [--json]`: aggregate a unified governance snapshot from session/batch-session/controller-session archives plus recovery memory state.
   - JSON output includes `totals`, `throughput`, `health` (`risk_level`, `concerns`, `recommendations`, `release_gate`, `handoff_quality`), `top_master_specs`, `recovery_memory`, and full per-archive stats under `archives`.
-  - `health.handoff_quality` carries Moqui matrix regression governance signals:
+  - `health.handoff_quality` carries Moqui matrix + capability lexicon governance signals:
+    - `latest_capability_expected_unknown_count`
+    - `latest_capability_provided_unknown_count`
+    - `capability_expected_unknown_positive_rate_percent`
+    - `capability_provided_unknown_positive_rate_percent`
     - `latest_moqui_matrix_regression_count`
     - `latest_moqui_matrix_regression_gate_max`
     - `avg_moqui_matrix_regression_count`
@@ -743,6 +747,10 @@ Cross-archive autonomous governance maintenance:
   - `--execute-advisory` enables automatic advisory action execution (`recover-latest`, `controller-resume-latest`) when governance assessment detects failed sessions or controller pending goals; sce auto-selects the latest actionable advisory source and reports `skipped` (not `failed`) when no actionable source exists.
   - JSON output includes round-by-round risk/action telemetry (`rounds`, with `risk_before/risk_after` and `release_gate_before/release_gate_after`), advisory telemetry (`execute_advisory`, `advisory_policy`, `advisory_summary`, `rounds[*].advisory_actions`), `stop_detail` + `recommendations` for explicit blocking reasons, plus `initial_assessment`, `final_assessment`, and convergence metadata.
   - Release-gate block reasons now include handoff matrix regression reasons when present:
+    - `handoff-capability-expected-unknown-positive:<n>`
+    - `handoff-capability-provided-unknown-positive:<n>`
+    - `handoff-capability-expected-unknown-positive-rate:<percent>`
+    - `handoff-capability-provided-unknown-positive-rate:<percent>`
     - `handoff-moqui-matrix-regressions-positive:<n>`
     - `handoff-moqui-matrix-regressions-over-gate:<n>/<max>`
 - `sce auto governance session list [--limit <n>] [--status <csv>] [--resume-only] [--json]`: list persisted governance close-loop sessions (`--resume-only` filters to resumed-chain sessions only).
@@ -814,11 +822,13 @@ Dual-track handoff integration:
   - Default scan dir is `.kiro/reports/release-evidence`, default output file is `.kiro/reports/release-evidence/release-gate-history.json`.
   - `--history-file` merges an existing index (for example, previous release asset) before dedup/refresh.
   - `--keep` retains latest N entries (`1-5000`, default `200`).
-  - Aggregates include scene package batch, drift, and release-preflight/hard-gate signals (`scene_package_batch_*`, `drift_alert_*`, `drift_block_*`, `release_gate_preflight_*`) when present in gate reports.
+  - Aggregates include scene package batch, capability unknown trend, drift, and release-preflight/hard-gate signals (`scene_package_batch_*`, `capability_expected_unknown_*`, `capability_provided_unknown_*`, `drift_alert_*`, `drift_block_*`, `release_gate_preflight_*`) when present in gate reports.
   - `--markdown-out <path>` writes a human-readable trend card markdown for PR/Issue handoff.
 
 Moqui template library lexicon audit (script-level governance helper):
 - `node scripts/moqui-lexicon-audit.js [--manifest <path>] [--template-dir <path>] [--lexicon <path>] [--out <path>] [--markdown-out <path>] [--fail-on-gap] [--json]`: audit manifest/template capability names against canonical Moqui lexicon; reports unknown aliases and uncovered expected capabilities.
+  - By default, template capability auditing is scoped to `manifest.templates` (when matched), reducing noise from unrelated templates.
+  - Template scope matching normalizes `sce.scene--*` / `kse.scene--*` prefixes, so renamed template namespaces still map correctly.
 
 Recommended `.kiro/config/orchestrator.json`:
 

package/docs/moqui-template-core-library-playbook.md

@@ -17,8 +17,10 @@ sce defaults already enforce the baseline below:
 - `sce auto handoff run`: requires Moqui baseline portfolio pass by default.
 - `sce auto handoff run`: enforces Moqui matrix regression hard-gate by default (`max_moqui_matrix_regressions=0`).
 - `sce auto handoff run`: evaluates capability coverage matrix by default when manifest `capabilities` is declared (default minimum `100%`).
+- `sce auto handoff run` / `sce auto handoff capability-matrix`: enforces capability lexicon normalization by default (expected/provided unknown aliases are blocked unless explicitly bypassed).
 - `sce auto handoff capability-matrix`: enforces both capability coverage and capability semantic completeness (default minimum `100%` for each).
 - `sce auto governance stats` / `sce auto governance close-loop`: treats Moqui matrix regressions as first-class risk/block signals (including over-gate stop reasons).
+- `sce auto governance stats` / `sce auto governance close-loop`: treats capability lexicon unknown-count signals as first-class risk/block signals.
 - `sce scene package-publish-batch`:
   - ontology validation required by default
   - batch ontology gate defaults:

package/lib/commands/auto.js

@@ -8954,6 +8954,24 @@ function buildAutoHandoffReleaseGateHistoryEntry(entry = {}, options = {}) {
       ? entry.scene_package_batch_failure_count
       : signalMap.scene_package_batch_failure_count
   );
+  const capabilityExpectedUnknownCount = parseAutoHandoffGateNumber(
+    entry.capability_expected_unknown_count !== undefined
+      ? entry.capability_expected_unknown_count
+      : (
+        signalMap.capability_expected_unknown_count !== undefined
+          ? signalMap.capability_expected_unknown_count
+          : signalMap.capability_lexicon_expected_unknown_count
+      )
+  );
+  const capabilityProvidedUnknownCount = parseAutoHandoffGateNumber(
+    entry.capability_provided_unknown_count !== undefined
+      ? entry.capability_provided_unknown_count
+      : (
+        signalMap.capability_provided_unknown_count !== undefined
+          ? signalMap.capability_provided_unknown_count
+          : signalMap.capability_lexicon_provided_unknown_count
+      )
+  );
   const releaseGatePreflightAvailable = parseAutoHandoffGateBoolean(
     entry.release_gate_preflight_available !== undefined
       ? entry.release_gate_preflight_available
@@ -9058,6 +9076,12 @@ function buildAutoHandoffReleaseGateHistoryEntry(entry = {}, options = {}) {
     scene_package_batch_status: sceneBatchStatus || null,
     scene_package_batch_passed: typeof sceneBatchPassed === 'boolean' ? sceneBatchPassed : null,
     scene_package_batch_failure_count: Number.isFinite(sceneBatchFailureCount) ? sceneBatchFailureCount : null,
+    capability_expected_unknown_count: Number.isFinite(capabilityExpectedUnknownCount)
+      ? Math.max(0, Number(capabilityExpectedUnknownCount))
+      : null,
+    capability_provided_unknown_count: Number.isFinite(capabilityProvidedUnknownCount)
+      ? Math.max(0, Number(capabilityProvidedUnknownCount))
+      : null,
     release_gate_preflight_available: typeof releaseGatePreflightAvailable === 'boolean'
       ? releaseGatePreflightAvailable
       : null,
@@ -9220,6 +9244,12 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
   let preflightAvailableRuns = 0;
   let preflightBlockedRuns = 0;
   let preflightHardGateRuns = 0;
+  let capabilityExpectedUnknownKnownRuns = 0;
+  let capabilityExpectedUnknownPositiveRuns = 0;
+  let capabilityProvidedUnknownKnownRuns = 0;
+  let capabilityProvidedUnknownPositiveRuns = 0;
+  const capabilityExpectedUnknownCounts = [];
+  const capabilityProvidedUnknownCounts = [];
   const sceneBatchFailureCounts = [];
   let sceneBatchApplicableCount = 0;
   let sceneBatchPassedCount = 0;
@@ -9268,6 +9298,28 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
     if (Number.isFinite(sceneBatchFailureCount)) {
       sceneBatchFailureCounts.push(sceneBatchFailureCount);
     }
+    const capabilityExpectedUnknownCount = parseAutoHandoffGateNumber(
+      entry && entry.capability_expected_unknown_count
+    );
+    if (Number.isFinite(capabilityExpectedUnknownCount)) {
+      const normalizedCount = Math.max(0, Number(capabilityExpectedUnknownCount));
+      capabilityExpectedUnknownKnownRuns += 1;
+      capabilityExpectedUnknownCounts.push(normalizedCount);
+      if (normalizedCount > 0) {
+        capabilityExpectedUnknownPositiveRuns += 1;
+      }
+    }
+    const capabilityProvidedUnknownCount = parseAutoHandoffGateNumber(
+      entry && entry.capability_provided_unknown_count
+    );
+    if (Number.isFinite(capabilityProvidedUnknownCount)) {
+      const normalizedCount = Math.max(0, Number(capabilityProvidedUnknownCount));
+      capabilityProvidedUnknownKnownRuns += 1;
+      capabilityProvidedUnknownCounts.push(normalizedCount);
+      if (normalizedCount > 0) {
+        capabilityProvidedUnknownPositiveRuns += 1;
+      }
+    }
     const preflightAvailable = parseAutoHandoffGateBoolean(
       entry && entry.release_gate_preflight_available,
       null
@@ -9348,6 +9400,24 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
   const maxSceneBatchFailureCount = sceneBatchFailureCounts.length > 0
     ? Number(Math.max(...sceneBatchFailureCounts).toFixed(2))
     : null;
+  const avgCapabilityExpectedUnknownCount = capabilityExpectedUnknownCounts.length > 0
+    ? Number((capabilityExpectedUnknownCounts.reduce((sum, value) => sum + value, 0) / capabilityExpectedUnknownCounts.length).toFixed(2))
+    : null;
+  const maxCapabilityExpectedUnknownCount = capabilityExpectedUnknownCounts.length > 0
+    ? Number(Math.max(...capabilityExpectedUnknownCounts).toFixed(2))
+    : null;
+  const capabilityExpectedUnknownPositiveRate = capabilityExpectedUnknownKnownRuns > 0
+    ? Number(((capabilityExpectedUnknownPositiveRuns / capabilityExpectedUnknownKnownRuns) * 100).toFixed(2))
+    : null;
+  const avgCapabilityProvidedUnknownCount = capabilityProvidedUnknownCounts.length > 0
+    ? Number((capabilityProvidedUnknownCounts.reduce((sum, value) => sum + value, 0) / capabilityProvidedUnknownCounts.length).toFixed(2))
+    : null;
+  const maxCapabilityProvidedUnknownCount = capabilityProvidedUnknownCounts.length > 0
+    ? Number(Math.max(...capabilityProvidedUnknownCounts).toFixed(2))
+    : null;
+  const capabilityProvidedUnknownPositiveRate = capabilityProvidedUnknownKnownRuns > 0
+    ? Number(((capabilityProvidedUnknownPositiveRuns / capabilityProvidedUnknownKnownRuns) * 100).toFixed(2))
+    : null;
   const driftAlertRate = driftKnownRuns > 0
     ? Number(((driftAlertRuns / driftKnownRuns) * 100).toFixed(2))
     : null;
@@ -9380,6 +9450,16 @@ function buildAutoHandoffReleaseGateHistoryAggregates(entries = []) {
     scene_package_batch_pass_rate_percent: sceneBatchPassRate,
     avg_scene_package_batch_failure_count: avgSceneBatchFailureCount,
     max_scene_package_batch_failure_count: maxSceneBatchFailureCount,
+    capability_expected_unknown_known_runs: capabilityExpectedUnknownKnownRuns,
+    capability_expected_unknown_positive_runs: capabilityExpectedUnknownPositiveRuns,
+    capability_expected_unknown_positive_rate_percent: capabilityExpectedUnknownPositiveRate,
+    avg_capability_expected_unknown_count: avgCapabilityExpectedUnknownCount,
+    max_capability_expected_unknown_count: maxCapabilityExpectedUnknownCount,
+    capability_provided_unknown_known_runs: capabilityProvidedUnknownKnownRuns,
+    capability_provided_unknown_positive_runs: capabilityProvidedUnknownPositiveRuns,
+    capability_provided_unknown_positive_rate_percent: capabilityProvidedUnknownPositiveRate,
+    avg_capability_provided_unknown_count: avgCapabilityProvidedUnknownCount,
+    max_capability_provided_unknown_count: maxCapabilityProvidedUnknownCount,
     drift_known_runs: driftKnownRuns,
     drift_alert_total: driftAlertTotal,
     drift_alert_runs: driftAlertRuns,
@@ -9445,6 +9525,8 @@ async function buildAutoHandoffReleaseGateHistoryIndex(projectPath, options = {}
         risk_level: latestEntry.risk_level,
         scene_package_batch_passed: latestEntry.scene_package_batch_passed,
         scene_package_batch_failure_count: latestEntry.scene_package_batch_failure_count,
+        capability_expected_unknown_count: latestEntry.capability_expected_unknown_count,
+        capability_provided_unknown_count: latestEntry.capability_provided_unknown_count,
         release_gate_preflight_available: latestEntry.release_gate_preflight_available,
         release_gate_preflight_blocked: latestEntry.release_gate_preflight_blocked,
         require_release_gate_preflight: latestEntry.require_release_gate_preflight,
@@ -9490,6 +9572,8 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
     lines.push(`- Risk level: ${formatAutoHandoffRegressionValue(latest.risk_level)}`);
     lines.push(`- Scene package batch: ${latest.scene_package_batch_passed === true ? 'pass' : (latest.scene_package_batch_passed === false ? 'fail' : 'n/a')}`);
     lines.push(`- Scene package batch failures: ${formatAutoHandoffRegressionValue(latest.scene_package_batch_failure_count)}`);
+    lines.push(`- Capability expected unknown count: ${formatAutoHandoffRegressionValue(latest.capability_expected_unknown_count, '0')}`);
+    lines.push(`- Capability provided unknown count: ${formatAutoHandoffRegressionValue(latest.capability_provided_unknown_count, '0')}`);
     lines.push(`- Release preflight available: ${latest.release_gate_preflight_available === true ? 'yes' : (latest.release_gate_preflight_available === false ? 'no' : 'n/a')}`);
     lines.push(`- Release preflight blocked: ${latest.release_gate_preflight_blocked === true ? 'yes' : (latest.release_gate_preflight_blocked === false ? 'no' : 'n/a')}`);
     lines.push(`- Release preflight hard-gate: ${latest.require_release_gate_preflight === true ? 'enabled' : (latest.require_release_gate_preflight === false ? 'advisory' : 'n/a')}`);
@@ -9511,6 +9595,12 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
   lines.push(`- Scene package batch pass rate: ${formatAutoHandoffRegressionValue(aggregates.scene_package_batch_pass_rate_percent)}%`);
   lines.push(`- Scene package batch failed: ${formatAutoHandoffRegressionValue(aggregates.scene_package_batch_failed_count, '0')}`);
   lines.push(`- Avg scene package batch failures: ${formatAutoHandoffRegressionValue(aggregates.avg_scene_package_batch_failure_count)}`);
+  lines.push(`- Capability expected unknown positive rate: ${formatAutoHandoffRegressionValue(aggregates.capability_expected_unknown_positive_rate_percent)}%`);
+  lines.push(`- Avg capability expected unknown count: ${formatAutoHandoffRegressionValue(aggregates.avg_capability_expected_unknown_count)}`);
+  lines.push(`- Max capability expected unknown count: ${formatAutoHandoffRegressionValue(aggregates.max_capability_expected_unknown_count)}`);
+  lines.push(`- Capability provided unknown positive rate: ${formatAutoHandoffRegressionValue(aggregates.capability_provided_unknown_positive_rate_percent)}%`);
+  lines.push(`- Avg capability provided unknown count: ${formatAutoHandoffRegressionValue(aggregates.avg_capability_provided_unknown_count)}`);
+  lines.push(`- Max capability provided unknown count: ${formatAutoHandoffRegressionValue(aggregates.max_capability_provided_unknown_count)}`);
   lines.push(`- Drift alert runs: ${formatAutoHandoffRegressionValue(aggregates.drift_alert_runs, '0')}`);
   lines.push(`- Drift blocked runs: ${formatAutoHandoffRegressionValue(aggregates.drift_blocked_runs, '0')}`);
   lines.push(`- Drift alert rate: ${formatAutoHandoffRegressionValue(aggregates.drift_alert_rate_percent)}%`);
@@ -9542,6 +9632,14 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
       const sceneBatchFailures = formatAutoHandoffRegressionValue(
         entry && entry.scene_package_batch_failure_count
       );
+      const capabilityExpectedUnknown = formatAutoHandoffRegressionValue(
+        entry && entry.capability_expected_unknown_count,
+        '0'
+      );
+      const capabilityProvidedUnknown = formatAutoHandoffRegressionValue(
+        entry && entry.capability_provided_unknown_count,
+        '0'
+      );
       const preflightBlocked = entry && entry.release_gate_preflight_blocked === true
         ? 'yes'
         : (entry && entry.release_gate_preflight_blocked === false ? 'no' : 'n/a');
@@ -9554,7 +9652,8 @@ function renderAutoHandoffReleaseGateHistoryMarkdown(payload = {}) {
         : (entry && entry.drift_blocked === false ? 'no' : 'n/a');
       lines.push(
         `- ${tag} | passed=${passed} | risk=${risk} | scene-batch=${sceneBatch} | ` +
-        `scene-failures=${sceneBatchFailures} | preflight-blocked=${preflightBlocked} | hard-gate=${preflightHardGate} | ` +
+        `scene-failures=${sceneBatchFailures} | capability-unknown=${capabilityExpectedUnknown}/${capabilityProvidedUnknown} | ` +
+        `preflight-blocked=${preflightBlocked} | hard-gate=${preflightHardGate} | ` +
         `drift-alerts=${driftAlerts} | drift-blocked=${driftBlocked} | ` +
         `success=${successRate} | violations=${violations} | at=${evaluatedAt}`
       );

package/lib/data/moqui-capability-lexicon.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.02.18",
+  "version": "2026.02.18.1",
   "source": "sce-moqui-core",
   "capabilities": [
     {
@@ -8,7 +8,8 @@
         "order-query-read",
         "order-read",
         "moqui-order-query-read",
-        "moqui-order-read"
+        "moqui-order-read",
+        "scene.erp.order.query.read"
       ],
       "deprecated_aliases": [
         "order-query",
@@ -21,7 +22,8 @@
         "order-fulfillment-workflow",
         "order-fulfillment",
         "fulfillment-workflow",
-        "moqui-order-fulfillment"
+        "moqui-order-fulfillment",
+        "scene.erp.order.fulfillment.workflow"
       ],
       "deprecated_aliases": [
         "order-fulfilment-workflow",
@@ -34,7 +36,8 @@
         "inventory-reserve-adjust",
         "inventory-adjust",
         "inventory-reserve",
-        "moqui-inventory-reserve-adjust"
+        "moqui-inventory-reserve-adjust",
+        "scene.erp.inventory.reserve.adjust"
       ],
       "deprecated_aliases": [
         "inventory-adjustment",

package/package.json

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