scene-capability-engine 3.0.4 → 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

@@ -787,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.
@@ -797,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`.
@@ -827,6 +829,7 @@ Dual-track handoff integration:
 
 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.
 
@@ -838,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/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
@@ -13472,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/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.4",
+  "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": {