scene-capability-engine 3.0.3 → 3.0.6

package/README.md

@@ -411,12 +411,14 @@ Tip: `sce spec bootstrap|pipeline run|gate run --specs ...` now defaults to this
   "maxParallel": 3,
   "timeoutSeconds": 900,
   "maxRetries": 2,
-  "rateLimitMaxRetries": 6,
-  "rateLimitBackoffBaseMs": 1000,
-  "rateLimitBackoffMaxMs": 30000,
+  "rateLimitMaxRetries": 8,
+  "rateLimitBackoffBaseMs": 1500,
+  "rateLimitBackoffMaxMs": 60000,
   "rateLimitAdaptiveParallel": true,
   "rateLimitParallelFloor": 1,
-  "rateLimitCooldownMs": 30000,
+  "rateLimitCooldownMs": 45000,
+  "rateLimitLaunchBudgetPerMinute": 8,
+  "rateLimitLaunchBudgetWindowMs": 60000,
   "apiKeyEnvVar": "CODEX_API_KEY",
   "codexArgs": ["--skip-git-repo-check"],
   "codexCommand": "npx @openai/codex"

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).
@@ -779,6 +787,7 @@ Dual-track handoff integration:
 - `sce auto handoff queue --manifest <path> [--out <path>] [--append] [--no-include-known-gaps] [--dry-run] [--json]`: generate close-loop batch goal queue from handoff manifest and optionally persist line-based queue file (default `.kiro/auto/handoff-goals.lines`).
 - `sce auto handoff template-diff --manifest <path> [--json]`: compare manifest templates against local template exports/registry and report `missing_in_local` and `extra_in_local`.
 - `sce auto handoff capability-matrix --manifest <path> [--strict] [--strict-warnings] [--min-capability-coverage <n>] [--min-capability-semantic <n>] [--no-require-capability-semantic] [--format <json|markdown>] [--out <path>] [--remediation-queue-out <path>] [--fail-on-gap] [--json]`: generate a fast Moqui capability matrix (`template-diff + baseline + capability coverage + semantic completeness`) and optionally fail fast on gaps.
+- When `manifest.capabilities` is empty, sce auto-infers canonical expected capabilities from `manifest.templates` using the Moqui lexicon before deciding whether capability coverage should be skipped.
 - `sce auto handoff run --manifest <path> [--out <path>] [--queue-out <path>] [--append] [--no-include-known-gaps] [--continue-from <session|latest|file>] [--continue-strategy <auto|pending|failed-only>] [--dry-run] [--strict] [--strict-warnings] [--no-dependency-batching] [--min-spec-success-rate <n>] [--max-risk-level <level>] [--max-moqui-matrix-regressions <n>] [--no-require-ontology-validation] [--no-require-moqui-baseline] [--min-capability-coverage <n>] [--no-require-capability-coverage] [--require-release-gate-preflight] [--release-evidence-window <n>] [--json]`: execute handoff end-to-end (`plan -> queue -> close-loop-batch -> observability`) with automatic report archive to `.kiro/reports/handoff-runs/<session>.json`.
   - Default mode is dependency-aware: spec integration goals are grouped into dependency batches and executed in topological order.
   - `--continue-from` resumes pending goals from an existing handoff run report (`latest`, session id, or JSON file path). For safety, sce enforces manifest-path consistency between the previous report and current run.
@@ -789,6 +798,7 @@ Dual-track handoff integration:
   - `moqui_baseline.summary` now includes `scope_breakdown`, `coverage_matrix`, and `gap_frequency` for ER/BR/decision closure tracking.
   - `moqui_baseline.compare` now includes `coverage_matrix_deltas` and `coverage_matrix_regressions` for trend-level entity/relation/rule/decision closure movement and negative-delta alerts (used by matrix-regression hard gate).
   - Run output includes `moqui_capability_coverage` snapshot by default (when manifest `capabilities` is declared), with artifacts at `.kiro/reports/release-evidence/moqui-capability-coverage.json` and `.kiro/reports/release-evidence/moqui-capability-coverage.md`.
