scene-capability-engine 3.0.4 → 3.0.7

package/README.md

@@ -253,6 +253,7 @@ sequenceDiagram
 - 🌍 **[Environment Management](docs/environment-management-guide.md)** - Multi-environment configuration
 - 📦 **[Multi-Repository Management](docs/multi-repo-management-guide.md)** - Manage multiple Git repositories
 - 🎭 **[Scene Runtime](docs/scene-runtime-guide.md)** - Template engine, quality pipeline, ontology, Moqui ERP
+- ♻️ **[Moqui Standard Rebuild](docs/moqui-standard-rebuild-guide.md)** - Rebuild bootstrap bundle + page-copilot contract from metadata
 - 🤖 **[Multi-Agent Coordination](docs/multi-agent-coordination-guide.md)** - Parallel agent coordination
 - 📈 **[Value Observability](docs/value-observability-guide.md)** - KPI snapshot, baseline, trend, gate-ready evidence
 - 🔌 **[Integration Modes](docs/integration-modes.md)** - Three ways to integrate sce
@@ -411,12 +412,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,9 +829,27 @@ 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.
 
+Moqui standard rebuild helper (script-level recovery bootstrap):
+- `node scripts/moqui-standard-rebuild.js [--metadata <path>] [--out <path>] [--markdown-out <path>] [--bundle-out <path>] [--json]`: build a standard Moqui recovery bundle from metadata, including recommended SCE template matrix, recovery spec plan, handoff manifest seed, ontology seed, and page-copilot context contract.
+  - Output now includes `recovery.readiness_matrix`, `recovery.readiness_summary`, and `recovery.prioritized_gaps` for template capability matrix scoring and remediation planning.
+  - Bundle now includes `rebuild/matrix-remediation.lines` (gap remediation queue lines).
+  - Bundle now includes `rebuild/matrix-remediation-plan.json|.md` (gap-to-source-file remediation plan).
+  - This workflow is scoped to SCE outputs and does not mutate business project code directly.
+  - Recommended usage for rebuild target path: `E:/workspace/331-poc-rebuild` (keep `331-poc` repair stream isolated).
+
+Moqui rebuild gate helper (CI/pre-release readiness gate):
+- `node scripts/moqui-rebuild-gate.js [--metadata <path>] [--out <path>] [--markdown-out <path>] [--bundle-out <path>] [--min-ready <n>] [--max-partial <n>] [--max-gap <n>]`: run rebuild and fail when readiness gate is not met (default: ready>=6, partial<=0, gap<=0).
+- npm alias: `npm run gate:moqui-rebuild`
+
+Moqui metadata extractor helper (script-level catalog bootstrap):
+- `node scripts/moqui-metadata-extract.js [--project-dir <path>] [--out <path>] [--markdown-out <path>] [--json]`: build a normalized metadata catalog from multiple sources for rebuild automation. Default sources include Moqui XML resources (`entity/service/screen/form/rule/decision`), scene package contracts (`.kiro/specs/**/docs/scene-package.json`), handoff manifest/capability matrix, and handoff evidence JSON.
+  - Recommended first step before `moqui-standard-rebuild`.
+  - Keep extraction source read-only and run rebuild generation against SCE output directories.
+
 Recommended `.kiro/config/orchestrator.json`:
 
 ```json
@@ -838,12 +858,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-standard-rebuild-guide.md

@@ -0,0 +1,96 @@
+# Moqui Standard Rebuild Guide
+
+This guide bootstraps a standard Moqui recovery bundle using SCE templates and metadata.
+It is designed to avoid direct interference with an in-progress `331-poc` repair stream.
+
+## Goal
+
+- Rebuild baseline business capability assets from metadata.
+- Keep original Moqui technology stack unchanged.
+- Add a page-level human/AI copilot dialog contract for contextual fixes.
+
+## Recommended Workspace Strategy
+
+1. Keep SCE in `E:/workspace/kiro-spec-engine` for reusable rebuild tooling.
+2. Keep business rebuild target isolated (recommended): `E:/workspace/331-poc-rebuild`.
+3. Do not write generated recovery files into live `331-poc` unless explicitly approved.
+
+## Input Metadata (minimum)
+
+Provide a JSON file with at least one of these arrays:
+
+- `entities`
+- `services`
+- `screens`
+- `forms`
+
+Optional:
+
+- `business_rules`
+- `decisions`
+
+## Step 1: Extract Metadata (from Moqui project)
+
+```bash
+node scripts/moqui-metadata-extract.js \
+  --project-dir E:/workspace/your-moqui-project \
+  --out docs/moqui/metadata-catalog.json \
+  --markdown-out docs/moqui/metadata-catalog.md \
+  --json
+```
+
+`moqui-metadata-extract` now performs multi-source catalog extraction by default:
+- Moqui XML (`entity/service/screen/form/rule/decision`)
+- `scene-package.json` contracts in `.kiro/specs/**/docs/`
+- `docs/handoffs/handoff-manifest.json`
+- `docs/handoffs/capability-matrix.md`
+- `docs/handoffs/evidence/**/*.json`
+- `.kiro/recovery/salvage/**/*.json` (if present)
+
+## Step 2: Build Rebuild Bundle
+
+```bash
+node scripts/moqui-standard-rebuild.js \
+  --metadata docs/moqui/metadata-catalog.json \
+  --out .kiro/reports/recovery/moqui-standard-rebuild.json \
+  --markdown-out .kiro/reports/recovery/moqui-standard-rebuild.md \
+  --bundle-out .kiro/reports/recovery/moqui-standard-bundle \
+  --json
+```
+
+## Step 3: Run Rebuild Readiness Gate (recommended for CI/release)
+
+```bash
+node scripts/moqui-rebuild-gate.js \
+  --metadata docs/moqui/metadata-catalog.json \
+  --out .kiro/reports/recovery/moqui-standard-rebuild.json \
+  --markdown-out .kiro/reports/recovery/moqui-standard-rebuild.md \
+  --bundle-out .kiro/reports/recovery/moqui-standard-bundle
+```
+
+Defaults: `ready>=6`, `partial<=0`, `gap<=0`.
+
+## Generated Bundle
+
+- `handoff/handoff-manifest.json`: seed manifest for SCE handoff gates.
+- `ontology/moqui-ontology-seed.json`: initial ontology graph seed.
+- `rebuild/recovery-spec-plan.json`: ordered recovery spec list.
+- `rebuild/matrix-remediation.lines`: prioritized remediation queue lines derived from template readiness gaps.
+- `rebuild/matrix-remediation-plan.json`: gap-to-source-file remediation plan for quick 331 execution.
+- `rebuild/matrix-remediation-plan.md`: markdown view of remediation plan.
+- `copilot/page-context-contract.json`: page-context contract for copilot dialog.
+- `copilot/conversation-playbook.md`: operational playbook for human/AI page fixes.
+- rebuild report includes template readiness scoring (`recovery.readiness_matrix`) and prioritized remediation items (`recovery.prioritized_gaps`).
+
+## Default Moqui Template Matrix
+
+- `kse.scene--moqui-entity-model-core--0.1.0`
+- `kse.scene--moqui-service-contract-core--0.1.0`
+- `kse.scene--moqui-screen-flow-core--0.1.0`
+- `kse.scene--moqui-form-interaction-core--0.1.0`
+- `kse.scene--moqui-rule-decision-core--0.1.0`
+- `kse.scene--moqui-page-copilot-dialog--0.1.0`
+
+## Next Step for Business Project
+
+Use generated assets as input to a dedicated rebuild project (for example `331-poc-rebuild`) and execute normal SCE handoff + gate flows there.

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.7",
   "description": "SCE (Scene Capability Engine) - A CLI tool and npm package for spec-driven development with AI coding assistants.",
   "main": "index.js",
   "bin": {
@@ -35,6 +35,9 @@
     "test:brand-consistency": "node scripts/check-branding-consistency.js",
     "test:watch": "npx jest --watch",
     "coverage": "npx jest --coverage",
+    "report:moqui-metadata": "node scripts/moqui-metadata-extract.js --json",
+    "report:moqui-rebuild": "node scripts/moqui-standard-rebuild.js --json",
+    "gate:moqui-rebuild": "node scripts/moqui-rebuild-gate.js",
     "report:moqui-baseline": "node scripts/moqui-template-baseline-report.js --json",
     "report:moqui-core-regression": "node scripts/moqui-core-regression-suite.js --json",
     "prepublishOnly": "npm run test:full && npm run test:skip-audit && npm run test:brand-consistency",