+  - When `manifest.capabilities` is not declared, sce attempts lexicon-based capability inference from `manifest.templates` first; only fully non-mappable manifests keep capability coverage in skipped mode.
   - Run output includes `release_gate_preflight` (latest release gate history signal snapshot + blocked reasons) and carries this context into `warnings`.
   - `release_gate_preflight` is advisory by default; use `--require-release-gate-preflight` to hard-fail when preflight is unavailable/blocked.
   - When Moqui baseline/capability gates fail, sce auto-generates remediation queue lines at `.kiro/auto/moqui-remediation.lines`.
@@ -814,11 +824,14 @@ 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.
+  - Expected capability scope uses `manifest.capabilities` first; when empty, it infers canonical expected capabilities from `manifest.templates` and emits `expected_scope` metadata (`source`, `inferred_*`, `unresolved_templates`).
+  - 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`:
 
@@ -828,12 +841,14 @@ Recommended `.kiro/config/orchestrator.json`:
   "maxParallel": 3,
   "timeoutSeconds": 900,
   "maxRetries": 2,
-  "rateLimitMaxRetries": 6,
-  "rateLimitBackoffBaseMs": 1000,
-  "rateLimitBackoffMaxMs": 30000,
+  "rateLimitMaxRetries": 8,
+  "rateLimitBackoffBaseMs": 1500,
+  "rateLimitBackoffMaxMs": 60000,
   "rateLimitAdaptiveParallel": true,
   "rateLimitParallelFloor": 1,
-  "rateLimitCooldownMs": 30000,
+  "rateLimitCooldownMs": 45000,
+  "rateLimitLaunchBudgetPerMinute": 8,
+  "rateLimitLaunchBudgetWindowMs": 60000,
   "apiKeyEnvVar": "CODEX_API_KEY",
   "codexArgs": ["--skip-git-repo-check"],
   "codexCommand": "npx @openai/codex"

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

@@ -6848,6 +6848,75 @@ function collectUniqueIdentifiers(rawEntries, fieldCandidates, label) {
   return { values, warnings };
 }
 
+function normalizeAutoHandoffTemplateCapabilityCandidate(value) {
+  if (value === undefined || value === null) {
+    return null;
+  }
+  const raw = `${value}`.trim();
+  if (!raw) {
+    return null;
+  }
+  const normalizedPath = raw.toLowerCase().replace(/\\/g, '/');
+  const baseName = normalizedPath.split('/').pop() || normalizedPath;
+  let candidate = baseName.replace(/^[a-z0-9-]+\.scene--/, 'scene--');
+  candidate = candidate.replace(/^scene--/, '');
+  candidate = candidate.replace(
+    /--\d+\.\d+\.\d+(?:-[a-z0-9.-]+)?(?:\+[a-z0-9.-]+)?$/,
+    ''
+  );
+  candidate = candidate.replace(/--\d{4}(?:-\d{2}){1,2}(?:-[a-z0-9-]+)?$/, '');
+  return normalizeMoquiCapabilityToken(candidate);
+}
+
+function inferManifestCapabilitiesFromTemplates(
+  templateIdentifiers = [],
+  lexiconIndex = MOQUI_CAPABILITY_LEXICON_INDEX
+) {
+  const inferred = [];
+  const inferredSet = new Set();
+  const inferredFrom = [];
+  const unresolvedTemplates = [];
+  const unresolvedSet = new Set();
+
+  if (!Array.isArray(templateIdentifiers) || templateIdentifiers.length === 0) {
+    return {
+      capabilities: inferred,
+      inferred_from: inferredFrom,
+      unresolved_templates: unresolvedTemplates
+    };
+  }
+
+  for (const templateIdentifier of templateIdentifiers) {
+    const candidate = normalizeAutoHandoffTemplateCapabilityCandidate(templateIdentifier);
+    if (!candidate) {
+      continue;
+    }
+    const descriptor = resolveMoquiCapabilityDescriptor(candidate, lexiconIndex);
+    if (descriptor && descriptor.is_known) {
+      if (!inferredSet.has(descriptor.canonical)) {
+        inferredSet.add(descriptor.canonical);
+        inferred.push(descriptor.canonical);
+      }
+      inferredFrom.push({
+        template: templateIdentifier,
+        normalized_template: candidate,
+        capability: descriptor.canonical
+      });
+      continue;
+    }
+    if (!unresolvedSet.has(templateIdentifier)) {
+      unresolvedSet.add(templateIdentifier);
+      unresolvedTemplates.push(templateIdentifier);
+    }
+  }
+
+  return {
+    capabilities: inferred,
+    inferred_from: inferredFrom,
+    unresolved_templates: unresolvedTemplates
+  };
+}
+
 function normalizeHandoffDependencyEntry(entry) {
   return normalizeHandoffIdentifier(entry, [
     'name',
@@ -7128,8 +7197,32 @@ function normalizeAutoHandoffManifest(payload = {}) {
     'capabilities'
   );
   validationWarnings.push(...capabilitiesCollected.warnings);
+  const capabilityInference = inferManifestCapabilitiesFromTemplates(
+    templatesCollected.values,
+    MOQUI_CAPABILITY_LEXICON_INDEX
+  );
+  let capabilityValues = capabilitiesCollected.values;
+  let capabilitySource = 'manifest';
   if (capabilitiesCollected.values.length === 0) {
-    validationWarnings.push('capabilities is empty; capability coverage gate will be skipped unless capabilities are declared');
+    if (capabilityInference.capabilities.length > 0) {
+      capabilityValues = capabilityInference.capabilities;
+      capabilitySource = 'inferred-from-templates';
+      validationWarnings.push(
+        `capabilities not declared; inferred ${capabilityValues.length} canonical capabilities from templates`
+      );
+      if (capabilityInference.unresolved_templates.length > 0) {
+        const preview = capabilityInference.unresolved_templates.slice(0, 5).join(', ');
+        const suffix = capabilityInference.unresolved_templates.length > 5
+          ? ` (+${capabilityInference.unresolved_templates.length - 5} more)`
+          : '';
+        validationWarnings.push(
+          `template capability inference skipped ${capabilityInference.unresolved_templates.length} templates not found in lexicon: ${preview}${suffix}`
+        );
+      }
+    } else {
+      capabilitySource = 'none';
+      validationWarnings.push('capabilities is empty; capability coverage gate will be skipped unless capabilities are declared');
+    }
   }
 
   const knownGapCollected = collectKnownGaps(payload.known_gaps);
@@ -7153,7 +7246,16 @@ function normalizeAutoHandoffManifest(payload = {}) {
     spec_descriptors: specsCollected.descriptors,
     dependency_batches: dependencyBatches,
     templates: templatesCollected.values,
-    capabilities: capabilitiesCollected.values,
+    capabilities: capabilityValues,
+    capability_source: capabilitySource,
+    capability_inference: {
+      applied: capabilitySource === 'inferred-from-templates',
+      inferred_count: capabilityInference.capabilities.length,
+      inferred_capabilities: capabilityInference.capabilities,
+      inferred_from_templates: capabilityInference.inferred_from,
+      unresolved_template_count: capabilityInference.unresolved_templates.length,
+      unresolved_templates: capabilityInference.unresolved_templates
+    },
     known_gaps: knownGapCollected.gaps,
     ontology_validation: ontologyValidation,
     next_batch: nextBatch,
@@ -7268,6 +7370,17 @@ async function buildAutoHandoffPlan(projectPath, options = {}) {
       dependency_batches: handoff.dependency_batches,
       templates: handoff.templates,
       capabilities: handoff.capabilities,
+      capability_source: handoff.capability_source || 'manifest',
+      capability_inference: handoff.capability_inference && typeof handoff.capability_inference === 'object'
+        ? handoff.capability_inference
+        : {
+          applied: false,
+          inferred_count: 0,
+          inferred_capabilities: [],
+          inferred_from_templates: [],
+          unresolved_template_count: 0,
+          unresolved_templates: []
+        },
       known_gaps: handoff.known_gaps,
       ontology_validation: handoff.ontology_validation,
       next_batch: handoff.next_batch
@@ -8954,6 +9067,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 +9189,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 +9357,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 +9411,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 +9513,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 +9563,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 +9638,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 +9685,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 +9708,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 +9745,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 +9765,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}`
       );
@@ -13373,6 +13585,18 @@ async function buildAutoHandoffCapabilityMatrix(projectPath, options = {}) {
       capability_count: Array.isArray(plan.handoff && plan.handoff.capabilities)
         ? plan.handoff.capabilities.length
         : 0,
+      capability_source: normalizeHandoffText(plan.handoff && plan.handoff.capability_source) || 'manifest',
+      capability_inference: plan.handoff && plan.handoff.capability_inference &&
+        typeof plan.handoff.capability_inference === 'object'
+        ? plan.handoff.capability_inference
+        : {
+          applied: false,
+          inferred_count: 0,
+          inferred_capabilities: [],
+          inferred_from_templates: [],
+          unresolved_template_count: 0,
+          unresolved_templates: []
+        },
       capabilities: Array.isArray(plan.handoff && plan.handoff.capabilities)
         ? plan.handoff.capabilities
         : []

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/lib/orchestrator/orchestration-engine.js

@@ -16,13 +16,13 @@ const path = require('path');
 const fsUtils = require('../utils/fs-utils');
 
 const SPECS_DIR = '.kiro/specs';
-const DEFAULT_RATE_LIMIT_MAX_RETRIES = 6;
-const DEFAULT_RATE_LIMIT_BACKOFF_BASE_MS = 1000;
-const DEFAULT_RATE_LIMIT_BACKOFF_MAX_MS = 30000;
+const DEFAULT_RATE_LIMIT_MAX_RETRIES = 8;
+const DEFAULT_RATE_LIMIT_BACKOFF_BASE_MS = 1500;
+const DEFAULT_RATE_LIMIT_BACKOFF_MAX_MS = 60000;
 const DEFAULT_RATE_LIMIT_ADAPTIVE_PARALLEL = true;
 const DEFAULT_RATE_LIMIT_PARALLEL_FLOOR = 1;
-const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 30000;
-const DEFAULT_RATE_LIMIT_LAUNCH_BUDGET_PER_MINUTE = 12;
+const DEFAULT_RATE_LIMIT_COOLDOWN_MS = 45000;
+const DEFAULT_RATE_LIMIT_LAUNCH_BUDGET_PER_MINUTE = 8;
 const DEFAULT_RATE_LIMIT_LAUNCH_BUDGET_WINDOW_MS = 60000;
 const DEFAULT_AGENT_WAIT_TIMEOUT_SECONDS = 600;
 const AGENT_WAIT_TIMEOUT_GRACE_MS = 30000;
@@ -35,6 +35,7 @@ const RATE_LIMIT_ERROR_PATTERNS = [
   /resource exhausted/i,
   /quota exceeded/i,
   /exceeded.*quota/i,
+  /exceeded retry limit/i,
   /requests per minute/i,
   /tokens per minute/i,
 ];

package/lib/orchestrator/orchestrator-config.js

@@ -44,13 +44,13 @@ const DEFAULT_CONFIG = Object.freeze({
   maxParallel: 3,
   timeoutSeconds: 600,
   maxRetries: 2,
-  rateLimitMaxRetries: 6,
-  rateLimitBackoffBaseMs: 1000,
-  rateLimitBackoffMaxMs: 30000,
+  rateLimitMaxRetries: 8,
+  rateLimitBackoffBaseMs: 1500,
+  rateLimitBackoffMaxMs: 60000,
   rateLimitAdaptiveParallel: true,
   rateLimitParallelFloor: 1,
-  rateLimitCooldownMs: 30000,
-  rateLimitLaunchBudgetPerMinute: 12,
+  rateLimitCooldownMs: 45000,
+  rateLimitLaunchBudgetPerMinute: 8,
   rateLimitLaunchBudgetWindowMs: 60000,
   apiKeyEnvVar: 'CODEX_API_KEY',
   bootstrapTemplate: null,

package/package.json

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